c_src/abstract_compiler.sep.2.c

   1 #include "abstract_compiler.sep.0.h"
   2 /* method abstract_compiler#AbstractCompilerVisitor#ret for (self: AbstractCompilerVisitor, RuntimeVariable) */
   3 void abstract_compiler__AbstractCompilerVisitor__ret(val* self, val* p0) {
   4 val* var_s /* var s: RuntimeVariable */;
   5 val* var /* : nullable Frame */;
   6 val* var1 /* : nullable RuntimeVariable */;
   7 static val* varonce;
   8 val* var2 /* : String */;
   9 char* var3 /* : NativeString */;
  10 long var4 /* : Int */;
  11 val* var5 /* : String */;
  12 val* var6 /* : nullable Frame */;
  13 val* var7 /* : nullable String */;
  14 static val* varonce8;
  15 val* var9 /* : String */;
  16 char* var10 /* : NativeString */;
  17 long var11 /* : Int */;
  18 val* var12 /* : String */;
  19 val* var13 /* : Array[Object] */;
  20 long var14 /* : Int */;
  21 val* var15 /* : NativeArray[Object] */;
  22 val* var16 /* : String */;
  23 var_s = p0;
  24 var = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__frame]))(self) /* frame on <self:AbstractCompilerVisitor>*/;
  25 if (var == NULL) {
  26 fprintf(stderr, "Runtime error: %s", "Reciever is null");
  27 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 925);
  28 exit(1);
  29 } else {
  30 var1 = ((val* (*)(val*))(var->class->vft[COLOR_abstract_compiler__Frame__returnvar]))(var) /* returnvar on <var:nullable Frame>*/;
  31 }
  32 if (var1 == NULL) {
  33 fprintf(stderr, "Runtime error: %s", "Cast failed");
  34 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 925);
  35 exit(1);
  36 }
  37 ((void (*)(val*, val*, val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__assign]))(self, var1, var_s) /* assign on <self:AbstractCompilerVisitor>*/;
  38 if (varonce) {
  39 var2 = varonce;
  40 } else {
  41 var3 = "goto ";
  42 var4 = 5;
  43 var5 = string__NativeString__to_s_with_length(var3, var4);
  44 var2 = var5;
  45 varonce = var2;
  46 }
  47 var6 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__frame]))(self) /* frame on <self:AbstractCompilerVisitor>*/;
  48 if (var6 == NULL) {
  49 fprintf(stderr, "Runtime error: %s", "Reciever is null");
  50 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 926);
  51 exit(1);
  52 } else {
  53 var7 = ((val* (*)(val*))(var6->class->vft[COLOR_abstract_compiler__Frame__returnlabel]))(var6) /* returnlabel on <var6:nullable Frame>*/;
  54 }
  55 if (var7 == NULL) {
  56 fprintf(stderr, "Runtime error: %s", "Cast failed");
  57 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 926);
  58 exit(1);
  59 }
  60 if (varonce8) {
  61 var9 = varonce8;
  62 } else {
  63 var10 = ";";
  64 var11 = 1;
  65 var12 = string__NativeString__to_s_with_length(var10, var11);
  66 var9 = var12;
  67 varonce8 = var9;
  68 }
  69 var13 = NEW_array__Array(&type_array__Arraykernel__Object);
  70 { /* var13 = array_instance Array[Object] */
  71 var14 = 3;
  72 var15 = NEW_array__NativeArray(var14, &type_array__NativeArraykernel__Object);
  73 ((struct instance_array__NativeArray*)var15)->values[0] = (val*) var2;
  74 ((struct instance_array__NativeArray*)var15)->values[1] = (val*) var7;
  75 ((struct instance_array__NativeArray*)var15)->values[2] = (val*) var9;
  76 ((void (*)(val*, val*, long))(var13->class->vft[COLOR_array__Array__with_native]))(var13, var15, var14) /* with_native on <var13:Array[Object]>*/;
  77 CHECK_NEW_array__Array(var13);
  78 }
  79 var16 = ((val* (*)(val*))(var13->class->vft[COLOR_string__Object__to_s]))(var13) /* to_s on <var13:Array[Object]>*/;
  80 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(self, var16) /* add on <self:AbstractCompilerVisitor>*/;
  81 RET_LABEL:;
  82 }
  83 /* method abstract_compiler#AbstractCompilerVisitor#ret for (self: Object, RuntimeVariable) */
  84 void VIRTUAL_abstract_compiler__AbstractCompilerVisitor__ret(val* self, val* p0) {
  85 abstract_compiler__AbstractCompilerVisitor__ret(self, p0);
  86 RET_LABEL:;
  87 }
  88 /* method abstract_compiler#AbstractCompilerVisitor#stmt for (self: AbstractCompilerVisitor, nullable AExpr) */
  89 void abstract_compiler__AbstractCompilerVisitor__stmt(val* self, val* p0) {
  90 val* var_nexpr /* var nexpr: nullable AExpr */;
  91 val* var /* : null */;
  92 short int var1 /* : Bool */;
  93 val* var2 /* : nullable ANode */;
  94 val* var_old /* var old: nullable ANode */;
  95 var_nexpr = p0;
  96 var = NULL;
  97 if (var_nexpr == NULL) {
  98 var1 = 1; /* is null */
  99 } else {
 100 var1 = 0; /* arg is null but recv is not */
 101 }
 102 if (var1){
 103 goto RET_LABEL;
 104 } else {
 105 }
 106 var2 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__current_node]))(self) /* current_node on <self:AbstractCompilerVisitor>*/;
 107 var_old = var2;
 108 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__current_node_61d]))(self, var_nexpr) /* current_node= on <self:AbstractCompilerVisitor>*/;
 109 ((void (*)(val*, val*))(var_nexpr->class->vft[COLOR_abstract_compiler__AExpr__stmt]))(var_nexpr, self) /* stmt on <var_nexpr:nullable AExpr(AExpr)>*/;
 110 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__current_node_61d]))(self, var_old) /* current_node= on <self:AbstractCompilerVisitor>*/;
 111 RET_LABEL:;
 112 }
 113 /* method abstract_compiler#AbstractCompilerVisitor#stmt for (self: Object, nullable AExpr) */
 114 void VIRTUAL_abstract_compiler__AbstractCompilerVisitor__stmt(val* self, val* p0) {
 115 abstract_compiler__AbstractCompilerVisitor__stmt(self, p0);
 116 RET_LABEL:;
 117 }
 118 /* method abstract_compiler#AbstractCompilerVisitor#expr for (self: AbstractCompilerVisitor, AExpr, nullable MType): RuntimeVariable */
 119 val* abstract_compiler__AbstractCompilerVisitor__expr(val* self, val* p0, val* p1) {
 120 val* var /* : RuntimeVariable */;
 121 val* var_nexpr /* var nexpr: AExpr */;
 122 val* var_mtype /* var mtype: nullable MType */;
 123 val* var1 /* : nullable ANode */;
 124 val* var_old /* var old: nullable ANode */;
 125 val* var2 /* : nullable RuntimeVariable */;
 126 val* var_res /* var res: RuntimeVariable */;
 127 val* var3 /* : null */;
 128 short int var4 /* : Bool */;
 129 val* var5 /* : MType */;
 130 val* var6 /* : RuntimeVariable */;
 131 val* var7 /* : nullable MType */;
 132 val* var8 /* : RuntimeVariable */;
 133 val* var9 /* : nullable MType */;
 134 val* var_implicit_cast_to /* var implicit_cast_to: nullable MType */;
 135 short int var10 /* : Bool */;
 136 val* var11 /* : null */;
 137 short int var12 /* : Bool */;
 138 short int var_ /* var : Bool */;
 139 val* var13 /* : AbstractCompiler */;
 140 val* var14 /* : ModelBuilder */;
 141 val* var15 /* : ToolContext */;
 142 val* var16 /* : OptionBool */;
 143 val* var17 /* : nullable Object */;
 144 short int var18 /* : Bool */;
 145 short int var19 /* : Bool */;
 146 static val* varonce;
 147 val* var20 /* : String */;
 148 char* var21 /* : NativeString */;
 149 long var22 /* : Int */;
 150 val* var23 /* : String */;
 151 val* var24 /* : RuntimeVariable */;
 152 var_nexpr = p0;
 153 var_mtype = p1;
 154 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__current_node]))(self) /* current_node on <self:AbstractCompilerVisitor>*/;
 155 var_old = var1;
 156 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__current_node_61d]))(self, var_nexpr) /* current_node= on <self:AbstractCompilerVisitor>*/;
 157 var2 = ((val* (*)(val*, val*))(var_nexpr->class->vft[COLOR_abstract_compiler__AExpr__expr]))(var_nexpr, self) /* expr on <var_nexpr:AExpr>*/;
 158 if (var2 == NULL) {
 159 fprintf(stderr, "Runtime error: %s", "Cast failed");
 160 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 945);
 161 exit(1);
 162 }
 163 var_res = var2;
 164 var3 = NULL;
 165 if (var_mtype == NULL) {
 166 var4 = 0; /* is null */
 167 } else {
 168 var4 = 1; /* arg is null and recv is not */
 169 }
 170 if (var4){
 171 var5 = ((val* (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__anchor]))(self, var_mtype) /* anchor on <self:AbstractCompilerVisitor>*/;
 172 var_mtype = var5;
 173 var6 = ((val* (*)(val*, val*, val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__autobox]))(self, var_res, var_mtype) /* autobox on <self:AbstractCompilerVisitor>*/;
 174 var_res = var6;
 175 } else {
 176 }
 177 var7 = ((val* (*)(val*))(var_nexpr->class->vft[COLOR_typing__AExpr__mtype]))(var_nexpr) /* mtype on <var_nexpr:AExpr>*/;
 178 if (var7 == NULL) {
 179 fprintf(stderr, "Runtime error: %s", "Cast failed");
 180 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 950);
 181 exit(1);
 182 }
 183 var8 = ((val* (*)(val*, val*, val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__autoadapt]))(self, var_res, var7) /* autoadapt on <self:AbstractCompilerVisitor>*/;
 184 var_res = var8;
 185 var9 = ((val* (*)(val*))(var_nexpr->class->vft[COLOR_typing__AExpr__implicit_cast_to]))(var_nexpr) /* implicit_cast_to on <var_nexpr:AExpr>*/;
 186 var_implicit_cast_to = var9;
 187 var11 = NULL;
 188 if (var_implicit_cast_to == NULL) {
 189 var12 = 0; /* is null */
 190 } else {
 191 var12 = 1; /* arg is null and recv is not */
 192 }
 193 var_ = var12;
 194 if (var12){
 195 var13 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__compiler]))(self) /* compiler on <self:AbstractCompilerVisitor>*/;
 196 var14 = ((val* (*)(val*))(var13->class->vft[COLOR_abstract_compiler__AbstractCompiler__modelbuilder]))(var13) /* modelbuilder on <var13:AbstractCompiler>*/;
 197 var15 = ((val* (*)(val*))(var14->class->vft[COLOR_modelbuilder__ModelBuilder__toolcontext]))(var14) /* toolcontext on <var14:ModelBuilder>*/;
 198 var16 = ((val* (*)(val*))(var15->class->vft[COLOR_abstract_compiler__ToolContext__opt_no_check_autocast]))(var15) /* opt_no_check_autocast on <var15:ToolContext>*/;
 199 var17 = ((val* (*)(val*))(var16->class->vft[COLOR_opts__Option__value]))(var16) /* value on <var16:OptionBool>*/;
 200 var18 = ((struct instance_kernel__Bool*)var17)->value; /* autounbox from nullable Object to Bool */;
 201 var19 = !var18;
 202 var10 = var19;
 203 } else {
 204 var10 = var_;
 205 }
 206 if (var10){
 207 if (varonce) {
 208 var20 = varonce;
 209 } else {
 210 var21 = "auto";
 211 var22 = 4;
 212 var23 = string__NativeString__to_s_with_length(var21, var22);
 213 var20 = var23;
 214 varonce = var20;
 215 }
 216 ((void (*)(val*, val*, val*, val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add_cast]))(self, var_res, var_implicit_cast_to, var20) /* add_cast on <self:AbstractCompilerVisitor>*/;
 217 var24 = ((val* (*)(val*, val*, val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__autoadapt]))(self, var_res, var_implicit_cast_to) /* autoadapt on <self:AbstractCompilerVisitor>*/;
 218 var_res = var24;
 219 } else {
 220 }
 221 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__current_node_61d]))(self, var_old) /* current_node= on <self:AbstractCompilerVisitor>*/;
 222 var = var_res;
 223 goto RET_LABEL;
 224 RET_LABEL:;
 225 return var;
 226 }
 227 /* method abstract_compiler#AbstractCompilerVisitor#expr for (self: Object, AExpr, nullable MType): RuntimeVariable */
 228 val* VIRTUAL_abstract_compiler__AbstractCompilerVisitor__expr(val* self, val* p0, val* p1) {
 229 val* var /* : RuntimeVariable */;
 230 val* var1 /* : RuntimeVariable */;
 231 var1 = abstract_compiler__AbstractCompilerVisitor__expr(self, p0, p1);
 232 var = var1;
 233 RET_LABEL:;
 234 return var;
 235 }
 236 /* method abstract_compiler#AbstractCompilerVisitor#expr_bool for (self: AbstractCompilerVisitor, AExpr): RuntimeVariable */
 237 val* abstract_compiler__AbstractCompilerVisitor__expr_bool(val* self, val* p0) {
 238 val* var /* : RuntimeVariable */;
 239 val* var_nexpr /* var nexpr: AExpr */;
 240 val* var1 /* : MClassType */;
 241 val* var2 /* : RuntimeVariable */;
 242 var_nexpr = p0;
 243 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__bool_type]))(self) /* bool_type on <self:AbstractCompilerVisitor>*/;
 244 var2 = ((val* (*)(val*, val*, val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__expr]))(self, var_nexpr, var1) /* expr on <self:AbstractCompilerVisitor>*/;
 245 var = var2;
 246 goto RET_LABEL;
 247 RET_LABEL:;
 248 return var;
 249 }
 250 /* method abstract_compiler#AbstractCompilerVisitor#expr_bool for (self: Object, AExpr): RuntimeVariable */
 251 val* VIRTUAL_abstract_compiler__AbstractCompilerVisitor__expr_bool(val* self, val* p0) {
 252 val* var /* : RuntimeVariable */;
 253 val* var1 /* : RuntimeVariable */;
 254 var1 = abstract_compiler__AbstractCompilerVisitor__expr_bool(self, p0);
 255 var = var1;
 256 RET_LABEL:;
 257 return var;
 258 }
 259 /* method abstract_compiler#AbstractCompilerVisitor#debug for (self: AbstractCompilerVisitor, String) */
 260 void abstract_compiler__AbstractCompilerVisitor__debug(val* self, val* p0) {
 261 val* var_message /* var message: String */;
 262 val* var /* : nullable ANode */;
 263 val* var_node /* var node: nullable ANode */;
 264 val* var1 /* : null */;
 265 short int var2 /* : Bool */;
 266 static val* varonce;
 267 val* var3 /* : String */;
 268 char* var4 /* : NativeString */;
 269 long var5 /* : Int */;
 270 val* var6 /* : String */;
 271 val* var7 /* : Array[Object] */;
 272 long var8 /* : Int */;
 273 val* var9 /* : NativeArray[Object] */;
 274 val* var10 /* : String */;
 275 static val* varonce11;
 276 val* var12 /* : String */;
 277 char* var13 /* : NativeString */;
 278 long var14 /* : Int */;
 279 val* var15 /* : String */;
 280 static val* varonce16;
 281 val* var17 /* : String */;
 282 char* var18 /* : NativeString */;
 283 long var19 /* : Int */;
 284 val* var20 /* : String */;
 285 val* var21 /* : Array[Object] */;
 286 long var22 /* : Int */;
 287 val* var23 /* : NativeArray[Object] */;
 288 val* var24 /* : String */;
 289 var_message = p0;
 290 var = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__current_node]))(self) /* current_node on <self:AbstractCompilerVisitor>*/;
 291 var_node = var;
 292 var1 = NULL;
 293 if (var_node == NULL) {
 294 var2 = 1; /* is null */
 295 } else {
 296 var2 = 0; /* arg is null but recv is not */
 297 }
 298 if (var2){
 299 if (varonce) {
 300 var3 = varonce;
 301 } else {
 302 var4 = "?: ";
 303 var5 = 3;
 304 var6 = string__NativeString__to_s_with_length(var4, var5);
 305 var3 = var6;
 306 varonce = var3;
 307 }
 308 var7 = NEW_array__Array(&type_array__Arraykernel__Object);
 309 { /* var7 = array_instance Array[Object] */
 310 var8 = 2;
 311 var9 = NEW_array__NativeArray(var8, &type_array__NativeArraykernel__Object);
 312 ((struct instance_array__NativeArray*)var9)->values[0] = (val*) var3;
 313 ((struct instance_array__NativeArray*)var9)->values[1] = (val*) var_message;
 314 ((void (*)(val*, val*, long))(var7->class->vft[COLOR_array__Array__with_native]))(var7, var9, var8) /* with_native on <var7:Array[Object]>*/;
 315 CHECK_NEW_array__Array(var7);
 316 }
 317 var10 = ((val* (*)(val*))(var7->class->vft[COLOR_string__Object__to_s]))(var7) /* to_s on <var7:Array[Object]>*/;
 318 ((void (*)(val*, val*))(self->class->vft[COLOR_file__Object__print]))(self, var10) /* print on <self:AbstractCompilerVisitor>*/;
 319 } else {
 320 ((void (*)(val*, val*))(var_node->class->vft[COLOR_parser_nodes__ANode__debug]))(var_node, var_message) /* debug on <var_node:nullable ANode(ANode)>*/;
 321 }
 322 if (varonce11) {
 323 var12 = varonce11;
 324 } else {
 325 var13 = "/* DEBUG: ";
 326 var14 = 10;
 327 var15 = string__NativeString__to_s_with_length(var13, var14);
 328 var12 = var15;
 329 varonce11 = var12;
 330 }
 331 if (varonce16) {
 332 var17 = varonce16;
 333 } else {
 334 var18 = " */";
 335 var19 = 3;
 336 var20 = string__NativeString__to_s_with_length(var18, var19);
 337 var17 = var20;
 338 varonce16 = var17;
 339 }
 340 var21 = NEW_array__Array(&type_array__Arraykernel__Object);
 341 { /* var21 = array_instance Array[Object] */
 342 var22 = 3;
 343 var23 = NEW_array__NativeArray(var22, &type_array__NativeArraykernel__Object);
 344 ((struct instance_array__NativeArray*)var23)->values[0] = (val*) var12;
 345 ((struct instance_array__NativeArray*)var23)->values[1] = (val*) var_message;
 346 ((struct instance_array__NativeArray*)var23)->values[2] = (val*) var17;
 347 ((void (*)(val*, val*, long))(var21->class->vft[COLOR_array__Array__with_native]))(var21, var23, var22) /* with_native on <var21:Array[Object]>*/;
 348 CHECK_NEW_array__Array(var21);
 349 }
 350 var24 = ((val* (*)(val*))(var21->class->vft[COLOR_string__Object__to_s]))(var21) /* to_s on <var21:Array[Object]>*/;
 351 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(self, var24) /* add on <self:AbstractCompilerVisitor>*/;
 352 RET_LABEL:;
 353 }
 354 /* method abstract_compiler#AbstractCompilerVisitor#debug for (self: Object, String) */
 355 void VIRTUAL_abstract_compiler__AbstractCompilerVisitor__debug(val* self, val* p0) {
 356 abstract_compiler__AbstractCompilerVisitor__debug(self, p0);
 357 RET_LABEL:;
 358 }
 359 /* method abstract_compiler#AbstractRuntimeFunction#mmethoddef for (self: AbstractRuntimeFunction): MMethodDef */
 360 val* abstract_compiler__AbstractRuntimeFunction__mmethoddef(val* self) {
 361 val* var /* : MMethodDef */;
 362 val* var1 /* : MMethodDef */;
 363 var1 = self->attrs[COLOR_abstract_compiler__AbstractRuntimeFunction___64dmmethoddef].val; /* @mmethoddef on <self:AbstractRuntimeFunction> */
 364 if (var1 == NULL) {
 365 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @mmethoddef");
 366 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 983);
 367 exit(1);
 368 }
 369 var = var1;
 370 RET_LABEL:;
 371 return var;
 372 }
 373 /* method abstract_compiler#AbstractRuntimeFunction#mmethoddef for (self: Object): MMethodDef */
 374 val* VIRTUAL_abstract_compiler__AbstractRuntimeFunction__mmethoddef(val* self) {
 375 val* var /* : MMethodDef */;
 376 val* var1 /* : MMethodDef */;
 377 var1 = abstract_compiler__AbstractRuntimeFunction__mmethoddef(self);
 378 var = var1;
 379 RET_LABEL:;
 380 return var;
 381 }
 382 /* method abstract_compiler#AbstractRuntimeFunction#mmethoddef= for (self: AbstractRuntimeFunction, MMethodDef) */
 383 void abstract_compiler__AbstractRuntimeFunction__mmethoddef_61d(val* self, val* p0) {
 384 self->attrs[COLOR_abstract_compiler__AbstractRuntimeFunction___64dmmethoddef].val = p0; /* @mmethoddef on <self:AbstractRuntimeFunction> */
 385 RET_LABEL:;
 386 }
 387 /* method abstract_compiler#AbstractRuntimeFunction#mmethoddef= for (self: Object, MMethodDef) */
 388 void VIRTUAL_abstract_compiler__AbstractRuntimeFunction__mmethoddef_61d(val* self, val* p0) {
 389 abstract_compiler__AbstractRuntimeFunction__mmethoddef_61d(self, p0);
 390 RET_LABEL:;
 391 }
 392 /* method abstract_compiler#AbstractRuntimeFunction#c_name for (self: AbstractRuntimeFunction): String */
 393 val* abstract_compiler__AbstractRuntimeFunction__c_name(val* self) {
 394 val* var /* : String */;
 395 val* var1 /* : nullable String */;
 396 val* var_res /* var res: nullable String */;
 397 val* var2 /* : null */;
 398 short int var3 /* : Bool */;
 399 val* var4 /* : String */;
 400 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__AbstractRuntimeFunction__c_name_cache]))(self) /* c_name_cache on <self:AbstractRuntimeFunction>*/;
 401 var_res = var1;
 402 var2 = NULL;
 403 if (var_res == NULL) {
 404 var3 = 0; /* is null */
 405 } else {
 406 var3 = 1; /* arg is null and recv is not */
 407 }
 408 if (var3){
 409 var = var_res;
 410 goto RET_LABEL;
 411 } else {
 412 }
 413 var4 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__AbstractRuntimeFunction__build_c_name]))(self) /* build_c_name on <self:AbstractRuntimeFunction>*/;
 414 var_res = var4;
 415 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__AbstractRuntimeFunction__c_name_cache_61d]))(self, var_res) /* c_name_cache= on <self:AbstractRuntimeFunction>*/;
 416 var = var_res;
 417 goto RET_LABEL;
 418 RET_LABEL:;
 419 return var;
 420 }
 421 /* method abstract_compiler#AbstractRuntimeFunction#c_name for (self: Object): String */
 422 val* VIRTUAL_abstract_compiler__AbstractRuntimeFunction__c_name(val* self) {
 423 val* var /* : String */;
 424 val* var1 /* : String */;
 425 var1 = abstract_compiler__AbstractRuntimeFunction__c_name(self);
 426 var = var1;
 427 RET_LABEL:;
 428 return var;
 429 }
 430 /* method abstract_compiler#AbstractRuntimeFunction#build_c_name for (self: AbstractRuntimeFunction): String */
 431 val* abstract_compiler__AbstractRuntimeFunction__build_c_name(val* self) {
 432 val* var /* : String */;
 433 const char* var_class_name;
 434 var_class_name = self == NULL ? "null" : self->type->name;
 435 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "build_c_name", var_class_name);
 436 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 997);
 437 exit(1);
 438 RET_LABEL:;
 439 return var;
 440 }
 441 /* method abstract_compiler#AbstractRuntimeFunction#build_c_name for (self: Object): String */
 442 val* VIRTUAL_abstract_compiler__AbstractRuntimeFunction__build_c_name(val* self) {
 443 val* var /* : String */;
 444 val* var1 /* : String */;
 445 var1 = abstract_compiler__AbstractRuntimeFunction__build_c_name(self);
 446 var = var1;
 447 RET_LABEL:;
 448 return var;
 449 }
 450 /* method abstract_compiler#AbstractRuntimeFunction#c_name_cache for (self: AbstractRuntimeFunction): nullable String */
 451 val* abstract_compiler__AbstractRuntimeFunction__c_name_cache(val* self) {
 452 val* var /* : nullable String */;
 453 val* var1 /* : nullable String */;
 454 var1 = self->attrs[COLOR_abstract_compiler__AbstractRuntimeFunction___64dc_name_cache].val; /* @c_name_cache on <self:AbstractRuntimeFunction> */
 455 var = var1;
 456 RET_LABEL:;
 457 return var;
 458 }
 459 /* method abstract_compiler#AbstractRuntimeFunction#c_name_cache for (self: Object): nullable String */
 460 val* VIRTUAL_abstract_compiler__AbstractRuntimeFunction__c_name_cache(val* self) {
 461 val* var /* : nullable String */;
 462 val* var1 /* : nullable String */;
 463 var1 = abstract_compiler__AbstractRuntimeFunction__c_name_cache(self);
 464 var = var1;
 465 RET_LABEL:;
 466 return var;
 467 }
 468 /* method abstract_compiler#AbstractRuntimeFunction#c_name_cache= for (self: AbstractRuntimeFunction, nullable String) */
 469 void abstract_compiler__AbstractRuntimeFunction__c_name_cache_61d(val* self, val* p0) {
 470 self->attrs[COLOR_abstract_compiler__AbstractRuntimeFunction___64dc_name_cache].val = p0; /* @c_name_cache on <self:AbstractRuntimeFunction> */
 471 RET_LABEL:;
 472 }
 473 /* method abstract_compiler#AbstractRuntimeFunction#c_name_cache= for (self: Object, nullable String) */
 474 void VIRTUAL_abstract_compiler__AbstractRuntimeFunction__c_name_cache_61d(val* self, val* p0) {
 475 abstract_compiler__AbstractRuntimeFunction__c_name_cache_61d(self, p0);
 476 RET_LABEL:;
 477 }
 478 /* method abstract_compiler#AbstractRuntimeFunction#call for (self: AbstractRuntimeFunction, AbstractCompilerVisitor, Array[RuntimeVariable]): nullable RuntimeVariable */
 479 val* abstract_compiler__AbstractRuntimeFunction__call(val* self, val* p0, val* p1) {
 480 val* var /* : nullable RuntimeVariable */;
 481 short int var1 /* : Bool */;
 482 int cltype;
 483 int idtype;
 484 const struct type* type_struct;
 485 const char* var_class_name;
 486 const char* var_class_name2;
 487 /* Covariant cast for argument 0 (v) <p0:AbstractCompilerVisitor> isa VISITOR */
 488 /* <p0:AbstractCompilerVisitor> isa VISITOR */
 489 type_struct = self->type->resolution_table->types[COLOR_abstract_compiler__AbstractRuntimeFunction_VTVISITOR];
 490 cltype = type_struct->color;
 491 idtype = type_struct->id;
 492 if(cltype >= p0->type->table_size) {
 493 var1 = 0;
 494 } else {
 495 var1 = p0->type->type_table[cltype] == idtype;
 496 }
 497 if (!var1) {
 498 var_class_name = p0 == NULL ? "null" : p0->type->name;
 499 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "VISITOR", var_class_name);
 500 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1002);
 501 exit(1);
 502 }
 503 var_class_name2 = self == NULL ? "null" : self->type->name;
 504 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "call", var_class_name2);
 505 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1002);
 506 exit(1);
 507 RET_LABEL:;
 508 return var;
 509 }
 510 /* method abstract_compiler#AbstractRuntimeFunction#call for (self: Object, AbstractCompilerVisitor, Array[RuntimeVariable]): nullable RuntimeVariable */
 511 val* VIRTUAL_abstract_compiler__AbstractRuntimeFunction__call(val* self, val* p0, val* p1) {
 512 val* var /* : nullable RuntimeVariable */;
 513 val* var1 /* : nullable RuntimeVariable */;
 514 var1 = abstract_compiler__AbstractRuntimeFunction__call(self, p0, p1);
 515 var = var1;
 516 RET_LABEL:;
 517 return var;
 518 }
 519 /* method abstract_compiler#AbstractRuntimeFunction#compile_to_c for (self: AbstractRuntimeFunction, AbstractCompiler) */
 520 void abstract_compiler__AbstractRuntimeFunction__compile_to_c(val* self, val* p0) {
 521 short int var /* : Bool */;
 522 int cltype;
 523 int idtype;
 524 const struct type* type_struct;
 525 const char* var_class_name;
 526 const char* var_class_name1;
 527 /* Covariant cast for argument 0 (compiler) <p0:AbstractCompiler> isa COMPILER */
 528 /* <p0:AbstractCompiler> isa COMPILER */
 529 type_struct = self->type->resolution_table->types[COLOR_abstract_compiler__AbstractRuntimeFunction_VTCOMPILER];
 530 cltype = type_struct->color;
 531 idtype = type_struct->id;
 532 if(cltype >= p0->type->table_size) {
 533 var = 0;
 534 } else {
 535 var = p0->type->type_table[cltype] == idtype;
 536 }
 537 if (!var) {
 538 var_class_name = p0 == NULL ? "null" : p0->type->name;
 539 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "COMPILER", var_class_name);
 540 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1006);
 541 exit(1);
 542 }
 543 var_class_name1 = self == NULL ? "null" : self->type->name;
 544 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "compile_to_c", var_class_name1);
 545 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1006);
 546 exit(1);
 547 RET_LABEL:;
 548 }
 549 /* method abstract_compiler#AbstractRuntimeFunction#compile_to_c for (self: Object, AbstractCompiler) */
 550 void VIRTUAL_abstract_compiler__AbstractRuntimeFunction__compile_to_c(val* self, val* p0) {
 551 abstract_compiler__AbstractRuntimeFunction__compile_to_c(self, p0);
 552 RET_LABEL:;
 553 }
 554 /* method abstract_compiler#AbstractRuntimeFunction#init for (self: AbstractRuntimeFunction, MMethodDef) */
 555 void abstract_compiler__AbstractRuntimeFunction__init(val* self, val* p0) {
 556 self->attrs[COLOR_abstract_compiler__AbstractRuntimeFunction___64dmmethoddef].val = p0; /* @mmethoddef on <self:AbstractRuntimeFunction> */
 557 RET_LABEL:;
 558 }
 559 /* method abstract_compiler#AbstractRuntimeFunction#init for (self: Object, MMethodDef) */
 560 void VIRTUAL_abstract_compiler__AbstractRuntimeFunction__init(val* self, val* p0) {
 561 abstract_compiler__AbstractRuntimeFunction__init(self, p0);
 562 RET_LABEL:;
 563 }
 564 /* method abstract_compiler#RuntimeVariable#name for (self: RuntimeVariable): String */
 565 val* abstract_compiler__RuntimeVariable__name(val* self) {
 566 val* var /* : String */;
 567 val* var1 /* : String */;
 568 var1 = self->attrs[COLOR_abstract_compiler__RuntimeVariable___64dname].val; /* @name on <self:RuntimeVariable> */
 569 if (var1 == NULL) {
 570 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @name");
 571 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1016);
 572 exit(1);
 573 }
 574 var = var1;
 575 RET_LABEL:;
 576 return var;
 577 }
 578 /* method abstract_compiler#RuntimeVariable#name for (self: Object): String */
 579 val* VIRTUAL_abstract_compiler__RuntimeVariable__name(val* self) {
 580 val* var /* : String */;
 581 val* var1 /* : String */;
 582 var1 = abstract_compiler__RuntimeVariable__name(self);
 583 var = var1;
 584 RET_LABEL:;
 585 return var;
 586 }
 587 /* method abstract_compiler#RuntimeVariable#name= for (self: RuntimeVariable, String) */
 588 void abstract_compiler__RuntimeVariable__name_61d(val* self, val* p0) {
 589 self->attrs[COLOR_abstract_compiler__RuntimeVariable___64dname].val = p0; /* @name on <self:RuntimeVariable> */
 590 RET_LABEL:;
 591 }
 592 /* method abstract_compiler#RuntimeVariable#name= for (self: Object, String) */
 593 void VIRTUAL_abstract_compiler__RuntimeVariable__name_61d(val* self, val* p0) {
 594 abstract_compiler__RuntimeVariable__name_61d(self, p0);
 595 RET_LABEL:;
 596 }
 597 /* method abstract_compiler#RuntimeVariable#mtype for (self: RuntimeVariable): MType */
 598 val* abstract_compiler__RuntimeVariable__mtype(val* self) {
 599 val* var /* : MType */;
 600 val* var1 /* : MType */;
 601 var1 = self->attrs[COLOR_abstract_compiler__RuntimeVariable___64dmtype].val; /* @mtype on <self:RuntimeVariable> */
 602 if (var1 == NULL) {
 603 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @mtype");
 604 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1019);
 605 exit(1);
 606 }
 607 var = var1;
 608 RET_LABEL:;
 609 return var;
 610 }
 611 /* method abstract_compiler#RuntimeVariable#mtype for (self: Object): MType */
 612 val* VIRTUAL_abstract_compiler__RuntimeVariable__mtype(val* self) {
 613 val* var /* : MType */;
 614 val* var1 /* : MType */;
 615 var1 = abstract_compiler__RuntimeVariable__mtype(self);
 616 var = var1;
 617 RET_LABEL:;
 618 return var;
 619 }
 620 /* method abstract_compiler#RuntimeVariable#mtype= for (self: RuntimeVariable, MType) */
 621 void abstract_compiler__RuntimeVariable__mtype_61d(val* self, val* p0) {
 622 self->attrs[COLOR_abstract_compiler__RuntimeVariable___64dmtype].val = p0; /* @mtype on <self:RuntimeVariable> */
 623 RET_LABEL:;
 624 }
 625 /* method abstract_compiler#RuntimeVariable#mtype= for (self: Object, MType) */
 626 void VIRTUAL_abstract_compiler__RuntimeVariable__mtype_61d(val* self, val* p0) {
 627 abstract_compiler__RuntimeVariable__mtype_61d(self, p0);
 628 RET_LABEL:;
 629 }
 630 /* method abstract_compiler#RuntimeVariable#mcasttype for (self: RuntimeVariable): MType */
 631 val* abstract_compiler__RuntimeVariable__mcasttype(val* self) {
 632 val* var /* : MType */;
 633 val* var1 /* : MType */;
 634 var1 = self->attrs[COLOR_abstract_compiler__RuntimeVariable___64dmcasttype].val; /* @mcasttype on <self:RuntimeVariable> */
 635 if (var1 == NULL) {
 636 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @mcasttype");
 637 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1022);
 638 exit(1);
 639 }
 640 var = var1;
 641 RET_LABEL:;
 642 return var;
 643 }
 644 /* method abstract_compiler#RuntimeVariable#mcasttype for (self: Object): MType */
 645 val* VIRTUAL_abstract_compiler__RuntimeVariable__mcasttype(val* self) {
 646 val* var /* : MType */;
 647 val* var1 /* : MType */;
 648 var1 = abstract_compiler__RuntimeVariable__mcasttype(self);
 649 var = var1;
 650 RET_LABEL:;
 651 return var;
 652 }
 653 /* method abstract_compiler#RuntimeVariable#mcasttype= for (self: RuntimeVariable, MType) */
 654 void abstract_compiler__RuntimeVariable__mcasttype_61d(val* self, val* p0) {
 655 self->attrs[COLOR_abstract_compiler__RuntimeVariable___64dmcasttype].val = p0; /* @mcasttype on <self:RuntimeVariable> */
 656 RET_LABEL:;
 657 }
 658 /* method abstract_compiler#RuntimeVariable#mcasttype= for (self: Object, MType) */
 659 void VIRTUAL_abstract_compiler__RuntimeVariable__mcasttype_61d(val* self, val* p0) {
 660 abstract_compiler__RuntimeVariable__mcasttype_61d(self, p0);
 661 RET_LABEL:;
 662 }
 663 /* method abstract_compiler#RuntimeVariable#is_exact for (self: RuntimeVariable): Bool */
 664 short int abstract_compiler__RuntimeVariable__is_exact(val* self) {
 665 short int var /* : Bool */;
 666 short int var1 /* : Bool */;
 667 var1 = self->attrs[COLOR_abstract_compiler__RuntimeVariable___64dis_exact].s; /* @is_exact on <self:RuntimeVariable> */
 668 var = var1;
 669 RET_LABEL:;
 670 return var;
 671 }
 672 /* method abstract_compiler#RuntimeVariable#is_exact for (self: Object): Bool */
 673 short int VIRTUAL_abstract_compiler__RuntimeVariable__is_exact(val* self) {
 674 short int var /* : Bool */;
 675 short int var1 /* : Bool */;
 676 var1 = abstract_compiler__RuntimeVariable__is_exact(self);
 677 var = var1;
 678 RET_LABEL:;
 679 return var;
 680 }
 681 /* method abstract_compiler#RuntimeVariable#is_exact= for (self: RuntimeVariable, Bool) */
 682 void abstract_compiler__RuntimeVariable__is_exact_61d(val* self, short int p0) {
 683 self->attrs[COLOR_abstract_compiler__RuntimeVariable___64dis_exact].s = p0; /* @is_exact on <self:RuntimeVariable> */
 684 RET_LABEL:;
 685 }
 686 /* method abstract_compiler#RuntimeVariable#is_exact= for (self: Object, Bool) */
 687 void VIRTUAL_abstract_compiler__RuntimeVariable__is_exact_61d(val* self, short int p0) {
 688 abstract_compiler__RuntimeVariable__is_exact_61d(self, p0);
 689 RET_LABEL:;
 690 }
 691 /* method abstract_compiler#RuntimeVariable#init for (self: RuntimeVariable, String, MType, MType) */
 692 void abstract_compiler__RuntimeVariable__init(val* self, val* p0, val* p1, val* p2) {
 693 val* var_name /* var name: String */;
 694 val* var_mtype /* var mtype: MType */;
 695 val* var_mcasttype /* var mcasttype: MType */;
 696 short int var /* : Bool */;
 697 short int var1 /* : Bool */;
 698 short int var2 /* : Bool */;
 699 short int var3 /* : Bool */;
 700 var_name = p0;
 701 var_mtype = p1;
 702 var_mcasttype = p2;
 703 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__RuntimeVariable__name_61d]))(self, var_name) /* name= on <self:RuntimeVariable>*/;
 704 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__RuntimeVariable__mtype_61d]))(self, var_mtype) /* mtype= on <self:RuntimeVariable>*/;
 705 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__RuntimeVariable__mcasttype_61d]))(self, var_mcasttype) /* mcasttype= on <self:RuntimeVariable>*/;
 706 var = ((short int (*)(val*))(var_mtype->class->vft[COLOR_model__MType__need_anchor]))(var_mtype) /* need_anchor on <var_mtype:MType>*/;
 707 var1 = !var;
 708 if (!var1) {
 709 fprintf(stderr, "Runtime error: %s", "Assert failed");
 710 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1034);
 711 exit(1);
 712 }
 713 var2 = ((short int (*)(val*))(var_mcasttype->class->vft[COLOR_model__MType__need_anchor]))(var_mcasttype) /* need_anchor on <var_mcasttype:MType>*/;
 714 var3 = !var2;
 715 if (!var3) {
 716 fprintf(stderr, "Runtime error: %s", "Assert failed");
 717 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1035);
 718 exit(1);
 719 }
 720 RET_LABEL:;
 721 }
 722 /* method abstract_compiler#RuntimeVariable#init for (self: Object, String, MType, MType) */
 723 void VIRTUAL_abstract_compiler__RuntimeVariable__init(val* self, val* p0, val* p1, val* p2) {
 724 abstract_compiler__RuntimeVariable__init(self, p0, p1, p2);
 725 RET_LABEL:;
 726 }
 727 /* method abstract_compiler#RuntimeVariable#to_s for (self: RuntimeVariable): String */
 728 val* abstract_compiler__RuntimeVariable__to_s(val* self) {
 729 val* var /* : String */;
 730 val* var1 /* : String */;
 731 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__RuntimeVariable__name]))(self) /* name on <self:RuntimeVariable>*/;
 732 var = var1;
 733 goto RET_LABEL;
 734 RET_LABEL:;
 735 return var;
 736 }
 737 /* method abstract_compiler#RuntimeVariable#to_s for (self: Object): String */
 738 val* VIRTUAL_abstract_compiler__RuntimeVariable__to_s(val* self) {
 739 val* var /* : String */;
 740 val* var1 /* : String */;
 741 var1 = abstract_compiler__RuntimeVariable__to_s(self);
 742 var = var1;
 743 RET_LABEL:;
 744 return var;
 745 }
 746 /* method abstract_compiler#RuntimeVariable#inspect for (self: RuntimeVariable): String */
 747 val* abstract_compiler__RuntimeVariable__inspect(val* self) {
 748 val* var /* : String */;
 749 short int var1 /* : Bool */;
 750 static val* varonce;
 751 val* var2 /* : String */;
 752 char* var3 /* : NativeString */;
 753 long var4 /* : Int */;
 754 val* var5 /* : String */;
 755 val* var_exact_str /* var exact_str: nullable Object */;
 756 static val* varonce6;
 757 val* var7 /* : String */;
 758 char* var8 /* : NativeString */;
 759 long var9 /* : Int */;
 760 val* var10 /* : String */;
 761 val* var11 /* : MType */;
 762 val* var12 /* : MType */;
 763 short int var13 /* : Bool */;
 764 val* var14 /* : MType */;
 765 val* var15 /* : Array[Object] */;
 766 long var16 /* : Int */;
 767 val* var17 /* : NativeArray[Object] */;
 768 val* var18 /* : String */;
 769 val* var_type_str /* var type_str: nullable Object */;
 770 val* var19 /* : MType */;
 771 static val* varonce20;
 772 val* var21 /* : String */;
 773 char* var22 /* : NativeString */;
 774 long var23 /* : Int */;
 775 val* var24 /* : String */;
 776 val* var25 /* : MType */;
 777 static val* varonce26;
 778 val* var27 /* : String */;
 779 char* var28 /* : NativeString */;
 780 long var29 /* : Int */;
 781 val* var30 /* : String */;
 782 val* var31 /* : Array[Object] */;
 783 long var32 /* : Int */;
 784 val* var33 /* : NativeArray[Object] */;
 785 val* var34 /* : String */;
 786 val* var35 /* : Array[Object] */;
 787 long var36 /* : Int */;
 788 val* var_ /* var : Array[Object] */;
 789 static val* varonce37;
 790 val* var38 /* : String */;
 791 char* var39 /* : NativeString */;
 792 long var40 /* : Int */;
 793 val* var41 /* : String */;
 794 val* var42 /* : String */;
 795 static val* varonce43;
 796 val* var44 /* : String */;
 797 char* var45 /* : NativeString */;
 798 long var46 /* : Int */;
 799 val* var47 /* : String */;
 800 static val* varonce48;
 801 val* var49 /* : String */;
 802 char* var50 /* : NativeString */;
 803 long var51 /* : Int */;
 804 val* var52 /* : String */;
 805 val* var53 /* : String */;
 806 var1 = ((short int (*)(val*))(self->class->vft[COLOR_abstract_compiler__RuntimeVariable__is_exact]))(self) /* is_exact on <self:RuntimeVariable>*/;
 807 if (var1){
 808 if (varonce) {
 809 var2 = varonce;
 810 } else {
 811 var3 = " exact";
 812 var4 = 6;
 813 var5 = string__NativeString__to_s_with_length(var3, var4);
 814 var2 = var5;
 815 varonce = var2;
 816 }
 817 var_exact_str = var2;
 818 } else {
 819 if (varonce6) {
 820 var7 = varonce6;
 821 } else {
 822 var8 = "";
 823 var9 = 0;
 824 var10 = string__NativeString__to_s_with_length(var8, var9);
 825 var7 = var10;
 826 varonce6 = var7;
 827 }
 828 var_exact_str = var7;
 829 }
 830 var11 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__RuntimeVariable__mtype]))(self) /* mtype on <self:RuntimeVariable>*/;
 831 var12 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__RuntimeVariable__mcasttype]))(self) /* mcasttype on <self:RuntimeVariable>*/;
 832 var13 = ((short int (*)(val*, val*))(var11->class->vft[COLOR_kernel__Object___61d_61d]))(var11, var12) /* == on <var11:MType>*/;
 833 if (var13){
 834 var14 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__RuntimeVariable__mtype]))(self) /* mtype on <self:RuntimeVariable>*/;
 835 var15 = NEW_array__Array(&type_array__Arraykernel__Object);
 836 { /* var15 = array_instance Array[Object] */
 837 var16 = 2;
 838 var17 = NEW_array__NativeArray(var16, &type_array__NativeArraykernel__Object);
 839 ((struct instance_array__NativeArray*)var17)->values[0] = (val*) var14;
 840 ((struct instance_array__NativeArray*)var17)->values[1] = (val*) var_exact_str;
 841 ((void (*)(val*, val*, long))(var15->class->vft[COLOR_array__Array__with_native]))(var15, var17, var16) /* with_native on <var15:Array[Object]>*/;
 842 CHECK_NEW_array__Array(var15);
 843 }
 844 var18 = ((val* (*)(val*))(var15->class->vft[COLOR_string__Object__to_s]))(var15) /* to_s on <var15:Array[Object]>*/;
 845 var_type_str = var18;
 846 } else {
 847 var19 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__RuntimeVariable__mtype]))(self) /* mtype on <self:RuntimeVariable>*/;
 848 if (varonce20) {
 849 var21 = varonce20;
 850 } else {
 851 var22 = "(";
 852 var23 = 1;
 853 var24 = string__NativeString__to_s_with_length(var22, var23);
 854 var21 = var24;
 855 varonce20 = var21;
 856 }
 857 var25 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__RuntimeVariable__mcasttype]))(self) /* mcasttype on <self:RuntimeVariable>*/;
 858 if (varonce26) {
 859 var27 = varonce26;
 860 } else {
 861 var28 = ")";
 862 var29 = 1;
 863 var30 = string__NativeString__to_s_with_length(var28, var29);
 864 var27 = var30;
 865 varonce26 = var27;
 866 }
 867 var31 = NEW_array__Array(&type_array__Arraykernel__Object);
 868 { /* var31 = array_instance Array[Object] */
 869 var32 = 5;
 870 var33 = NEW_array__NativeArray(var32, &type_array__NativeArraykernel__Object);
 871 ((struct instance_array__NativeArray*)var33)->values[0] = (val*) var19;
 872 ((struct instance_array__NativeArray*)var33)->values[1] = (val*) var21;
 873 ((struct instance_array__NativeArray*)var33)->values[2] = (val*) var25;
 874 ((struct instance_array__NativeArray*)var33)->values[3] = (val*) var_exact_str;
 875 ((struct instance_array__NativeArray*)var33)->values[4] = (val*) var27;
 876 ((void (*)(val*, val*, long))(var31->class->vft[COLOR_array__Array__with_native]))(var31, var33, var32) /* with_native on <var31:Array[Object]>*/;
 877 CHECK_NEW_array__Array(var31);
 878 }
 879 var34 = ((val* (*)(val*))(var31->class->vft[COLOR_string__Object__to_s]))(var31) /* to_s on <var31:Array[Object]>*/;
 880 var_type_str = var34;
 881 }
 882 var35 = NEW_array__Array(&type_array__Arraykernel__Object);
 883 var36 = 5;
 884 ((void (*)(val*, long))(var35->class->vft[COLOR_array__Array__with_capacity]))(var35, var36) /* with_capacity on <var35:Array[Object]>*/;
 885 CHECK_NEW_array__Array(var35);
 886 var_ = var35;
 887 if (varonce37) {
 888 var38 = varonce37;
 889 } else {
 890 var39 = "<";
 891 var40 = 1;
 892 var41 = string__NativeString__to_s_with_length(var39, var40);
 893 var38 = var41;
 894 varonce37 = var38;
 895 }
 896 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var38) /* add on <var_:Array[Object]>*/;
 897 var42 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__RuntimeVariable__name]))(self) /* name on <self:RuntimeVariable>*/;
 898 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var42) /* add on <var_:Array[Object]>*/;
 899 if (varonce43) {
 900 var44 = varonce43;
 901 } else {
 902 var45 = ":";
 903 var46 = 1;
 904 var47 = string__NativeString__to_s_with_length(var45, var46);
 905 var44 = var47;
 906 varonce43 = var44;
 907 }
 908 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var44) /* add on <var_:Array[Object]>*/;
 909 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var_type_str) /* add on <var_:Array[Object]>*/;
 910 if (varonce48) {
 911 var49 = varonce48;
 912 } else {
 913 var50 = ">";
 914 var51 = 1;
 915 var52 = string__NativeString__to_s_with_length(var50, var51);
 916 var49 = var52;
 917 varonce48 = var49;
 918 }
 919 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var49) /* add on <var_:Array[Object]>*/;
 920 var53 = ((val* (*)(val*))(var_->class->vft[COLOR_string__Object__to_s]))(var_) /* to_s on <var_:Array[Object]>*/;
 921 var = var53;
 922 goto RET_LABEL;
 923 RET_LABEL:;
 924 return var;
 925 }
 926 /* method abstract_compiler#RuntimeVariable#inspect for (self: Object): String */
 927 val* VIRTUAL_abstract_compiler__RuntimeVariable__inspect(val* self) {
 928 val* var /* : String */;
 929 val* var1 /* : String */;
 930 var1 = abstract_compiler__RuntimeVariable__inspect(self);
 931 var = var1;
 932 RET_LABEL:;
 933 return var;
 934 }
 935 /* method abstract_compiler#Frame#visitor for (self: Frame): AbstractCompilerVisitor */
 936 val* abstract_compiler__Frame__visitor(val* self) {
 937 val* var /* : AbstractCompilerVisitor */;
 938 val* var1 /* : AbstractCompilerVisitor */;
 939 var1 = self->attrs[COLOR_abstract_compiler__Frame___64dvisitor].val; /* @visitor on <self:Frame> */
 940 if (var1 == NULL) {
 941 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @visitor");
 942 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1063);
 943 exit(1);
 944 }
 945 var = var1;
 946 RET_LABEL:;
 947 return var;
 948 }
 949 /* method abstract_compiler#Frame#visitor for (self: Object): AbstractCompilerVisitor */
 950 val* VIRTUAL_abstract_compiler__Frame__visitor(val* self) {
 951 val* var /* : AbstractCompilerVisitor */;
 952 val* var1 /* : AbstractCompilerVisitor */;
 953 var1 = abstract_compiler__Frame__visitor(self);
 954 var = var1;
 955 RET_LABEL:;
 956 return var;
 957 }
 958 /* method abstract_compiler#Frame#visitor= for (self: Frame, AbstractCompilerVisitor) */
 959 void abstract_compiler__Frame__visitor_61d(val* self, val* p0) {
 960 short int var /* : Bool */;
 961 int cltype;
 962 int idtype;
 963 const struct type* type_struct;
 964 const char* var_class_name;
 965 /* Covariant cast for argument 0 (visitor) <p0:AbstractCompilerVisitor> isa VISITOR */
 966 /* <p0:AbstractCompilerVisitor> isa VISITOR */
 967 type_struct = self->type->resolution_table->types[COLOR_abstract_compiler__Frame_VTVISITOR];
 968 cltype = type_struct->color;
 969 idtype = type_struct->id;
 970 if(cltype >= p0->type->table_size) {
 971 var = 0;
 972 } else {
 973 var = p0->type->type_table[cltype] == idtype;
 974 }
 975 if (!var) {
 976 var_class_name = p0 == NULL ? "null" : p0->type->name;
 977 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "VISITOR", var_class_name);
 978 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1063);
 979 exit(1);
 980 }
 981 self->attrs[COLOR_abstract_compiler__Frame___64dvisitor].val = p0; /* @visitor on <self:Frame> */
 982 RET_LABEL:;
 983 }
 984 /* method abstract_compiler#Frame#visitor= for (self: Object, AbstractCompilerVisitor) */
 985 void VIRTUAL_abstract_compiler__Frame__visitor_61d(val* self, val* p0) {
 986 abstract_compiler__Frame__visitor_61d(self, p0);
 987 RET_LABEL:;
 988 }
 989 /* method abstract_compiler#Frame#mpropdef for (self: Frame): MPropDef */
 990 val* abstract_compiler__Frame__mpropdef(val* self) {
 991 val* var /* : MPropDef */;
 992 val* var1 /* : MPropDef */;
 993 var1 = self->attrs[COLOR_abstract_compiler__Frame___64dmpropdef].val; /* @mpropdef on <self:Frame> */
 994 if (var1 == NULL) {
 995 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @mpropdef");
 996 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1066);
 997 exit(1);
 998 }
 999 var = var1;
1000 RET_LABEL:;
1001 return var;
1002 }
1003 /* method abstract_compiler#Frame#mpropdef for (self: Object): MPropDef */
1004 val* VIRTUAL_abstract_compiler__Frame__mpropdef(val* self) {
1005 val* var /* : MPropDef */;
1006 val* var1 /* : MPropDef */;
1007 var1 = abstract_compiler__Frame__mpropdef(self);
1008 var = var1;
1009 RET_LABEL:;
1010 return var;
1011 }
1012 /* method abstract_compiler#Frame#mpropdef= for (self: Frame, MPropDef) */
1013 void abstract_compiler__Frame__mpropdef_61d(val* self, val* p0) {
1014 self->attrs[COLOR_abstract_compiler__Frame___64dmpropdef].val = p0; /* @mpropdef on <self:Frame> */
1015 RET_LABEL:;
1016 }
1017 /* method abstract_compiler#Frame#mpropdef= for (self: Object, MPropDef) */
1018 void VIRTUAL_abstract_compiler__Frame__mpropdef_61d(val* self, val* p0) {
1019 abstract_compiler__Frame__mpropdef_61d(self, p0);
1020 RET_LABEL:;
1021 }
1022 /* method abstract_compiler#Frame#receiver for (self: Frame): MClassType */
1023 val* abstract_compiler__Frame__receiver(val* self) {
1024 val* var /* : MClassType */;
1025 val* var1 /* : MClassType */;
1026 var1 = self->attrs[COLOR_abstract_compiler__Frame___64dreceiver].val; /* @receiver on <self:Frame> */
1027 if (var1 == NULL) {
1028 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @receiver");
1029 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1070);
1030 exit(1);
1031 }
1032 var = var1;
1033 RET_LABEL:;
1034 return var;
1035 }
1036 /* method abstract_compiler#Frame#receiver for (self: Object): MClassType */
1037 val* VIRTUAL_abstract_compiler__Frame__receiver(val* self) {
1038 val* var /* : MClassType */;
1039 val* var1 /* : MClassType */;
1040 var1 = abstract_compiler__Frame__receiver(self);
1041 var = var1;
1042 RET_LABEL:;
1043 return var;
1044 }
1045 /* method abstract_compiler#Frame#receiver= for (self: Frame, MClassType) */
1046 void abstract_compiler__Frame__receiver_61d(val* self, val* p0) {
1047 self->attrs[COLOR_abstract_compiler__Frame___64dreceiver].val = p0; /* @receiver on <self:Frame> */
1048 RET_LABEL:;
1049 }
1050 /* method abstract_compiler#Frame#receiver= for (self: Object, MClassType) */
1051 void VIRTUAL_abstract_compiler__Frame__receiver_61d(val* self, val* p0) {
1052 abstract_compiler__Frame__receiver_61d(self, p0);
1053 RET_LABEL:;
1054 }
1055 /* method abstract_compiler#Frame#arguments for (self: Frame): Array[RuntimeVariable] */
1056 val* abstract_compiler__Frame__arguments(val* self) {
1057 val* var /* : Array[RuntimeVariable] */;
1058 val* var1 /* : Array[RuntimeVariable] */;
1059 var1 = self->attrs[COLOR_abstract_compiler__Frame___64darguments].val; /* @arguments on <self:Frame> */
1060 if (var1 == NULL) {
1061 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @arguments");
1062 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1073);
1063 exit(1);
1064 }
1065 var = var1;
1066 RET_LABEL:;
1067 return var;
1068 }
1069 /* method abstract_compiler#Frame#arguments for (self: Object): Array[RuntimeVariable] */
1070 val* VIRTUAL_abstract_compiler__Frame__arguments(val* self) {
1071 val* var /* : Array[RuntimeVariable] */;
1072 val* var1 /* : Array[RuntimeVariable] */;
1073 var1 = abstract_compiler__Frame__arguments(self);
1074 var = var1;
1075 RET_LABEL:;
1076 return var;
1077 }
1078 /* method abstract_compiler#Frame#arguments= for (self: Frame, Array[RuntimeVariable]) */
1079 void abstract_compiler__Frame__arguments_61d(val* self, val* p0) {
1080 self->attrs[COLOR_abstract_compiler__Frame___64darguments].val = p0; /* @arguments on <self:Frame> */
1081 RET_LABEL:;
1082 }
1083 /* method abstract_compiler#Frame#arguments= for (self: Object, Array[RuntimeVariable]) */
1084 void VIRTUAL_abstract_compiler__Frame__arguments_61d(val* self, val* p0) {
1085 abstract_compiler__Frame__arguments_61d(self, p0);
1086 RET_LABEL:;
1087 }
1088 /* method abstract_compiler#Frame#returnvar for (self: Frame): nullable RuntimeVariable */
1089 val* abstract_compiler__Frame__returnvar(val* self) {
1090 val* var /* : nullable RuntimeVariable */;
1091 val* var1 /* : nullable RuntimeVariable */;
1092 var1 = self->attrs[COLOR_abstract_compiler__Frame___64dreturnvar].val; /* @returnvar on <self:Frame> */
1093 var = var1;
1094 RET_LABEL:;
1095 return var;
1096 }
1097 /* method abstract_compiler#Frame#returnvar for (self: Object): nullable RuntimeVariable */
1098 val* VIRTUAL_abstract_compiler__Frame__returnvar(val* self) {
1099 val* var /* : nullable RuntimeVariable */;
1100 val* var1 /* : nullable RuntimeVariable */;
1101 var1 = abstract_compiler__Frame__returnvar(self);
1102 var = var1;
1103 RET_LABEL:;
1104 return var;
1105 }
1106 /* method abstract_compiler#Frame#returnvar= for (self: Frame, nullable RuntimeVariable) */
1107 void abstract_compiler__Frame__returnvar_61d(val* self, val* p0) {
1108 self->attrs[COLOR_abstract_compiler__Frame___64dreturnvar].val = p0; /* @returnvar on <self:Frame> */
1109 RET_LABEL:;
1110 }
1111 /* method abstract_compiler#Frame#returnvar= for (self: Object, nullable RuntimeVariable) */
1112 void VIRTUAL_abstract_compiler__Frame__returnvar_61d(val* self, val* p0) {
1113 abstract_compiler__Frame__returnvar_61d(self, p0);
1114 RET_LABEL:;
1115 }
1116 /* method abstract_compiler#Frame#returnlabel for (self: Frame): nullable String */
1117 val* abstract_compiler__Frame__returnlabel(val* self) {
1118 val* var /* : nullable String */;
1119 val* var1 /* : nullable String */;
1120 var1 = self->attrs[COLOR_abstract_compiler__Frame___64dreturnlabel].val; /* @returnlabel on <self:Frame> */
1121 var = var1;
1122 RET_LABEL:;
1123 return var;
1124 }
1125 /* method abstract_compiler#Frame#returnlabel for (self: Object): nullable String */
1126 val* VIRTUAL_abstract_compiler__Frame__returnlabel(val* self) {
1127 val* var /* : nullable String */;
1128 val* var1 /* : nullable String */;
1129 var1 = abstract_compiler__Frame__returnlabel(self);
1130 var = var1;
1131 RET_LABEL:;
1132 return var;
1133 }
1134 /* method abstract_compiler#Frame#returnlabel= for (self: Frame, nullable String) */
1135 void abstract_compiler__Frame__returnlabel_61d(val* self, val* p0) {
1136 self->attrs[COLOR_abstract_compiler__Frame___64dreturnlabel].val = p0; /* @returnlabel on <self:Frame> */
1137 RET_LABEL:;
1138 }
1139 /* method abstract_compiler#Frame#returnlabel= for (self: Object, nullable String) */
1140 void VIRTUAL_abstract_compiler__Frame__returnlabel_61d(val* self, val* p0) {
1141 abstract_compiler__Frame__returnlabel_61d(self, p0);
1142 RET_LABEL:;
1143 }
1144 /* method abstract_compiler#Frame#init for (self: Frame, AbstractCompilerVisitor, MPropDef, MClassType, Array[RuntimeVariable]) */
1145 void abstract_compiler__Frame__init(val* self, val* p0, val* p1, val* p2, val* p3) {
1146 short int var /* : Bool */;
1147 int cltype;
1148 int idtype;
1149 const struct type* type_struct;
1150 const char* var_class_name;
1151 /* Covariant cast for argument 0 (visitor) <p0:AbstractCompilerVisitor> isa VISITOR */
1152 /* <p0:AbstractCompilerVisitor> isa VISITOR */
1153 type_struct = self->type->resolution_table->types[COLOR_abstract_compiler__Frame_VTVISITOR];
1154 cltype = type_struct->color;
1155 idtype = type_struct->id;
1156 if(cltype >= p0->type->table_size) {
1157 var = 0;
1158 } else {
1159 var = p0->type->type_table[cltype] == idtype;
1160 }
1161 if (!var) {
1162 var_class_name = p0 == NULL ? "null" : p0->type->name;
1163 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "VISITOR", var_class_name);
1164 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1058);
1165 exit(1);
1166 }
1167 self->attrs[COLOR_abstract_compiler__Frame___64dvisitor].val = p0; /* @visitor on <self:Frame> */
1168 self->attrs[COLOR_abstract_compiler__Frame___64dmpropdef].val = p1; /* @mpropdef on <self:Frame> */
1169 self->attrs[COLOR_abstract_compiler__Frame___64dreceiver].val = p2; /* @receiver on <self:Frame> */
1170 self->attrs[COLOR_abstract_compiler__Frame___64darguments].val = p3; /* @arguments on <self:Frame> */
1171 RET_LABEL:;
1172 }
1173 /* method abstract_compiler#Frame#init for (self: Object, AbstractCompilerVisitor, MPropDef, MClassType, Array[RuntimeVariable]) */
1174 void VIRTUAL_abstract_compiler__Frame__init(val* self, val* p0, val* p1, val* p2, val* p3) {
1175 abstract_compiler__Frame__init(self, p0, p1, p2, p3);
1176 RET_LABEL:;
1177 }
1178 /* method abstract_compiler#ExternCFile#filename for (self: ExternCFile): String */
1179 val* abstract_compiler__ExternCFile__filename(val* self) {
1180 val* var /* : String */;
1181 val* var1 /* : String */;
1182 var1 = self->attrs[COLOR_abstract_compiler__ExternCFile___64dfilename].val; /* @filename on <self:ExternCFile> */
1183 if (var1 == NULL) {
1184 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @filename");
1185 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1085);
1186 exit(1);
1187 }
1188 var = var1;
1189 RET_LABEL:;
1190 return var;
1191 }
1192 /* method abstract_compiler#ExternCFile#filename for (self: Object): String */
1193 val* VIRTUAL_abstract_compiler__ExternCFile__filename(val* self) {
1194 val* var /* : String */;
1195 val* var1 /* : String */;
1196 var1 = abstract_compiler__ExternCFile__filename(self);
1197 var = var1;
1198 RET_LABEL:;
1199 return var;
1200 }
1201 /* method abstract_compiler#ExternCFile#filename= for (self: ExternCFile, String) */
1202 void abstract_compiler__ExternCFile__filename_61d(val* self, val* p0) {
1203 self->attrs[COLOR_abstract_compiler__ExternCFile___64dfilename].val = p0; /* @filename on <self:ExternCFile> */
1204 RET_LABEL:;
1205 }
1206 /* method abstract_compiler#ExternCFile#filename= for (self: Object, String) */
1207 void VIRTUAL_abstract_compiler__ExternCFile__filename_61d(val* self, val* p0) {
1208 abstract_compiler__ExternCFile__filename_61d(self, p0);
1209 RET_LABEL:;
1210 }
1211 /* method abstract_compiler#ExternCFile#cflags for (self: ExternCFile): String */
1212 val* abstract_compiler__ExternCFile__cflags(val* self) {
1213 val* var /* : String */;
1214 val* var1 /* : String */;
1215 var1 = self->attrs[COLOR_abstract_compiler__ExternCFile___64dcflags].val; /* @cflags on <self:ExternCFile> */
1216 if (var1 == NULL) {
1217 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @cflags");
1218 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1087);
1219 exit(1);
1220 }
1221 var = var1;
1222 RET_LABEL:;
1223 return var;
1224 }
1225 /* method abstract_compiler#ExternCFile#cflags for (self: Object): String */
1226 val* VIRTUAL_abstract_compiler__ExternCFile__cflags(val* self) {
1227 val* var /* : String */;
1228 val* var1 /* : String */;
1229 var1 = abstract_compiler__ExternCFile__cflags(self);
1230 var = var1;
1231 RET_LABEL:;
1232 return var;
1233 }
1234 /* method abstract_compiler#ExternCFile#cflags= for (self: ExternCFile, String) */
1235 void abstract_compiler__ExternCFile__cflags_61d(val* self, val* p0) {
1236 self->attrs[COLOR_abstract_compiler__ExternCFile___64dcflags].val = p0; /* @cflags on <self:ExternCFile> */
1237 RET_LABEL:;
1238 }
1239 /* method abstract_compiler#ExternCFile#cflags= for (self: Object, String) */
1240 void VIRTUAL_abstract_compiler__ExternCFile__cflags_61d(val* self, val* p0) {
1241 abstract_compiler__ExternCFile__cflags_61d(self, p0);
1242 RET_LABEL:;
1243 }
1244 /* method abstract_compiler#ExternCFile#init for (self: ExternCFile, String, String) */
1245 void abstract_compiler__ExternCFile__init(val* self, val* p0, val* p1) {
1246 self->attrs[COLOR_abstract_compiler__ExternCFile___64dfilename].val = p0; /* @filename on <self:ExternCFile> */
1247 self->attrs[COLOR_abstract_compiler__ExternCFile___64dcflags].val = p1; /* @cflags on <self:ExternCFile> */
1248 RET_LABEL:;
1249 }
1250 /* method abstract_compiler#ExternCFile#init for (self: Object, String, String) */
1251 void VIRTUAL_abstract_compiler__ExternCFile__init(val* self, val* p0, val* p1) {
1252 abstract_compiler__ExternCFile__init(self, p0, p1);
1253 RET_LABEL:;
1254 }
1255 /* method abstract_compiler#MType#ctype for (self: MType): String */
1256 val* abstract_compiler__MType__ctype(val* self) {
1257 val* var /* : String */;
1258 static val* varonce;
1259 val* var1 /* : String */;
1260 char* var2 /* : NativeString */;
1261 long var3 /* : Int */;
1262 val* var4 /* : String */;
1263 if (varonce) {
1264 var1 = varonce;
1265 } else {
1266 var2 = "val*";
1267 var3 = 4;
1268 var4 = string__NativeString__to_s_with_length(var2, var3);
1269 var1 = var4;
1270 varonce = var1;
1271 }
1272 var = var1;
1273 goto RET_LABEL;
1274 RET_LABEL:;
1275 return var;
1276 }
1277 /* method abstract_compiler#MType#ctype for (self: Object): String */
1278 val* VIRTUAL_abstract_compiler__MType__ctype(val* self) {
1279 val* var /* : String */;
1280 val* var1 /* : String */;
1281 var1 = abstract_compiler__MType__ctype(self);
1282 var = var1;
1283 RET_LABEL:;
1284 return var;
1285 }
1286 /* method abstract_compiler#MType#ctypename for (self: MType): String */
1287 val* abstract_compiler__MType__ctypename(val* self) {
1288 val* var /* : String */;
1289 static val* varonce;
1290 val* var1 /* : String */;
1291 char* var2 /* : NativeString */;
1292 long var3 /* : Int */;
1293 val* var4 /* : String */;
1294 if (varonce) {
1295 var1 = varonce;
1296 } else {
1297 var2 = "val";
1298 var3 = 3;
1299 var4 = string__NativeString__to_s_with_length(var2, var3);
1300 var1 = var4;
1301 varonce = var1;
1302 }
1303 var = var1;
1304 goto RET_LABEL;
1305 RET_LABEL:;
1306 return var;
1307 }
1308 /* method abstract_compiler#MType#ctypename for (self: Object): String */
1309 val* VIRTUAL_abstract_compiler__MType__ctypename(val* self) {
1310 val* var /* : String */;
1311 val* var1 /* : String */;
1312 var1 = abstract_compiler__MType__ctypename(self);
1313 var = var1;
1314 RET_LABEL:;
1315 return var;
1316 }
1317 /* method abstract_compiler#MType#c_name for (self: MType): String */
1318 val* abstract_compiler__MType__c_name(val* self) {
1319 val* var /* : String */;
1320 const char* var_class_name;
1321 var_class_name = self == NULL ? "null" : self->type->name;
1322 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "c_name", var_class_name);
1323 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1097);
1324 exit(1);
1325 RET_LABEL:;
1326 return var;
1327 }
1328 /* method abstract_compiler#MType#c_name for (self: Object): String */
1329 val* VIRTUAL_abstract_compiler__MType__c_name(val* self) {
1330 val* var /* : String */;
1331 val* var1 /* : String */;
1332 var1 = abstract_compiler__MType__c_name(self);
1333 var = var1;
1334 RET_LABEL:;
1335 return var;
1336 }
1337 /* method abstract_compiler#MType#c_name_cache for (self: MType): nullable String */
1338 val* abstract_compiler__MType__c_name_cache(val* self) {
1339 val* var /* : nullable String */;
1340 val* var1 /* : nullable String */;
1341 var1 = self->attrs[COLOR_abstract_compiler__MType___64dc_name_cache].val; /* @c_name_cache on <self:MType> */
1342 var = var1;
1343 RET_LABEL:;
1344 return var;
1345 }
1346 /* method abstract_compiler#MType#c_name_cache for (self: Object): nullable String */
1347 val* VIRTUAL_abstract_compiler__MType__c_name_cache(val* self) {
1348 val* var /* : nullable String */;
1349 val* var1 /* : nullable String */;
1350 var1 = abstract_compiler__MType__c_name_cache(self);
1351 var = var1;
1352 RET_LABEL:;
1353 return var;
1354 }
1355 /* method abstract_compiler#MType#c_name_cache= for (self: MType, nullable String) */
1356 void abstract_compiler__MType__c_name_cache_61d(val* self, val* p0) {
1357 self->attrs[COLOR_abstract_compiler__MType___64dc_name_cache].val = p0; /* @c_name_cache on <self:MType> */
1358 RET_LABEL:;
1359 }
1360 /* method abstract_compiler#MType#c_name_cache= for (self: Object, nullable String) */
1361 void VIRTUAL_abstract_compiler__MType__c_name_cache_61d(val* self, val* p0) {
1362 abstract_compiler__MType__c_name_cache_61d(self, p0);
1363 RET_LABEL:;
1364 }
1365 /* method abstract_compiler#MClassType#c_name for (self: MClassType): String */
1366 val* abstract_compiler__MClassType__c_name(val* self) {
1367 val* var /* : String */;
1368 val* var1 /* : nullable String */;
1369 val* var_res /* var res: nullable String */;
1370 val* var2 /* : null */;
1371 short int var3 /* : Bool */;
1372 val* var4 /* : Array[Object] */;
1373 long var5 /* : Int */;
1374 val* var_ /* var : Array[Object] */;
1375 static val* varonce;
1376 val* var6 /* : String */;
1377 char* var7 /* : NativeString */;
1378 long var8 /* : Int */;
1379 val* var9 /* : String */;
1380 val* var10 /* : MClass */;
1381 val* var11 /* : MModule */;
1382 val* var12 /* : String */;
1383 val* var13 /* : String */;
1384 static val* varonce14;
1385 val* var15 /* : String */;
1386 char* var16 /* : NativeString */;
1387 long var17 /* : Int */;
1388 val* var18 /* : String */;
1389 val* var19 /* : MClass */;
1390 val* var20 /* : String */;
1391 val* var21 /* : String */;
1392 static val* varonce22;
1393 val* var23 /* : String */;
1394 char* var24 /* : NativeString */;
1395 long var25 /* : Int */;
1396 val* var26 /* : String */;
1397 val* var27 /* : String */;
1398 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__MType__c_name_cache]))(self) /* c_name_cache on <self:MClassType>*/;
1399 var_res = var1;
1400 var2 = NULL;
1401 if (var_res == NULL) {
1402 var3 = 0; /* is null */
1403 } else {
1404 var3 = 1; /* arg is null and recv is not */
1405 }
1406 if (var3){
1407 var = var_res;
1408 goto RET_LABEL;
1409 } else {
1410 }
1411 var4 = NEW_array__Array(&type_array__Arraykernel__Object);
1412 var5 = 5;
1413 ((void (*)(val*, long))(var4->class->vft[COLOR_array__Array__with_capacity]))(var4, var5) /* with_capacity on <var4:Array[Object]>*/;
1414 CHECK_NEW_array__Array(var4);
1415 var_ = var4;
1416 if (varonce) {
1417 var6 = varonce;
1418 } else {
1419 var7 = "";
1420 var8 = 0;
1421 var9 = string__NativeString__to_s_with_length(var7, var8);
1422 var6 = var9;
1423 varonce = var6;
1424 }
1425 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var6) /* add on <var_:Array[Object]>*/;
1426 var10 = ((val* (*)(val*))(self->class->vft[COLOR_model__MClassType__mclass]))(self) /* mclass on <self:MClassType>*/;
1427 var11 = ((val* (*)(val*))(var10->class->vft[COLOR_model__MClass__intro_mmodule]))(var10) /* intro_mmodule on <var10:MClass>*/;
1428 var12 = ((val* (*)(val*))(var11->class->vft[COLOR_model_base__MModule__name]))(var11) /* name on <var11:MModule>*/;
1429 var13 = ((val* (*)(val*))(var12->class->vft[COLOR_string__AbstractString__to_cmangle]))(var12) /* to_cmangle on <var12:String>*/;
1430 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var13) /* add on <var_:Array[Object]>*/;
1431 if (varonce14) {
1432 var15 = varonce14;
1433 } else {
1434 var16 = "__";
1435 var17 = 2;
1436 var18 = string__NativeString__to_s_with_length(var16, var17);
1437 var15 = var18;
1438 varonce14 = var15;
1439 }
1440 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var15) /* add on <var_:Array[Object]>*/;
1441 var19 = ((val* (*)(val*))(self->class->vft[COLOR_model__MClassType__mclass]))(self) /* mclass on <self:MClassType>*/;
1442 var20 = ((val* (*)(val*))(var19->class->vft[COLOR_model__MClass__name]))(var19) /* name on <var19:MClass>*/;
1443 var21 = ((val* (*)(val*))(var20->class->vft[COLOR_string__AbstractString__to_cmangle]))(var20) /* to_cmangle on <var20:String>*/;
1444 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var21) /* add on <var_:Array[Object]>*/;
1445 if (varonce22) {
1446 var23 = varonce22;
1447 } else {
1448 var24 = "";
1449 var25 = 0;
1450 var26 = string__NativeString__to_s_with_length(var24, var25);
1451 var23 = var26;
1452 varonce22 = var23;
1453 }
1454 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var23) /* add on <var_:Array[Object]>*/;
1455 var27 = ((val* (*)(val*))(var_->class->vft[COLOR_string__Object__to_s]))(var_) /* to_s on <var_:Array[Object]>*/;
1456 var_res = var27;
1457 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__MType__c_name_cache_61d]))(self, var_res) /* c_name_cache= on <self:MClassType>*/;
1458 var = var_res;
1459 goto RET_LABEL;
1460 RET_LABEL:;
1461 return var;
1462 }
1463 /* method abstract_compiler#MClassType#c_name for (self: Object): String */
1464 val* VIRTUAL_abstract_compiler__MClassType__c_name(val* self) {
1465 val* var /* : String */;
1466 val* var1 /* : String */;
1467 var1 = abstract_compiler__MClassType__c_name(self);
1468 var = var1;
1469 RET_LABEL:;
1470 return var;
1471 }
1472 /* method abstract_compiler#MClassType#ctype for (self: MClassType): String */
1473 val* abstract_compiler__MClassType__ctype(val* self) {
1474 val* var /* : String */;
1475 val* var1 /* : MClass */;
1476 val* var2 /* : String */;
1477 static val* varonce;
1478 val* var3 /* : String */;
1479 char* var4 /* : NativeString */;
1480 long var5 /* : Int */;
1481 val* var6 /* : String */;
1482 short int var7 /* : Bool */;
1483 static val* varonce8;
1484 val* var9 /* : String */;
1485 char* var10 /* : NativeString */;
1486 long var11 /* : Int */;
1487 val* var12 /* : String */;
1488 val* var13 /* : MClass */;
1489 val* var14 /* : String */;
1490 static val* varonce15;
1491 val* var16 /* : String */;
1492 char* var17 /* : NativeString */;
1493 long var18 /* : Int */;
1494 val* var19 /* : String */;
1495 short int var20 /* : Bool */;
1496 static val* varonce21;
1497 val* var22 /* : String */;
1498 char* var23 /* : NativeString */;
1499 long var24 /* : Int */;
1500 val* var25 /* : String */;
1501 val* var26 /* : MClass */;
1502 val* var27 /* : String */;
1503 static val* varonce28;
1504 val* var29 /* : String */;
1505 char* var30 /* : NativeString */;
1506 long var31 /* : Int */;
1507 val* var32 /* : String */;
1508 short int var33 /* : Bool */;
1509 static val* varonce34;
1510 val* var35 /* : String */;
1511 char* var36 /* : NativeString */;
1512 long var37 /* : Int */;
1513 val* var38 /* : String */;
1514 val* var39 /* : MClass */;
1515 val* var40 /* : String */;
1516 static val* varonce41;
1517 val* var42 /* : String */;
1518 char* var43 /* : NativeString */;
1519 long var44 /* : Int */;
1520 val* var45 /* : String */;
1521 short int var46 /* : Bool */;
1522 static val* varonce47;
1523 val* var48 /* : String */;
1524 char* var49 /* : NativeString */;
1525 long var50 /* : Int */;
1526 val* var51 /* : String */;
1527 val* var52 /* : MClass */;
1528 val* var53 /* : String */;
1529 static val* varonce54;
1530 val* var55 /* : String */;
1531 char* var56 /* : NativeString */;
1532 long var57 /* : Int */;
1533 val* var58 /* : String */;
1534 short int var59 /* : Bool */;
1535 static val* varonce60;
1536 val* var61 /* : String */;
1537 char* var62 /* : NativeString */;
1538 long var63 /* : Int */;
1539 val* var64 /* : String */;
1540 val* var65 /* : MClass */;
1541 val* var66 /* : String */;
1542 static val* varonce67;
1543 val* var68 /* : String */;
1544 char* var69 /* : NativeString */;
1545 long var70 /* : Int */;
1546 val* var71 /* : String */;
1547 short int var72 /* : Bool */;
1548 static val* varonce73;
1549 val* var74 /* : String */;
1550 char* var75 /* : NativeString */;
1551 long var76 /* : Int */;
1552 val* var77 /* : String */;
1553 val* var78 /* : MClass */;
1554 val* var79 /* : MClassKind */;
1555 val* var80 /* : MClassKind */;
1556 short int var81 /* : Bool */;
1557 static val* varonce82;
1558 val* var83 /* : String */;
1559 char* var84 /* : NativeString */;
1560 long var85 /* : Int */;
1561 val* var86 /* : String */;
1562 static val* varonce87;
1563 val* var88 /* : String */;
1564 char* var89 /* : NativeString */;
1565 long var90 /* : Int */;
1566 val* var91 /* : String */;
1567 var1 = ((val* (*)(val*))(self->class->vft[COLOR_model__MClassType__mclass]))(self) /* mclass on <self:MClassType>*/;
1568 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_model__MClass__name]))(var1) /* name on <var1:MClass>*/;
1569 if (varonce) {
1570 var3 = varonce;
1571 } else {
1572 var4 = "Int";
1573 var5 = 3;
1574 var6 = string__NativeString__to_s_with_length(var4, var5);
1575 var3 = var6;
1576 varonce = var3;
1577 }
1578 var7 = ((short int (*)(val*, val*))(var2->class->vft[COLOR_kernel__Object___61d_61d]))(var2, var3) /* == on <var2:String>*/;
1579 if (var7){
1580 if (varonce8) {
1581 var9 = varonce8;
1582 } else {
1583 var10 = "long";
1584 var11 = 4;
1585 var12 = string__NativeString__to_s_with_length(var10, var11);
1586 var9 = var12;
1587 varonce8 = var9;
1588 }
1589 var = var9;
1590 goto RET_LABEL;
1591 } else {
1592 var13 = ((val* (*)(val*))(self->class->vft[COLOR_model__MClassType__mclass]))(self) /* mclass on <self:MClassType>*/;
1593 var14 = ((val* (*)(val*))(var13->class->vft[COLOR_model__MClass__name]))(var13) /* name on <var13:MClass>*/;
1594 if (varonce15) {
1595 var16 = varonce15;
1596 } else {
1597 var17 = "Bool";
1598 var18 = 4;
1599 var19 = string__NativeString__to_s_with_length(var17, var18);
1600 var16 = var19;
1601 varonce15 = var16;
1602 }
1603 var20 = ((short int (*)(val*, val*))(var14->class->vft[COLOR_kernel__Object___61d_61d]))(var14, var16) /* == on <var14:String>*/;
1604 if (var20){
1605 if (varonce21) {
1606 var22 = varonce21;
1607 } else {
1608 var23 = "short int";
1609 var24 = 9;
1610 var25 = string__NativeString__to_s_with_length(var23, var24);
1611 var22 = var25;
1612 varonce21 = var22;
1613 }
1614 var = var22;
1615 goto RET_LABEL;
1616 } else {
1617 var26 = ((val* (*)(val*))(self->class->vft[COLOR_model__MClassType__mclass]))(self) /* mclass on <self:MClassType>*/;
1618 var27 = ((val* (*)(val*))(var26->class->vft[COLOR_model__MClass__name]))(var26) /* name on <var26:MClass>*/;
1619 if (varonce28) {
1620 var29 = varonce28;
1621 } else {
1622 var30 = "Char";
1623 var31 = 4;
1624 var32 = string__NativeString__to_s_with_length(var30, var31);
1625 var29 = var32;
1626 varonce28 = var29;
1627 }
1628 var33 = ((short int (*)(val*, val*))(var27->class->vft[COLOR_kernel__Object___61d_61d]))(var27, var29) /* == on <var27:String>*/;
1629 if (var33){
1630 if (varonce34) {
1631 var35 = varonce34;
1632 } else {
1633 var36 = "char";
1634 var37 = 4;
1635 var38 = string__NativeString__to_s_with_length(var36, var37);
1636 var35 = var38;
1637 varonce34 = var35;
1638 }
1639 var = var35;
1640 goto RET_LABEL;
1641 } else {
1642 var39 = ((val* (*)(val*))(self->class->vft[COLOR_model__MClassType__mclass]))(self) /* mclass on <self:MClassType>*/;
1643 var40 = ((val* (*)(val*))(var39->class->vft[COLOR_model__MClass__name]))(var39) /* name on <var39:MClass>*/;
1644 if (varonce41) {
1645 var42 = varonce41;
1646 } else {
1647 var43 = "Float";
1648 var44 = 5;
1649 var45 = string__NativeString__to_s_with_length(var43, var44);
1650 var42 = var45;
1651 varonce41 = var42;
1652 }
1653 var46 = ((short int (*)(val*, val*))(var40->class->vft[COLOR_kernel__Object___61d_61d]))(var40, var42) /* == on <var40:String>*/;
1654 if (var46){
1655 if (varonce47) {
1656 var48 = varonce47;
1657 } else {
1658 var49 = "double";
1659 var50 = 6;
1660 var51 = string__NativeString__to_s_with_length(var49, var50);
1661 var48 = var51;
1662 varonce47 = var48;
1663 }
1664 var = var48;
1665 goto RET_LABEL;
1666 } else {
1667 var52 = ((val* (*)(val*))(self->class->vft[COLOR_model__MClassType__mclass]))(self) /* mclass on <self:MClassType>*/;
1668 var53 = ((val* (*)(val*))(var52->class->vft[COLOR_model__MClass__name]))(var52) /* name on <var52:MClass>*/;
1669 if (varonce54) {
1670 var55 = varonce54;
1671 } else {
1672 var56 = "NativeString";
1673 var57 = 12;
1674 var58 = string__NativeString__to_s_with_length(var56, var57);
1675 var55 = var58;
1676 varonce54 = var55;
1677 }
1678 var59 = ((short int (*)(val*, val*))(var53->class->vft[COLOR_kernel__Object___61d_61d]))(var53, var55) /* == on <var53:String>*/;
1679 if (var59){
1680 if (varonce60) {
1681 var61 = varonce60;
1682 } else {
1683 var62 = "char*";
1684 var63 = 5;
1685 var64 = string__NativeString__to_s_with_length(var62, var63);
1686 var61 = var64;
1687 varonce60 = var61;
1688 }
1689 var = var61;
1690 goto RET_LABEL;
1691 } else {
1692 var65 = ((val* (*)(val*))(self->class->vft[COLOR_model__MClassType__mclass]))(self) /* mclass on <self:MClassType>*/;
1693 var66 = ((val* (*)(val*))(var65->class->vft[COLOR_model__MClass__name]))(var65) /* name on <var65:MClass>*/;
1694 if (varonce67) {
1695 var68 = varonce67;
1696 } else {
1697 var69 = "NativeArray";
1698 var70 = 11;
1699 var71 = string__NativeString__to_s_with_length(var69, var70);
1700 var68 = var71;
1701 varonce67 = var68;
1702 }
1703 var72 = ((short int (*)(val*, val*))(var66->class->vft[COLOR_kernel__Object___61d_61d]))(var66, var68) /* == on <var66:String>*/;
1704 if (var72){
1705 if (varonce73) {
1706 var74 = varonce73;
1707 } else {
1708 var75 = "val*";
1709 var76 = 4;
1710 var77 = string__NativeString__to_s_with_length(var75, var76);
1711 var74 = var77;
1712 varonce73 = var74;
1713 }
1714 var = var74;
1715 goto RET_LABEL;
1716 } else {
1717 var78 = ((val* (*)(val*))(self->class->vft[COLOR_model__MClassType__mclass]))(self) /* mclass on <self:MClassType>*/;
1718 var79 = ((val* (*)(val*))(var78->class->vft[COLOR_model__MClass__kind]))(var78) /* kind on <var78:MClass>*/;
1719 var80 = ((val* (*)(val*))(self->class->vft[COLOR_model__Object__extern_kind]))(self) /* extern_kind on <self:MClassType>*/;
1720 var81 = ((short int (*)(val*, val*))(var79->class->vft[COLOR_kernel__Object___61d_61d]))(var79, var80) /* == on <var79:MClassKind>*/;
1721 if (var81){
1722 if (varonce82) {
1723 var83 = varonce82;
1724 } else {
1725 var84 = "void*";
1726 var85 = 5;
1727 var86 = string__NativeString__to_s_with_length(var84, var85);
1728 var83 = var86;
1729 varonce82 = var83;
1730 }
1731 var = var83;
1732 goto RET_LABEL;
1733 } else {
1734 if (varonce87) {
1735 var88 = varonce87;
1736 } else {
1737 var89 = "val*";
1738 var90 = 4;
1739 var91 = string__NativeString__to_s_with_length(var89, var90);
1740 var88 = var91;
1741 varonce87 = var88;
1742 }
1743 var = var88;
1744 goto RET_LABEL;
1745 }
1746 }
1747 }
1748 }
1749 }
1750 }
1751 }
1752 RET_LABEL:;
1753 return var;
1754 }
1755 /* method abstract_compiler#MClassType#ctype for (self: Object): String */
1756 val* VIRTUAL_abstract_compiler__MClassType__ctype(val* self) {
1757 val* var /* : String */;
1758 val* var1 /* : String */;
1759 var1 = abstract_compiler__MClassType__ctype(self);
1760 var = var1;
1761 RET_LABEL:;
1762 return var;
1763 }
1764 /* method abstract_compiler#MClassType#ctypename for (self: MClassType): String */
1765 val* abstract_compiler__MClassType__ctypename(val* self) {
1766 val* var /* : String */;
1767 val* var1 /* : MClass */;
1768 val* var2 /* : String */;
1769 static val* varonce;
1770 val* var3 /* : String */;
1771 char* var4 /* : NativeString */;
1772 long var5 /* : Int */;
1773 val* var6 /* : String */;
1774 short int var7 /* : Bool */;
1775 static val* varonce8;
1776 val* var9 /* : String */;
1777 char* var10 /* : NativeString */;
1778 long var11 /* : Int */;
1779 val* var12 /* : String */;
1780 val* var13 /* : MClass */;
1781 val* var14 /* : String */;
1782 static val* varonce15;
1783 val* var16 /* : String */;
1784 char* var17 /* : NativeString */;
1785 long var18 /* : Int */;
1786 val* var19 /* : String */;
1787 short int var20 /* : Bool */;
1788 static val* varonce21;
1789 val* var22 /* : String */;
1790 char* var23 /* : NativeString */;
1791 long var24 /* : Int */;
1792 val* var25 /* : String */;
1793 val* var26 /* : MClass */;
1794 val* var27 /* : String */;
1795 static val* varonce28;
1796 val* var29 /* : String */;
1797 char* var30 /* : NativeString */;
1798 long var31 /* : Int */;
1799 val* var32 /* : String */;
1800 short int var33 /* : Bool */;
1801 static val* varonce34;
1802 val* var35 /* : String */;
1803 char* var36 /* : NativeString */;
1804 long var37 /* : Int */;
1805 val* var38 /* : String */;
1806 val* var39 /* : MClass */;
1807 val* var40 /* : String */;
1808 static val* varonce41;
1809 val* var42 /* : String */;
1810 char* var43 /* : NativeString */;
1811 long var44 /* : Int */;
1812 val* var45 /* : String */;
1813 short int var46 /* : Bool */;
1814 static val* varonce47;
1815 val* var48 /* : String */;
1816 char* var49 /* : NativeString */;
1817 long var50 /* : Int */;
1818 val* var51 /* : String */;
1819 val* var52 /* : MClass */;
1820 val* var53 /* : String */;
1821 static val* varonce54;
1822 val* var55 /* : String */;
1823 char* var56 /* : NativeString */;
1824 long var57 /* : Int */;
1825 val* var58 /* : String */;
1826 short int var59 /* : Bool */;
1827 static val* varonce60;
1828 val* var61 /* : String */;
1829 char* var62 /* : NativeString */;
1830 long var63 /* : Int */;
1831 val* var64 /* : String */;
1832 val* var65 /* : MClass */;
1833 val* var66 /* : String */;
1834 static val* varonce67;
1835 val* var68 /* : String */;
1836 char* var69 /* : NativeString */;
1837 long var70 /* : Int */;
1838 val* var71 /* : String */;
1839 short int var72 /* : Bool */;
1840 static val* varonce73;
1841 val* var74 /* : String */;
1842 char* var75 /* : NativeString */;
1843 long var76 /* : Int */;
1844 val* var77 /* : String */;
1845 val* var78 /* : MClass */;
1846 val* var79 /* : MClassKind */;
1847 val* var80 /* : MClassKind */;
1848 short int var81 /* : Bool */;
1849 static val* varonce82;
1850 val* var83 /* : String */;
1851 char* var84 /* : NativeString */;
1852 long var85 /* : Int */;
1853 val* var86 /* : String */;
1854 static val* varonce87;
1855 val* var88 /* : String */;
1856 char* var89 /* : NativeString */;
1857 long var90 /* : Int */;
1858 val* var91 /* : String */;
1859 var1 = ((val* (*)(val*))(self->class->vft[COLOR_model__MClassType__mclass]))(self) /* mclass on <self:MClassType>*/;
1860 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_model__MClass__name]))(var1) /* name on <var1:MClass>*/;
1861 if (varonce) {
1862 var3 = varonce;
1863 } else {
1864 var4 = "Int";
1865 var5 = 3;
1866 var6 = string__NativeString__to_s_with_length(var4, var5);
1867 var3 = var6;
1868 varonce = var3;
1869 }
1870 var7 = ((short int (*)(val*, val*))(var2->class->vft[COLOR_kernel__Object___61d_61d]))(var2, var3) /* == on <var2:String>*/;
1871 if (var7){
1872 if (varonce8) {
1873 var9 = varonce8;
1874 } else {
1875 var10 = "l";
1876 var11 = 1;
1877 var12 = string__NativeString__to_s_with_length(var10, var11);
1878 var9 = var12;
1879 varonce8 = var9;
1880 }
1881 var = var9;
1882 goto RET_LABEL;
1883 } else {
1884 var13 = ((val* (*)(val*))(self->class->vft[COLOR_model__MClassType__mclass]))(self) /* mclass on <self:MClassType>*/;
1885 var14 = ((val* (*)(val*))(var13->class->vft[COLOR_model__MClass__name]))(var13) /* name on <var13:MClass>*/;
1886 if (varonce15) {
1887 var16 = varonce15;
1888 } else {
1889 var17 = "Bool";
1890 var18 = 4;
1891 var19 = string__NativeString__to_s_with_length(var17, var18);
1892 var16 = var19;
1893 varonce15 = var16;
1894 }
1895 var20 = ((short int (*)(val*, val*))(var14->class->vft[COLOR_kernel__Object___61d_61d]))(var14, var16) /* == on <var14:String>*/;
1896 if (var20){
1897 if (varonce21) {
1898 var22 = varonce21;
1899 } else {
1900 var23 = "s";
1901 var24 = 1;
1902 var25 = string__NativeString__to_s_with_length(var23, var24);
1903 var22 = var25;
1904 varonce21 = var22;
1905 }
1906 var = var22;
1907 goto RET_LABEL;
1908 } else {
1909 var26 = ((val* (*)(val*))(self->class->vft[COLOR_model__MClassType__mclass]))(self) /* mclass on <self:MClassType>*/;
1910 var27 = ((val* (*)(val*))(var26->class->vft[COLOR_model__MClass__name]))(var26) /* name on <var26:MClass>*/;
1911 if (varonce28) {
1912 var29 = varonce28;
1913 } else {
1914 var30 = "Char";
1915 var31 = 4;
1916 var32 = string__NativeString__to_s_with_length(var30, var31);
1917 var29 = var32;
1918 varonce28 = var29;
1919 }
1920 var33 = ((short int (*)(val*, val*))(var27->class->vft[COLOR_kernel__Object___61d_61d]))(var27, var29) /* == on <var27:String>*/;
1921 if (var33){
1922 if (varonce34) {
1923 var35 = varonce34;
1924 } else {
1925 var36 = "c";
1926 var37 = 1;
1927 var38 = string__NativeString__to_s_with_length(var36, var37);
1928 var35 = var38;
1929 varonce34 = var35;
1930 }
1931 var = var35;
1932 goto RET_LABEL;
1933 } else {
1934 var39 = ((val* (*)(val*))(self->class->vft[COLOR_model__MClassType__mclass]))(self) /* mclass on <self:MClassType>*/;
1935 var40 = ((val* (*)(val*))(var39->class->vft[COLOR_model__MClass__name]))(var39) /* name on <var39:MClass>*/;
1936 if (varonce41) {
1937 var42 = varonce41;
1938 } else {
1939 var43 = "Float";
1940 var44 = 5;
1941 var45 = string__NativeString__to_s_with_length(var43, var44);
1942 var42 = var45;
1943 varonce41 = var42;
1944 }
1945 var46 = ((short int (*)(val*, val*))(var40->class->vft[COLOR_kernel__Object___61d_61d]))(var40, var42) /* == on <var40:String>*/;
1946 if (var46){
1947 if (varonce47) {
1948 var48 = varonce47;
1949 } else {
1950 var49 = "d";
1951 var50 = 1;
1952 var51 = string__NativeString__to_s_with_length(var49, var50);
1953 var48 = var51;
1954 varonce47 = var48;
1955 }
1956 var = var48;
1957 goto RET_LABEL;
1958 } else {
1959 var52 = ((val* (*)(val*))(self->class->vft[COLOR_model__MClassType__mclass]))(self) /* mclass on <self:MClassType>*/;
1960 var53 = ((val* (*)(val*))(var52->class->vft[COLOR_model__MClass__name]))(var52) /* name on <var52:MClass>*/;
1961 if (varonce54) {
1962 var55 = varonce54;
1963 } else {
1964 var56 = "NativeString";
1965 var57 = 12;
1966 var58 = string__NativeString__to_s_with_length(var56, var57);
1967 var55 = var58;
1968 varonce54 = var55;
1969 }
1970 var59 = ((short int (*)(val*, val*))(var53->class->vft[COLOR_kernel__Object___61d_61d]))(var53, var55) /* == on <var53:String>*/;
1971 if (var59){
1972 if (varonce60) {
1973 var61 = varonce60;
1974 } else {
1975 var62 = "str";
1976 var63 = 3;
1977 var64 = string__NativeString__to_s_with_length(var62, var63);
1978 var61 = var64;
1979 varonce60 = var61;
1980 }
1981 var = var61;
1982 goto RET_LABEL;
1983 } else {
1984 var65 = ((val* (*)(val*))(self->class->vft[COLOR_model__MClassType__mclass]))(self) /* mclass on <self:MClassType>*/;
1985 var66 = ((val* (*)(val*))(var65->class->vft[COLOR_model__MClass__name]))(var65) /* name on <var65:MClass>*/;
1986 if (varonce67) {
1987 var68 = varonce67;
1988 } else {
1989 var69 = "NativeArray";
1990 var70 = 11;
1991 var71 = string__NativeString__to_s_with_length(var69, var70);
1992 var68 = var71;
1993 varonce67 = var68;
1994 }
1995 var72 = ((short int (*)(val*, val*))(var66->class->vft[COLOR_kernel__Object___61d_61d]))(var66, var68) /* == on <var66:String>*/;
1996 if (var72){
1997 if (varonce73) {
1998 var74 = varonce73;
1999 } else {
2000 var75 = "val";
2001 var76 = 3;
2002 var77 = string__NativeString__to_s_with_length(var75, var76);
2003 var74 = var77;
2004 varonce73 = var74;
2005 }
2006 var = var74;
2007 goto RET_LABEL;
2008 } else {
2009 var78 = ((val* (*)(val*))(self->class->vft[COLOR_model__MClassType__mclass]))(self) /* mclass on <self:MClassType>*/;
2010 var79 = ((val* (*)(val*))(var78->class->vft[COLOR_model__MClass__kind]))(var78) /* kind on <var78:MClass>*/;
2011 var80 = ((val* (*)(val*))(self->class->vft[COLOR_model__Object__extern_kind]))(self) /* extern_kind on <self:MClassType>*/;
2012 var81 = ((short int (*)(val*, val*))(var79->class->vft[COLOR_kernel__Object___61d_61d]))(var79, var80) /* == on <var79:MClassKind>*/;
2013 if (var81){
2014 if (varonce82) {
2015 var83 = varonce82;
2016 } else {
2017 var84 = "ptr";
2018 var85 = 3;
2019 var86 = string__NativeString__to_s_with_length(var84, var85);
2020 var83 = var86;
2021 varonce82 = var83;
2022 }
2023 var = var83;
2024 goto RET_LABEL;
2025 } else {
2026 if (varonce87) {
2027 var88 = varonce87;
2028 } else {
2029 var89 = "val";
2030 var90 = 3;
2031 var91 = string__NativeString__to_s_with_length(var89, var90);
2032 var88 = var91;
2033 varonce87 = var88;
2034 }
2035 var = var88;
2036 goto RET_LABEL;
2037 }
2038 }
2039 }
2040 }
2041 }
2042 }
2043 }
2044 RET_LABEL:;
2045 return var;
2046 }
2047 /* method abstract_compiler#MClassType#ctypename for (self: Object): String */
2048 val* VIRTUAL_abstract_compiler__MClassType__ctypename(val* self) {
2049 val* var /* : String */;
2050 val* var1 /* : String */;
2051 var1 = abstract_compiler__MClassType__ctypename(self);
2052 var = var1;
2053 RET_LABEL:;
2054 return var;
2055 }
2056 /* method abstract_compiler#MGenericType#c_name for (self: MGenericType): String */
2057 val* abstract_compiler__MGenericType__c_name(val* self) {
2058 val* var /* : String */;
2059 val* var1 /* : nullable String */;
2060 val* var_res /* var res: nullable String */;
2061 val* var2 /* : null */;
2062 short int var3 /* : Bool */;
2063 val* var4 /* : String */;
2064 val* var5 /* : Array[MType] */;
2065 val* var6 /* : Iterator[nullable Object] */;
2066 short int var7 /* : Bool */;
2067 val* var8 /* : nullable Object */;
2068 val* var_t /* var t: MType */;
2069 val* var9 /* : String */;
2070 val* var10 /* : String */;
2071 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__MType__c_name_cache]))(self) /* c_name_cache on <self:MGenericType>*/;
2072 var_res = var1;
2073 var2 = NULL;
2074 if (var_res == NULL) {
2075 var3 = 0; /* is null */
2076 } else {
2077 var3 = 1; /* arg is null and recv is not */
2078 }
2079 if (var3){
2080 var = var_res;
2081 goto RET_LABEL;
2082 } else {
2083 }
2084 var4 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__MGenericType__c_name]))(self) /* c_name on <self:MGenericType>*/;
2085 var_res = var4;
2086 var5 = ((val* (*)(val*))(self->class->vft[COLOR_model__MClassType__arguments]))(self) /* arguments on <self:MGenericType>*/;
2087 var6 = ((val* (*)(val*))(var5->class->vft[COLOR_abstract_collection__Collection__iterator]))(var5) /* iterator on <var5:Array[MType]>*/;
2088 for(;;) {
2089 var7 = ((short int (*)(val*))(var6->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var6) /* is_ok on <var6:Iterator[nullable Object]>*/;
2090 if(!var7) break;
2091 var8 = ((val* (*)(val*))(var6->class->vft[COLOR_abstract_collection__Iterator__item]))(var6) /* item on <var6:Iterator[nullable Object]>*/;
2092 var_t = var8;
2093 var9 = ((val* (*)(val*))(var_t->class->vft[COLOR_abstract_compiler__MType__c_name]))(var_t) /* c_name on <var_t:MType>*/;
2094 var10 = ((val* (*)(val*, val*))(var_res->class->vft[COLOR_string__String___43d]))(var_res, var9) /* + on <var_res:nullable String(String)>*/;
2095 var_res = var10;
2096 CONTINUE_label: (void)0;
2097 ((void (*)(val*))(var6->class->vft[COLOR_abstract_collection__Iterator__next]))(var6) /* next on <var6:Iterator[nullable Object]>*/;
2098 }
2099 BREAK_label: (void)0;
2100 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__MType__c_name_cache_61d]))(self, var_res) /* c_name_cache= on <self:MGenericType>*/;
2101 var = var_res;
2102 goto RET_LABEL;
2103 RET_LABEL:;
2104 return var;
2105 }
2106 /* method abstract_compiler#MGenericType#c_name for (self: Object): String */
2107 val* VIRTUAL_abstract_compiler__MGenericType__c_name(val* self) {
2108 val* var /* : String */;
2109 val* var1 /* : String */;
2110 var1 = abstract_compiler__MGenericType__c_name(self);
2111 var = var1;
2112 RET_LABEL:;
2113 return var;
2114 }
2115 /* method abstract_compiler#MParameterType#c_name for (self: MParameterType): String */
2116 val* abstract_compiler__MParameterType__c_name(val* self) {
2117 val* var /* : String */;
2118 val* var1 /* : nullable String */;
2119 val* var_res /* var res: nullable String */;
2120 val* var2 /* : null */;
2121 short int var3 /* : Bool */;
2122 val* var4 /* : Array[Object] */;
2123 long var5 /* : Int */;
2124 val* var_ /* var : Array[Object] */;
2125 static val* varonce;
2126 val* var6 /* : String */;
2127 char* var7 /* : NativeString */;
2128 long var8 /* : Int */;
2129 val* var9 /* : String */;
2130 val* var10 /* : MClass */;
2131 val* var11 /* : String */;
2132 static val* varonce12;
2133 val* var13 /* : String */;
2134 char* var14 /* : NativeString */;
2135 long var15 /* : Int */;
2136 val* var16 /* : String */;
2137 long var17 /* : Int */;
2138 val* var18 /* : nullable Object */;
2139 static val* varonce19;
2140 val* var20 /* : String */;
2141 char* var21 /* : NativeString */;
2142 long var22 /* : Int */;
2143 val* var23 /* : String */;
2144 val* var24 /* : String */;
2145 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__MType__c_name_cache]))(self) /* c_name_cache on <self:MParameterType>*/;
2146 var_res = var1;
2147 var2 = NULL;
2148 if (var_res == NULL) {
2149 var3 = 0; /* is null */
2150 } else {
2151 var3 = 1; /* arg is null and recv is not */
2152 }
2153 if (var3){
2154 var = var_res;
2155 goto RET_LABEL;
2156 } else {
2157 }
2158 var4 = NEW_array__Array(&type_array__Arraykernel__Object);
2159 var5 = 5;
2160 ((void (*)(val*, long))(var4->class->vft[COLOR_array__Array__with_capacity]))(var4, var5) /* with_capacity on <var4:Array[Object]>*/;
2161 CHECK_NEW_array__Array(var4);
2162 var_ = var4;
2163 if (varonce) {
2164 var6 = varonce;
2165 } else {
2166 var7 = "";
2167 var8 = 0;
2168 var9 = string__NativeString__to_s_with_length(var7, var8);
2169 var6 = var9;
2170 varonce = var6;
2171 }
2172 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var6) /* add on <var_:Array[Object]>*/;
2173 var10 = ((val* (*)(val*))(self->class->vft[COLOR_model__MParameterType__mclass]))(self) /* mclass on <self:MParameterType>*/;
2174 var11 = ((val* (*)(val*))(var10->class->vft[COLOR_abstract_compiler__MClass__c_name]))(var10) /* c_name on <var10:MClass>*/;
2175 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var11) /* add on <var_:Array[Object]>*/;
2176 if (varonce12) {
2177 var13 = varonce12;
2178 } else {
2179 var14 = "_FT";
2180 var15 = 3;
2181 var16 = string__NativeString__to_s_with_length(var14, var15);
2182 var13 = var16;
2183 varonce12 = var13;
2184 }
2185 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var13) /* add on <var_:Array[Object]>*/;
2186 var17 = ((long (*)(val*))(self->class->vft[COLOR_model__MParameterType__rank]))(self) /* rank on <self:MParameterType>*/;
2187 var18 = BOX_kernel__Int(var17); /* autobox from Int to nullable Object */
2188 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var18) /* add on <var_:Array[Object]>*/;
2189 if (varonce19) {
2190 var20 = varonce19;
2191 } else {
2192 var21 = "";
2193 var22 = 0;
2194 var23 = string__NativeString__to_s_with_length(var21, var22);
2195 var20 = var23;
2196 varonce19 = var20;
2197 }
2198 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var20) /* add on <var_:Array[Object]>*/;
2199 var24 = ((val* (*)(val*))(var_->class->vft[COLOR_string__Object__to_s]))(var_) /* to_s on <var_:Array[Object]>*/;
2200 var_res = var24;
2201 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__MType__c_name_cache_61d]))(self, var_res) /* c_name_cache= on <self:MParameterType>*/;
2202 var = var_res;
2203 goto RET_LABEL;
2204 RET_LABEL:;
2205 return var;
2206 }
2207 /* method abstract_compiler#MParameterType#c_name for (self: Object): String */
2208 val* VIRTUAL_abstract_compiler__MParameterType__c_name(val* self) {
2209 val* var /* : String */;
2210 val* var1 /* : String */;
2211 var1 = abstract_compiler__MParameterType__c_name(self);
2212 var = var1;
2213 RET_LABEL:;
2214 return var;
2215 }
2216 /* method abstract_compiler#MVirtualType#c_name for (self: MVirtualType): String */
2217 val* abstract_compiler__MVirtualType__c_name(val* self) {
2218 val* var /* : String */;
2219 val* var1 /* : nullable String */;
2220 val* var_res /* var res: nullable String */;
2221 val* var2 /* : null */;
2222 short int var3 /* : Bool */;
2223 val* var4 /* : Array[Object] */;
2224 long var5 /* : Int */;
2225 val* var_ /* var : Array[Object] */;
2226 static val* varonce;
2227 val* var6 /* : String */;
2228 char* var7 /* : NativeString */;
2229 long var8 /* : Int */;
2230 val* var9 /* : String */;
2231 val* var10 /* : MProperty */;
2232 val* var11 /* : MPropDef */;
2233 val* var12 /* : MClassDef */;
2234 val* var13 /* : MClass */;
2235 val* var14 /* : String */;
2236 static val* varonce15;
2237 val* var16 /* : String */;
2238 char* var17 /* : NativeString */;
2239 long var18 /* : Int */;
2240 val* var19 /* : String */;
2241 val* var20 /* : MProperty */;
2242 val* var21 /* : String */;
2243 static val* varonce22;
2244 val* var23 /* : String */;
2245 char* var24 /* : NativeString */;
2246 long var25 /* : Int */;
2247 val* var26 /* : String */;
2248 val* var27 /* : String */;
2249 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__MType__c_name_cache]))(self) /* c_name_cache on <self:MVirtualType>*/;
2250 var_res = var1;
2251 var2 = NULL;
2252 if (var_res == NULL) {
2253 var3 = 0; /* is null */
2254 } else {
2255 var3 = 1; /* arg is null and recv is not */
2256 }
2257 if (var3){
2258 var = var_res;
2259 goto RET_LABEL;
2260 } else {
2261 }
2262 var4 = NEW_array__Array(&type_array__Arraykernel__Object);
2263 var5 = 5;
2264 ((void (*)(val*, long))(var4->class->vft[COLOR_array__Array__with_capacity]))(var4, var5) /* with_capacity on <var4:Array[Object]>*/;
2265 CHECK_NEW_array__Array(var4);
2266 var_ = var4;
2267 if (varonce) {
2268 var6 = varonce;
2269 } else {
2270 var7 = "";
2271 var8 = 0;
2272 var9 = string__NativeString__to_s_with_length(var7, var8);
2273 var6 = var9;
2274 varonce = var6;
2275 }
2276 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var6) /* add on <var_:Array[Object]>*/;
2277 var10 = ((val* (*)(val*))(self->class->vft[COLOR_model__MVirtualType__mproperty]))(self) /* mproperty on <self:MVirtualType>*/;
2278 var11 = ((val* (*)(val*))(var10->class->vft[COLOR_model__MProperty__intro]))(var10) /* intro on <var10:MProperty>*/;
2279 var12 = ((val* (*)(val*))(var11->class->vft[COLOR_model__MPropDef__mclassdef]))(var11) /* mclassdef on <var11:MPropDef>*/;
2280 var13 = ((val* (*)(val*))(var12->class->vft[COLOR_model__MClassDef__mclass]))(var12) /* mclass on <var12:MClassDef>*/;
2281 var14 = ((val* (*)(val*))(var13->class->vft[COLOR_abstract_compiler__MClass__c_name]))(var13) /* c_name on <var13:MClass>*/;
2282 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var14) /* add on <var_:Array[Object]>*/;
2283 if (varonce15) {
2284 var16 = varonce15;
2285 } else {
2286 var17 = "_VT";
2287 var18 = 3;
2288 var19 = string__NativeString__to_s_with_length(var17, var18);
2289 var16 = var19;
2290 varonce15 = var16;
2291 }
2292 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var16) /* add on <var_:Array[Object]>*/;
2293 var20 = ((val* (*)(val*))(self->class->vft[COLOR_model__MVirtualType__mproperty]))(self) /* mproperty on <self:MVirtualType>*/;
2294 var21 = ((val* (*)(val*))(var20->class->vft[COLOR_model__MProperty__name]))(var20) /* name on <var20:MProperty>*/;
2295 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var21) /* add on <var_:Array[Object]>*/;
2296 if (varonce22) {
2297 var23 = varonce22;
2298 } else {
2299 var24 = "";
2300 var25 = 0;
2301 var26 = string__NativeString__to_s_with_length(var24, var25);
2302 var23 = var26;
2303 varonce22 = var23;
2304 }
2305 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var23) /* add on <var_:Array[Object]>*/;
2306 var27 = ((val* (*)(val*))(var_->class->vft[COLOR_string__Object__to_s]))(var_) /* to_s on <var_:Array[Object]>*/;
2307 var_res = var27;
2308 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__MType__c_name_cache_61d]))(self, var_res) /* c_name_cache= on <self:MVirtualType>*/;
2309 var = var_res;
2310 goto RET_LABEL;
2311 RET_LABEL:;
2312 return var;
2313 }
2314 /* method abstract_compiler#MVirtualType#c_name for (self: Object): String */
2315 val* VIRTUAL_abstract_compiler__MVirtualType__c_name(val* self) {
2316 val* var /* : String */;
2317 val* var1 /* : String */;
2318 var1 = abstract_compiler__MVirtualType__c_name(self);
2319 var = var1;
2320 RET_LABEL:;
2321 return var;
2322 }
2323 /* method abstract_compiler#MNullableType#c_name for (self: MNullableType): String */
2324 val* abstract_compiler__MNullableType__c_name(val* self) {
2325 val* var /* : String */;
2326 val* var1 /* : nullable String */;
2327 val* var_res /* var res: nullable String */;
2328 val* var2 /* : null */;
2329 short int var3 /* : Bool */;
2330 val* var4 /* : Array[Object] */;
2331 long var5 /* : Int */;
2332 val* var_ /* var : Array[Object] */;
2333 static val* varonce;
2334 val* var6 /* : String */;
2335 char* var7 /* : NativeString */;
2336 long var8 /* : Int */;
2337 val* var9 /* : String */;
2338 val* var10 /* : MType */;
2339 val* var11 /* : String */;
2340 static val* varonce12;
2341 val* var13 /* : String */;
2342 char* var14 /* : NativeString */;
2343 long var15 /* : Int */;
2344 val* var16 /* : String */;
2345 val* var17 /* : String */;
2346 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__MType__c_name_cache]))(self) /* c_name_cache on <self:MNullableType>*/;
2347 var_res = var1;
2348 var2 = NULL;
2349 if (var_res == NULL) {
2350 var3 = 0; /* is null */
2351 } else {
2352 var3 = 1; /* arg is null and recv is not */
2353 }
2354 if (var3){
2355 var = var_res;
2356 goto RET_LABEL;
2357 } else {
2358 }
2359 var4 = NEW_array__Array(&type_array__Arraykernel__Object);
2360 var5 = 3;
2361 ((void (*)(val*, long))(var4->class->vft[COLOR_array__Array__with_capacity]))(var4, var5) /* with_capacity on <var4:Array[Object]>*/;
2362 CHECK_NEW_array__Array(var4);
2363 var_ = var4;
2364 if (varonce) {
2365 var6 = varonce;
2366 } else {
2367 var7 = "nullable_";
2368 var8 = 9;
2369 var9 = string__NativeString__to_s_with_length(var7, var8);
2370 var6 = var9;
2371 varonce = var6;
2372 }
2373 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var6) /* add on <var_:Array[Object]>*/;
2374 var10 = ((val* (*)(val*))(self->class->vft[COLOR_model__MNullableType__mtype]))(self) /* mtype on <self:MNullableType>*/;
2375 var11 = ((val* (*)(val*))(var10->class->vft[COLOR_abstract_compiler__MType__c_name]))(var10) /* c_name on <var10:MType>*/;
2376 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var11) /* add on <var_:Array[Object]>*/;
2377 if (varonce12) {
2378 var13 = varonce12;
2379 } else {
2380 var14 = "";
2381 var15 = 0;
2382 var16 = string__NativeString__to_s_with_length(var14, var15);
2383 var13 = var16;
2384 varonce12 = var13;
2385 }
2386 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var13) /* add on <var_:Array[Object]>*/;
2387 var17 = ((val* (*)(val*))(var_->class->vft[COLOR_string__Object__to_s]))(var_) /* to_s on <var_:Array[Object]>*/;
2388 var_res = var17;
2389 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__MType__c_name_cache_61d]))(self, var_res) /* c_name_cache= on <self:MNullableType>*/;
2390 var = var_res;
2391 goto RET_LABEL;
2392 RET_LABEL:;
2393 return var;
2394 }
2395 /* method abstract_compiler#MNullableType#c_name for (self: Object): String */
2396 val* VIRTUAL_abstract_compiler__MNullableType__c_name(val* self) {
2397 val* var /* : String */;
2398 val* var1 /* : String */;
2399 var1 = abstract_compiler__MNullableType__c_name(self);
2400 var = var1;
2401 RET_LABEL:;
2402 return var;
2403 }
2404 /* method abstract_compiler#MClass#c_name for (self: MClass): String */
2405 val* abstract_compiler__MClass__c_name(val* self) {
2406 val* var /* : String */;
2407 val* var1 /* : nullable String */;
2408 val* var_res /* var res: nullable String */;
2409 val* var2 /* : null */;
2410 short int var3 /* : Bool */;
2411 val* var4 /* : Array[Object] */;
2412 long var5 /* : Int */;
2413 val* var_ /* var : Array[Object] */;
2414 static val* varonce;
2415 val* var6 /* : String */;
2416 char* var7 /* : NativeString */;
2417 long var8 /* : Int */;
2418 val* var9 /* : String */;
2419 val* var10 /* : MModule */;
2420 val* var11 /* : String */;
2421 val* var12 /* : String */;
2422 static val* varonce13;
2423 val* var14 /* : String */;
2424 char* var15 /* : NativeString */;
2425 long var16 /* : Int */;
2426 val* var17 /* : String */;
2427 val* var18 /* : String */;
2428 val* var19 /* : String */;
2429 static val* varonce20;
2430 val* var21 /* : String */;
2431 char* var22 /* : NativeString */;
2432 long var23 /* : Int */;
2433 val* var24 /* : String */;
2434 val* var25 /* : String */;
2435 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__MClass__c_name_cache]))(self) /* c_name_cache on <self:MClass>*/;
2436 var_res = var1;
2437 var2 = NULL;
2438 if (var_res == NULL) {
2439 var3 = 0; /* is null */
2440 } else {
2441 var3 = 1; /* arg is null and recv is not */
2442 }
2443 if (var3){
2444 var = var_res;
2445 goto RET_LABEL;
2446 } else {
2447 }
2448 var4 = NEW_array__Array(&type_array__Arraykernel__Object);
2449 var5 = 5;
2450 ((void (*)(val*, long))(var4->class->vft[COLOR_array__Array__with_capacity]))(var4, var5) /* with_capacity on <var4:Array[Object]>*/;
2451 CHECK_NEW_array__Array(var4);
2452 var_ = var4;
2453 if (varonce) {
2454 var6 = varonce;
2455 } else {
2456 var7 = "";
2457 var8 = 0;
2458 var9 = string__NativeString__to_s_with_length(var7, var8);
2459 var6 = var9;
2460 varonce = var6;
2461 }
2462 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var6) /* add on <var_:Array[Object]>*/;
2463 var10 = ((val* (*)(val*))(self->class->vft[COLOR_model__MClass__intro_mmodule]))(self) /* intro_mmodule on <self:MClass>*/;
2464 var11 = ((val* (*)(val*))(var10->class->vft[COLOR_model_base__MModule__name]))(var10) /* name on <var10:MModule>*/;
2465 var12 = ((val* (*)(val*))(var11->class->vft[COLOR_string__AbstractString__to_cmangle]))(var11) /* to_cmangle on <var11:String>*/;
2466 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var12) /* add on <var_:Array[Object]>*/;
2467 if (varonce13) {
2468 var14 = varonce13;
2469 } else {
2470 var15 = "__";
2471 var16 = 2;
2472 var17 = string__NativeString__to_s_with_length(var15, var16);
2473 var14 = var17;
2474 varonce13 = var14;
2475 }
2476 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var14) /* add on <var_:Array[Object]>*/;
2477 var18 = ((val* (*)(val*))(self->class->vft[COLOR_model__MClass__name]))(self) /* name on <self:MClass>*/;
2478 var19 = ((val* (*)(val*))(var18->class->vft[COLOR_string__AbstractString__to_cmangle]))(var18) /* to_cmangle on <var18:String>*/;
2479 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var19) /* add on <var_:Array[Object]>*/;
2480 if (varonce20) {
2481 var21 = varonce20;
2482 } else {
2483 var22 = "";
2484 var23 = 0;
2485 var24 = string__NativeString__to_s_with_length(var22, var23);
2486 var21 = var24;
2487 varonce20 = var21;
2488 }
2489 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var21) /* add on <var_:Array[Object]>*/;
2490 var25 = ((val* (*)(val*))(var_->class->vft[COLOR_string__Object__to_s]))(var_) /* to_s on <var_:Array[Object]>*/;
2491 var_res = var25;
2492 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__MClass__c_name_cache_61d]))(self, var_res) /* c_name_cache= on <self:MClass>*/;
2493 var = var_res;
2494 goto RET_LABEL;
2495 RET_LABEL:;
2496 return var;
2497 }
2498 /* method abstract_compiler#MClass#c_name for (self: Object): String */
2499 val* VIRTUAL_abstract_compiler__MClass__c_name(val* self) {
2500 val* var /* : String */;
2501 val* var1 /* : String */;
2502 var1 = abstract_compiler__MClass__c_name(self);
2503 var = var1;
2504 RET_LABEL:;
2505 return var;
2506 }
2507 /* method abstract_compiler#MClass#c_name_cache for (self: MClass): nullable String */
2508 val* abstract_compiler__MClass__c_name_cache(val* self) {
2509 val* var /* : nullable String */;
2510 val* var1 /* : nullable String */;
2511 var1 = self->attrs[COLOR_abstract_compiler__MClass___64dc_name_cache].val; /* @c_name_cache on <self:MClass> */
2512 var = var1;
2513 RET_LABEL:;
2514 return var;
2515 }
2516 /* method abstract_compiler#MClass#c_name_cache for (self: Object): nullable String */
2517 val* VIRTUAL_abstract_compiler__MClass__c_name_cache(val* self) {
2518 val* var /* : nullable String */;
2519 val* var1 /* : nullable String */;
2520 var1 = abstract_compiler__MClass__c_name_cache(self);
2521 var = var1;
2522 RET_LABEL:;
2523 return var;
2524 }
2525 /* method abstract_compiler#MClass#c_name_cache= for (self: MClass, nullable String) */
2526 void abstract_compiler__MClass__c_name_cache_61d(val* self, val* p0) {
2527 self->attrs[COLOR_abstract_compiler__MClass___64dc_name_cache].val = p0; /* @c_name_cache on <self:MClass> */
2528 RET_LABEL:;
2529 }
2530 /* method abstract_compiler#MClass#c_name_cache= for (self: Object, nullable String) */
2531 void VIRTUAL_abstract_compiler__MClass__c_name_cache_61d(val* self, val* p0) {
2532 abstract_compiler__MClass__c_name_cache_61d(self, p0);
2533 RET_LABEL:;
2534 }
2535 /* method abstract_compiler#MProperty#c_name for (self: MProperty): String */
2536 val* abstract_compiler__MProperty__c_name(val* self) {
2537 val* var /* : String */;
2538 val* var1 /* : nullable String */;
2539 val* var_res /* var res: nullable String */;
2540 val* var2 /* : null */;
2541 short int var3 /* : Bool */;
2542 val* var4 /* : Array[Object] */;
2543 long var5 /* : Int */;
2544 val* var_ /* var : Array[Object] */;
2545 static val* varonce;
2546 val* var6 /* : String */;
2547 char* var7 /* : NativeString */;
2548 long var8 /* : Int */;
2549 val* var9 /* : String */;
2550 val* var10 /* : MPropDef */;
2551 val* var11 /* : String */;
2552 static val* varonce12;
2553 val* var13 /* : String */;
2554 char* var14 /* : NativeString */;
2555 long var15 /* : Int */;
2556 val* var16 /* : String */;
2557 val* var17 /* : String */;
2558 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__MProperty__c_name_cache]))(self) /* c_name_cache on <self:MProperty>*/;
2559 var_res = var1;
2560 var2 = NULL;
2561 if (var_res == NULL) {
2562 var3 = 0; /* is null */
2563 } else {
2564 var3 = 1; /* arg is null and recv is not */
2565 }
2566 if (var3){
2567 var = var_res;
2568 goto RET_LABEL;
2569 } else {
2570 }
2571 var4 = NEW_array__Array(&type_array__Arraykernel__Object);
2572 var5 = 3;
2573 ((void (*)(val*, long))(var4->class->vft[COLOR_array__Array__with_capacity]))(var4, var5) /* with_capacity on <var4:Array[Object]>*/;
2574 CHECK_NEW_array__Array(var4);
2575 var_ = var4;
2576 if (varonce) {
2577 var6 = varonce;
2578 } else {
2579 var7 = "";
2580 var8 = 0;
2581 var9 = string__NativeString__to_s_with_length(var7, var8);
2582 var6 = var9;
2583 varonce = var6;
2584 }
2585 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var6) /* add on <var_:Array[Object]>*/;
2586 var10 = ((val* (*)(val*))(self->class->vft[COLOR_model__MProperty__intro]))(self) /* intro on <self:MProperty>*/;
2587 var11 = ((val* (*)(val*))(var10->class->vft[COLOR_abstract_compiler__MPropDef__c_name]))(var10) /* c_name on <var10:MPropDef>*/;
2588 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var11) /* add on <var_:Array[Object]>*/;
2589 if (varonce12) {
2590 var13 = varonce12;
2591 } else {
2592 var14 = "";
2593 var15 = 0;
2594 var16 = string__NativeString__to_s_with_length(var14, var15);
2595 var13 = var16;
2596 varonce12 = var13;
2597 }
2598 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var13) /* add on <var_:Array[Object]>*/;
2599 var17 = ((val* (*)(val*))(var_->class->vft[COLOR_string__Object__to_s]))(var_) /* to_s on <var_:Array[Object]>*/;
2600 var_res = var17;
2601 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__MProperty__c_name_cache_61d]))(self, var_res) /* c_name_cache= on <self:MProperty>*/;
2602 var = var_res;
2603 goto RET_LABEL;
2604 RET_LABEL:;
2605 return var;
2606 }
2607 /* method abstract_compiler#MProperty#c_name for (self: Object): String */
2608 val* VIRTUAL_abstract_compiler__MProperty__c_name(val* self) {
2609 val* var /* : String */;
2610 val* var1 /* : String */;
2611 var1 = abstract_compiler__MProperty__c_name(self);
2612 var = var1;
2613 RET_LABEL:;
2614 return var;
2615 }
2616 /* method abstract_compiler#MProperty#c_name_cache for (self: MProperty): nullable String */
2617 val* abstract_compiler__MProperty__c_name_cache(val* self) {
2618 val* var /* : nullable String */;
2619 val* var1 /* : nullable String */;
2620 var1 = self->attrs[COLOR_abstract_compiler__MProperty___64dc_name_cache].val; /* @c_name_cache on <self:MProperty> */
2621 var = var1;
2622 RET_LABEL:;
2623 return var;
2624 }
2625 /* method abstract_compiler#MProperty#c_name_cache for (self: Object): nullable String */
2626 val* VIRTUAL_abstract_compiler__MProperty__c_name_cache(val* self) {
2627 val* var /* : nullable String */;
2628 val* var1 /* : nullable String */;
2629 var1 = abstract_compiler__MProperty__c_name_cache(self);
2630 var = var1;
2631 RET_LABEL:;
2632 return var;
2633 }
2634 /* method abstract_compiler#MProperty#c_name_cache= for (self: MProperty, nullable String) */
2635 void abstract_compiler__MProperty__c_name_cache_61d(val* self, val* p0) {
2636 self->attrs[COLOR_abstract_compiler__MProperty___64dc_name_cache].val = p0; /* @c_name_cache on <self:MProperty> */
2637 RET_LABEL:;
2638 }
2639 /* method abstract_compiler#MProperty#c_name_cache= for (self: Object, nullable String) */
2640 void VIRTUAL_abstract_compiler__MProperty__c_name_cache_61d(val* self, val* p0) {
2641 abstract_compiler__MProperty__c_name_cache_61d(self, p0);
2642 RET_LABEL:;
2643 }
2644 /* method abstract_compiler#MPropDef#c_name_cache for (self: MPropDef): nullable String */
2645 val* abstract_compiler__MPropDef__c_name_cache(val* self) {
2646 val* var /* : nullable String */;
2647 val* var1 /* : nullable String */;
2648 var1 = self->attrs[COLOR_abstract_compiler__MPropDef___64dc_name_cache].val; /* @c_name_cache on <self:MPropDef> */
2649 var = var1;
2650 RET_LABEL:;
2651 return var;
2652 }
2653 /* method abstract_compiler#MPropDef#c_name_cache for (self: Object): nullable String */
2654 val* VIRTUAL_abstract_compiler__MPropDef__c_name_cache(val* self) {
2655 val* var /* : nullable String */;
2656 val* var1 /* : nullable String */;
2657 var1 = abstract_compiler__MPropDef__c_name_cache(self);
2658 var = var1;
2659 RET_LABEL:;
2660 return var;
2661 }
2662 /* method abstract_compiler#MPropDef#c_name_cache= for (self: MPropDef, nullable String) */
2663 void abstract_compiler__MPropDef__c_name_cache_61d(val* self, val* p0) {
2664 self->attrs[COLOR_abstract_compiler__MPropDef___64dc_name_cache].val = p0; /* @c_name_cache on <self:MPropDef> */
2665 RET_LABEL:;
2666 }
2667 /* method abstract_compiler#MPropDef#c_name_cache= for (self: Object, nullable String) */
2668 void VIRTUAL_abstract_compiler__MPropDef__c_name_cache_61d(val* self, val* p0) {
2669 abstract_compiler__MPropDef__c_name_cache_61d(self, p0);
2670 RET_LABEL:;
2671 }
2672 /* method abstract_compiler#MPropDef#c_name for (self: MPropDef): String */
2673 val* abstract_compiler__MPropDef__c_name(val* self) {
2674 val* var /* : String */;
2675 val* var1 /* : nullable String */;
2676 val* var_res /* var res: nullable String */;
2677 val* var2 /* : null */;
2678 short int var3 /* : Bool */;
2679 val* var4 /* : Array[Object] */;
2680 long var5 /* : Int */;
2681 val* var_ /* var : Array[Object] */;
2682 static val* varonce;
2683 val* var6 /* : String */;
2684 char* var7 /* : NativeString */;
2685 long var8 /* : Int */;
2686 val* var9 /* : String */;
2687 val* var10 /* : MClassDef */;
2688 val* var11 /* : MModule */;
2689 val* var12 /* : String */;
2690 val* var13 /* : String */;
2691 static val* varonce14;
2692 val* var15 /* : String */;
2693 char* var16 /* : NativeString */;
2694 long var17 /* : Int */;
2695 val* var18 /* : String */;
2696 val* var19 /* : MClassDef */;
2697 val* var20 /* : MClass */;
2698 val* var21 /* : String */;
2699 val* var22 /* : String */;
2700 static val* varonce23;
2701 val* var24 /* : String */;
2702 char* var25 /* : NativeString */;
2703 long var26 /* : Int */;
2704 val* var27 /* : String */;
2705 val* var28 /* : MProperty */;
2706 val* var29 /* : String */;
2707 val* var30 /* : String */;
2708 static val* varonce31;
2709 val* var32 /* : String */;
2710 char* var33 /* : NativeString */;
2711 long var34 /* : Int */;
2712 val* var35 /* : String */;
2713 val* var36 /* : String */;
2714 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_compiler__MPropDef__c_name_cache]))(self) /* c_name_cache on <self:MPropDef>*/;
2715 var_res = var1;
2716 var2 = NULL;
2717 if (var_res == NULL) {
2718 var3 = 0; /* is null */
2719 } else {
2720 var3 = 1; /* arg is null and recv is not */
2721 }
2722 if (var3){
2723 var = var_res;
2724 goto RET_LABEL;
2725 } else {
2726 }
2727 var4 = NEW_array__Array(&type_array__Arraykernel__Object);
2728 var5 = 7;
2729 ((void (*)(val*, long))(var4->class->vft[COLOR_array__Array__with_capacity]))(var4, var5) /* with_capacity on <var4:Array[Object]>*/;
2730 CHECK_NEW_array__Array(var4);
2731 var_ = var4;
2732 if (varonce) {
2733 var6 = varonce;
2734 } else {
2735 var7 = "";
2736 var8 = 0;
2737 var9 = string__NativeString__to_s_with_length(var7, var8);
2738 var6 = var9;
2739 varonce = var6;
2740 }
2741 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var6) /* add on <var_:Array[Object]>*/;
2742 var10 = ((val* (*)(val*))(self->class->vft[COLOR_model__MPropDef__mclassdef]))(self) /* mclassdef on <self:MPropDef>*/;
2743 var11 = ((val* (*)(val*))(var10->class->vft[COLOR_model__MClassDef__mmodule]))(var10) /* mmodule on <var10:MClassDef>*/;
2744 var12 = ((val* (*)(val*))(var11->class->vft[COLOR_model_base__MModule__name]))(var11) /* name on <var11:MModule>*/;
2745 var13 = ((val* (*)(val*))(var12->class->vft[COLOR_string__AbstractString__to_cmangle]))(var12) /* to_cmangle on <var12:String>*/;
2746 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var13) /* add on <var_:Array[Object]>*/;
2747 if (varonce14) {
2748 var15 = varonce14;
2749 } else {
2750 var16 = "__";
2751 var17 = 2;
2752 var18 = string__NativeString__to_s_with_length(var16, var17);
2753 var15 = var18;
2754 varonce14 = var15;
2755 }
2756 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var15) /* add on <var_:Array[Object]>*/;
2757 var19 = ((val* (*)(val*))(self->class->vft[COLOR_model__MPropDef__mclassdef]))(self) /* mclassdef on <self:MPropDef>*/;
2758 var20 = ((val* (*)(val*))(var19->class->vft[COLOR_model__MClassDef__mclass]))(var19) /* mclass on <var19:MClassDef>*/;
2759 var21 = ((val* (*)(val*))(var20->class->vft[COLOR_model__MClass__name]))(var20) /* name on <var20:MClass>*/;
2760 var22 = ((val* (*)(val*))(var21->class->vft[COLOR_string__AbstractString__to_cmangle]))(var21) /* to_cmangle on <var21:String>*/;
2761 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var22) /* add on <var_:Array[Object]>*/;
2762 if (varonce23) {
2763 var24 = varonce23;
2764 } else {
2765 var25 = "__";
2766 var26 = 2;
2767 var27 = string__NativeString__to_s_with_length(var25, var26);
2768 var24 = var27;
2769 varonce23 = var24;
2770 }
2771 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var24) /* add on <var_:Array[Object]>*/;
2772 var28 = ((val* (*)(val*))(self->class->vft[COLOR_model__MPropDef__mproperty]))(self) /* mproperty on <self:MPropDef>*/;
2773 var29 = ((val* (*)(val*))(var28->class->vft[COLOR_model__MProperty__name]))(var28) /* name on <var28:MProperty>*/;
2774 var30 = ((val* (*)(val*))(var29->class->vft[COLOR_string__AbstractString__to_cmangle]))(var29) /* to_cmangle on <var29:String>*/;
2775 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var30) /* add on <var_:Array[Object]>*/;
2776 if (varonce31) {
2777 var32 = varonce31;
2778 } else {
2779 var33 = "";
2780 var34 = 0;
2781 var35 = string__NativeString__to_s_with_length(var33, var34);
2782 var32 = var35;
2783 varonce31 = var32;
2784 }
2785 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_, var32) /* add on <var_:Array[Object]>*/;
2786 var36 = ((val* (*)(val*))(var_->class->vft[COLOR_string__Object__to_s]))(var_) /* to_s on <var_:Array[Object]>*/;
2787 var_res = var36;
2788 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__MPropDef__c_name_cache_61d]))(self, var_res) /* c_name_cache= on <self:MPropDef>*/;
2789 var = var_res;
2790 goto RET_LABEL;
2791 RET_LABEL:;
2792 return var;
2793 }
2794 /* method abstract_compiler#MPropDef#c_name for (self: Object): String */
2795 val* VIRTUAL_abstract_compiler__MPropDef__c_name(val* self) {
2796 val* var /* : String */;
2797 val* var1 /* : String */;
2798 var1 = abstract_compiler__MPropDef__c_name(self);
2799 var = var1;
2800 RET_LABEL:;
2801 return var;
2802 }
2803 /* method abstract_compiler#MMethodDef#can_inline for (self: MMethodDef, AbstractCompilerVisitor): Bool */
2804 short int abstract_compiler__MMethodDef__can_inline(val* self, val* p0) {
2805 short int var /* : Bool */;
2806 short int var1 /* : Bool */;
2807 int cltype;
2808 int idtype;
2809 const struct type* type_struct;
2810 const char* var_class_name;
2811 val* var_v /* var v: AbstractCompilerVisitor */;
2812 val* var2 /* : AbstractCompiler */;
2813 val* var3 /* : ModelBuilder */;
2814 val* var_modelbuilder /* var modelbuilder: ModelBuilder */;
2815 val* var4 /* : HashMap[MPropDef, APropdef] */;
2816 short int var5 /* : Bool */;
2817 val* var6 /* : HashMap[MPropDef, APropdef] */;
2818 val* var7 /* : nullable Object */;
2819 val* var_npropdef /* var npropdef: APropdef */;
2820 short int var8 /* : Bool */;
2821 val* var9 /* : MProperty */;
2822 val* var10 /* : String */;
2823 static val* varonce;
2824 val* var11 /* : String */;
2825 char* var12 /* : NativeString */;
2826 long var13 /* : Int */;
2827 val* var14 /* : String */;
2828 short int var15 /* : Bool */;
2829 short int var16 /* : Bool */;
2830 /* Covariant cast for argument 0 (v) <p0:AbstractCompilerVisitor> isa VISITOR */
2831 /* <p0:AbstractCompilerVisitor> isa VISITOR */
2832 type_struct = self->type->resolution_table->types[COLOR_model__MPropDef_VTVISITOR];
2833 cltype = type_struct->color;
2834 idtype = type_struct->id;
2835 if(cltype >= p0->type->table_size) {
2836 var1 = 0;
2837 } else {
2838 var1 = p0->type->type_table[cltype] == idtype;
2839 }
2840 if (!var1) {
2841 var_class_name = p0 == NULL ? "null" : p0->type->name;
2842 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "VISITOR", var_class_name);
2843 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1243);
2844 exit(1);
2845 }
2846 var_v = p0;
2847 var2 = ((val* (*)(val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__compiler]))(var_v) /* compiler on <var_v:AbstractCompilerVisitor>*/;
2848 var3 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_compiler__AbstractCompiler__modelbuilder]))(var2) /* modelbuilder on <var2:AbstractCompiler>*/;
2849 var_modelbuilder = var3;
2850 var4 = ((val* (*)(val*))(var_modelbuilder->class->vft[COLOR_modelize_property__ModelBuilder__mpropdef2npropdef]))(var_modelbuilder) /* mpropdef2npropdef on <var_modelbuilder:ModelBuilder>*/;
2851 var5 = ((short int (*)(val*, val*))(var4->class->vft[COLOR_abstract_collection__MapRead__has_key]))(var4, self) /* has_key on <var4:HashMap[MPropDef, APropdef]>*/;
2852 if (var5){
2853 var6 = ((val* (*)(val*))(var_modelbuilder->class->vft[COLOR_modelize_property__ModelBuilder__mpropdef2npropdef]))(var_modelbuilder) /* mpropdef2npropdef on <var_modelbuilder:ModelBuilder>*/;
2854 var7 = ((val* (*)(val*, val*))(var6->class->vft[COLOR_abstract_collection__MapRead___91d_93d]))(var6, self) /* [] on <var6:HashMap[MPropDef, APropdef]>*/;
2855 var_npropdef = var7;
2856 var8 = ((short int (*)(val*))(var_npropdef->class->vft[COLOR_abstract_compiler__APropdef__can_inline]))(var_npropdef) /* can_inline on <var_npropdef:APropdef>*/;
2857 var = var8;
2858 goto RET_LABEL;
2859 } else {
2860 var9 = ((val* (*)(val*))(self->class->vft[COLOR_model__MPropDef__mproperty]))(self) /* mproperty on <self:MMethodDef>*/;
2861 var10 = ((val* (*)(val*))(var9->class->vft[COLOR_model__MProperty__name]))(var9) /* name on <var9:MProperty(MMethod)>*/;
2862 if (varonce) {
2863 var11 = varonce;
2864 } else {
2865 var12 = "init";
2866 var13 = 4;
2867 var14 = string__NativeString__to_s_with_length(var12, var13);
2868 var11 = var14;
2869 varonce = var11;
2870 }
2871 var15 = ((short int (*)(val*, val*))(var10->class->vft[COLOR_kernel__Object___61d_61d]))(var10, var11) /* == on <var10:String>*/;
2872 if (var15){
2873 var16 = 1;
2874 var = var16;
2875 goto RET_LABEL;
2876 } else {
2877 fprintf(stderr, "Runtime error: %s", "Aborted");
2878 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1254);
2879 exit(1);
2880 }
2881 }
2882 RET_LABEL:;
2883 return var;
2884 }
2885 /* method abstract_compiler#MMethodDef#can_inline for (self: Object, AbstractCompilerVisitor): Bool */
2886 short int VIRTUAL_abstract_compiler__MMethodDef__can_inline(val* self, val* p0) {
2887 short int var /* : Bool */;
2888 short int var1 /* : Bool */;
2889 var1 = abstract_compiler__MMethodDef__can_inline(self, p0);
2890 var = var1;
2891 RET_LABEL:;
2892 return var;
2893 }
2894 /* method abstract_compiler#MMethodDef#compile_inside_to_c for (self: MMethodDef, AbstractCompilerVisitor, Array[RuntimeVariable]): nullable RuntimeVariable */
2895 val* abstract_compiler__MMethodDef__compile_inside_to_c(val* self, val* p0, val* p1) {
2896 val* var /* : nullable RuntimeVariable */;
2897 short int var1 /* : Bool */;
2898 int cltype;
2899 int idtype;
2900 const struct type* type_struct;
2901 const char* var_class_name;
2902 val* var_v /* var v: AbstractCompilerVisitor */;
2903 val* var_arguments /* var arguments: Array[RuntimeVariable] */;
2904 val* var2 /* : AbstractCompiler */;
2905 val* var3 /* : ModelBuilder */;
2906 val* var_modelbuilder /* var modelbuilder: ModelBuilder */;
2907 val* var4 /* : HashMap[MPropDef, APropdef] */;
2908 short int var5 /* : Bool */;
2909 val* var6 /* : HashMap[MPropDef, APropdef] */;
2910 val* var7 /* : nullable Object */;
2911 val* var_npropdef /* var npropdef: APropdef */;
2912 val* var8 /* : nullable ANode */;
2913 val* var_oldnode /* var oldnode: nullable ANode */;
2914 val* var9 /* : MProperty */;
2915 val* var10 /* : String */;
2916 static val* varonce;
2917 val* var11 /* : String */;
2918 char* var12 /* : NativeString */;
2919 long var13 /* : Int */;
2920 val* var14 /* : String */;
2921 short int var15 /* : Bool */;
2922 val* var16 /* : HashMap[MClassDef, AClassdef] */;
2923 val* var17 /* : MClassDef */;
2924 val* var18 /* : nullable Object */;
2925 val* var_nclassdef /* var nclassdef: AClassdef */;
2926 val* var19 /* : nullable ANode */;
2927 val* var_oldnode20 /* var oldnode: nullable ANode */;
2928 val* var21 /* : null */;
2929 /* Covariant cast for argument 0 (v) <p0:AbstractCompilerVisitor> isa VISITOR */
2930 /* <p0:AbstractCompilerVisitor> isa VISITOR */
2931 type_struct = self->type->resolution_table->types[COLOR_model__MPropDef_VTVISITOR];
2932 cltype = type_struct->color;
2933 idtype = type_struct->id;
2934 if(cltype >= p0->type->table_size) {
2935 var1 = 0;
2936 } else {
2937 var1 = p0->type->type_table[cltype] == idtype;
2938 }
2939 if (!var1) {
2940 var_class_name = p0 == NULL ? "null" : p0->type->name;
2941 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "VISITOR", var_class_name);
2942 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1258);
2943 exit(1);
2944 }
2945 var_v = p0;
2946 var_arguments = p1;
2947 var2 = ((val* (*)(val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__compiler]))(var_v) /* compiler on <var_v:AbstractCompilerVisitor>*/;
2948 var3 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_compiler__AbstractCompiler__modelbuilder]))(var2) /* modelbuilder on <var2:AbstractCompiler>*/;
2949 var_modelbuilder = var3;
2950 var4 = ((val* (*)(val*))(var_modelbuilder->class->vft[COLOR_modelize_property__ModelBuilder__mpropdef2npropdef]))(var_modelbuilder) /* mpropdef2npropdef on <var_modelbuilder:ModelBuilder>*/;
2951 var5 = ((short int (*)(val*, val*))(var4->class->vft[COLOR_abstract_collection__MapRead__has_key]))(var4, self) /* has_key on <var4:HashMap[MPropDef, APropdef]>*/;
2952 if (var5){
2953 var6 = ((val* (*)(val*))(var_modelbuilder->class->vft[COLOR_modelize_property__ModelBuilder__mpropdef2npropdef]))(var_modelbuilder) /* mpropdef2npropdef on <var_modelbuilder:ModelBuilder>*/;
2954 var7 = ((val* (*)(val*, val*))(var6->class->vft[COLOR_abstract_collection__MapRead___91d_93d]))(var6, self) /* [] on <var6:HashMap[MPropDef, APropdef]>*/;
2955 var_npropdef = var7;
2956 var8 = ((val* (*)(val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__current_node]))(var_v) /* current_node on <var_v:AbstractCompilerVisitor>*/;
2957 var_oldnode = var8;
2958 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__current_node_61d]))(var_v, var_npropdef) /* current_node= on <var_v:AbstractCompilerVisitor>*/;
2959 ((void (*)(val*, val*, val*))(self->class->vft[COLOR_abstract_compiler__MMethodDef__compile_parameter_check]))(self, var_v, var_arguments) /* compile_parameter_check on <self:MMethodDef>*/;
2960 ((void (*)(val*, val*, val*, val*))(var_npropdef->class->vft[COLOR_abstract_compiler__APropdef__compile_to_c]))(var_npropdef, var_v, self, var_arguments) /* compile_to_c on <var_npropdef:APropdef>*/;
2961 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__current_node_61d]))(var_v, var_oldnode) /* current_node= on <var_v:AbstractCompilerVisitor>*/;
2962 } else {
2963 var9 = ((val* (*)(val*))(self->class->vft[COLOR_model__MPropDef__mproperty]))(self) /* mproperty on <self:MMethodDef>*/;
2964 var10 = ((val* (*)(val*))(var9->class->vft[COLOR_model__MProperty__name]))(var9) /* name on <var9:MProperty(MMethod)>*/;
2965 if (varonce) {
2966 var11 = varonce;
2967 } else {
2968 var12 = "init";
2969 var13 = 4;
2970 var14 = string__NativeString__to_s_with_length(var12, var13);
2971 var11 = var14;
2972 varonce = var11;
2973 }
2974 var15 = ((short int (*)(val*, val*))(var10->class->vft[COLOR_kernel__Object___61d_61d]))(var10, var11) /* == on <var10:String>*/;
2975 if (var15){
2976 var16 = ((val* (*)(val*))(var_modelbuilder->class->vft[COLOR_modelize_class__ModelBuilder__mclassdef2nclassdef]))(var_modelbuilder) /* mclassdef2nclassdef on <var_modelbuilder:ModelBuilder>*/;
2977 var17 = ((val* (*)(val*))(self->class->vft[COLOR_model__MPropDef__mclassdef]))(self) /* mclassdef on <self:MMethodDef>*/;
2978 var18 = ((val* (*)(val*, val*))(var16->class->vft[COLOR_abstract_collection__MapRead___91d_93d]))(var16, var17) /* [] on <var16:HashMap[MClassDef, AClassdef]>*/;
2979 var_nclassdef = var18;
2980 var19 = ((val* (*)(val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__current_node]))(var_v) /* current_node on <var_v:AbstractCompilerVisitor>*/;
2981 var_oldnode20 = var19;
2982 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__current_node_61d]))(var_v, var_nclassdef) /* current_node= on <var_v:AbstractCompilerVisitor>*/;
2983 ((void (*)(val*, val*, val*))(self->class->vft[COLOR_abstract_compiler__MMethodDef__compile_parameter_check]))(self, var_v, var_arguments) /* compile_parameter_check on <self:MMethodDef>*/;
2984 ((void (*)(val*, val*, val*, val*))(var_nclassdef->class->vft[COLOR_abstract_compiler__AClassdef__compile_to_c]))(var_nclassdef, var_v, self, var_arguments) /* compile_to_c on <var_nclassdef:AClassdef>*/;
2985 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__current_node_61d]))(var_v, var_oldnode20) /* current_node= on <var_v:AbstractCompilerVisitor>*/;
2986 } else {
2987 fprintf(stderr, "Runtime error: %s", "Aborted");
2988 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1277);
2989 exit(1);
2990 }
2991 }
2992 var21 = NULL;
2993 var = var21;
2994 goto RET_LABEL;
2995 RET_LABEL:;
2996 return var;
2997 }
2998 /* method abstract_compiler#MMethodDef#compile_inside_to_c for (self: Object, AbstractCompilerVisitor, Array[RuntimeVariable]): nullable RuntimeVariable */
2999 val* VIRTUAL_abstract_compiler__MMethodDef__compile_inside_to_c(val* self, val* p0, val* p1) {
3000 val* var /* : nullable RuntimeVariable */;
3001 val* var1 /* : nullable RuntimeVariable */;
3002 var1 = abstract_compiler__MMethodDef__compile_inside_to_c(self, p0, p1);
3003 var = var1;
3004 RET_LABEL:;
3005 return var;
3006 }
3007 /* method abstract_compiler#MMethodDef#compile_parameter_check for (self: MMethodDef, AbstractCompilerVisitor, Array[RuntimeVariable]) */
3008 void abstract_compiler__MMethodDef__compile_parameter_check(val* self, val* p0, val* p1) {
3009 short int var /* : Bool */;
3010 int cltype;
3011 int idtype;
3012 const struct type* type_struct;
3013 const char* var_class_name;
3014 val* var_v /* var v: AbstractCompilerVisitor */;
3015 val* var_arguments /* var arguments: Array[RuntimeVariable] */;
3016 val* var1 /* : AbstractCompiler */;
3017 val* var2 /* : ModelBuilder */;
3018 val* var3 /* : ToolContext */;
3019 val* var4 /* : OptionBool */;
3020 val* var5 /* : nullable Object */;
3021 short int var6 /* : Bool */;
3022 val* var7 /* : Range[Int] */;
3023 long var8 /* : Int */;
3024 val* var9 /* : nullable MSignature */;
3025 long var10 /* : Int */;
3026 val* var11 /* : Discrete */;
3027 val* var12 /* : Discrete */;
3028 val* var13 /* : Iterator[nullable Object] */;
3029 short int var14 /* : Bool */;
3030 val* var15 /* : nullable Object */;
3031 long var_i /* var i: Int */;
3032 long var16 /* : Int */;
3033 val* var17 /* : nullable MSignature */;
3034 long var18 /* : Int */;
3035 short int var19 /* : Bool */;
3036 short int var21 /* : Bool */;
3037 val* var22 /* : MProperty */;
3038 val* var23 /* : MPropDef */;
3039 val* var24 /* : nullable MSignature */;
3040 val* var25 /* : Array[MParameter] */;
3041 val* var26 /* : nullable Object */;
3042 val* var27 /* : MType */;
3043 val* var_origmtype /* var origmtype: MType */;
3044 short int var28 /* : Bool */;
3045 short int var29 /* : Bool */;
3046 val* var30 /* : nullable MSignature */;
3047 val* var31 /* : Array[MParameter] */;
3048 val* var32 /* : nullable Object */;
3049 val* var33 /* : MType */;
3050 val* var_mtype /* var mtype: MType */;
3051 static val* varonce;
3052 val* var34 /* : String */;
3053 char* var35 /* : NativeString */;
3054 long var36 /* : Int */;
3055 val* var37 /* : String */;
3056 static val* varonce38;
3057 val* var39 /* : String */;
3058 char* var40 /* : NativeString */;
3059 long var41 /* : Int */;
3060 val* var42 /* : String */;
3061 val* var43 /* : nullable MSignature */;
3062 val* var44 /* : Array[MParameter] */;
3063 val* var45 /* : nullable Object */;
3064 val* var46 /* : String */;
3065 static val* varonce47;
3066 val* var48 /* : String */;
3067 char* var49 /* : NativeString */;
3068 long var50 /* : Int */;
3069 val* var51 /* : String */;
3070 long var52 /* : Int */;
3071 long var53 /* : Int */;
3072 long var55 /* : Int */;
3073 val* var56 /* : nullable Object */;
3074 val* var57 /* : String */;
3075 static val* varonce58;
3076 val* var59 /* : String */;
3077 char* var60 /* : NativeString */;
3078 long var61 /* : Int */;
3079 val* var62 /* : String */;
3080 static val* varonce63;
3081 val* var64 /* : String */;
3082 char* var65 /* : NativeString */;
3083 long var66 /* : Int */;
3084 val* var67 /* : String */;
3085 val* var68 /* : Array[Object] */;
3086 long var69 /* : Int */;
3087 val* var70 /* : NativeArray[Object] */;
3088 val* var71 /* : Object */;
3089 val* var72 /* : String */;
3090 long var73 /* : Int */;
3091 long var74 /* : Int */;
3092 long var76 /* : Int */;
3093 val* var77 /* : nullable Object */;
3094 static val* varonce78;
3095 val* var79 /* : String */;
3096 char* var80 /* : NativeString */;
3097 long var81 /* : Int */;
3098 val* var82 /* : String */;
3099 /* Covariant cast for argument 0 (v) <p0:AbstractCompilerVisitor> isa VISITOR */
3100 /* <p0:AbstractCompilerVisitor> isa VISITOR */
3101 type_struct = self->type->resolution_table->types[COLOR_model__MPropDef_VTVISITOR];
3102 cltype = type_struct->color;
3103 idtype = type_struct->id;
3104 if(cltype >= p0->type->table_size) {
3105 var = 0;
3106 } else {
3107 var = p0->type->type_table[cltype] == idtype;
3108 }
3109 if (!var) {
3110 var_class_name = p0 == NULL ? "null" : p0->type->name;
3111 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "VISITOR", var_class_name);
3112 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1282);
3113 exit(1);
3114 }
3115 var_v = p0;
3116 var_arguments = p1;
3117 var1 = ((val* (*)(val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__compiler]))(var_v) /* compiler on <var_v:AbstractCompilerVisitor>*/;
3118 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_abstract_compiler__AbstractCompiler__modelbuilder]))(var1) /* modelbuilder on <var1:AbstractCompiler>*/;
3119 var3 = ((val* (*)(val*))(var2->class->vft[COLOR_modelbuilder__ModelBuilder__toolcontext]))(var2) /* toolcontext on <var2:ModelBuilder>*/;
3120 var4 = ((val* (*)(val*))(var3->class->vft[COLOR_abstract_compiler__ToolContext__opt_no_check_covariance]))(var3) /* opt_no_check_covariance on <var3:ToolContext>*/;
3121 var5 = ((val* (*)(val*))(var4->class->vft[COLOR_opts__Option__value]))(var4) /* value on <var4:OptionBool>*/;
3122 var6 = ((struct instance_kernel__Bool*)var5)->value; /* autounbox from nullable Object to Bool */;
3123 if (var6){
3124 goto RET_LABEL;
3125 } else {
3126 }
3127 var7 = NEW_range__Range(&type_range__Rangekernel__Int);
3128 var8 = 0;
3129 var9 = ((val* (*)(val*))(self->class->vft[COLOR_model__MMethodDef__msignature]))(self) /* msignature on <self:MMethodDef>*/;
3130 if (var9 == NULL) {
3131 fprintf(stderr, "Runtime error: %s", "Reciever is null");
3132 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1287);
3133 exit(1);
3134 } else {
3135 var10 = ((long (*)(val*))(var9->class->vft[COLOR_model__MSignature__arity]))(var9) /* arity on <var9:nullable MSignature>*/;
3136 }
3137 var11 = BOX_kernel__Int(var8); /* autobox from Int to Discrete */
3138 var12 = BOX_kernel__Int(var10); /* autobox from Int to Discrete */
3139 ((void (*)(val*, val*, val*))(var7->class->vft[COLOR_range__Range__without_last]))(var7, var11, var12) /* without_last on <var7:Range[Int]>*/;
3140 CHECK_NEW_range__Range(var7);
3141 var13 = ((val* (*)(val*))(var7->class->vft[COLOR_abstract_collection__Collection__iterator]))(var7) /* iterator on <var7:Range[Int]>*/;
3142 for(;;) {
3143 var14 = ((short int (*)(val*))(var13->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var13) /* is_ok on <var13:Iterator[nullable Object]>*/;
3144 if(!var14) break;
3145 var15 = ((val* (*)(val*))(var13->class->vft[COLOR_abstract_collection__Iterator__item]))(var13) /* item on <var13:Iterator[nullable Object]>*/;
3146 var16 = ((struct instance_kernel__Int*)var15)->value; /* autounbox from nullable Object to Int */;
3147 var_i = var16;
3148 var17 = ((val* (*)(val*))(self->class->vft[COLOR_model__MMethodDef__msignature]))(self) /* msignature on <self:MMethodDef>*/;
3149 if (var17 == NULL) {
3150 fprintf(stderr, "Runtime error: %s", "Reciever is null");
3151 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1289);
3152 exit(1);
3153 } else {
3154 var18 = ((long (*)(val*))(var17->class->vft[COLOR_model__MSignature__vararg_rank]))(var17) /* vararg_rank on <var17:nullable MSignature>*/;
3155 }
3156 { /* Inline kernel#Int#== (var18,var_i) */
3157 var21 = var18 == var_i;
3158 var19 = var21;
3159 goto RET_LABEL20;
3160 RET_LABEL20:(void)0;
3161 }
3162 if (var19){
3163 goto CONTINUE_label;
3164 } else {
3165 }
3166 var22 = ((val* (*)(val*))(self->class->vft[COLOR_model__MPropDef__mproperty]))(self) /* mproperty on <self:MMethodDef>*/;
3167 var23 = ((val* (*)(val*))(var22->class->vft[COLOR_model__MProperty__intro]))(var22) /* intro on <var22:MProperty(MMethod)>*/;
3168 var24 = ((val* (*)(val*))(var23->class->vft[COLOR_model__MMethodDef__msignature]))(var23) /* msignature on <var23:MPropDef(MMethodDef)>*/;
3169 if (var24 == NULL) {
3170 fprintf(stderr, "Runtime error: %s", "Reciever is null");
3171 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1292);
3172 exit(1);
3173 } else {
3174 var25 = ((val* (*)(val*))(var24->class->vft[COLOR_model__MSignature__mparameters]))(var24) /* mparameters on <var24:nullable MSignature>*/;
3175 }
3176 var26 = ((val* (*)(val*, long))(var25->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var25, var_i) /* [] on <var25:Array[MParameter]>*/;
3177 var27 = ((val* (*)(val*))(var26->class->vft[COLOR_model__MParameter__mtype]))(var26) /* mtype on <var26:nullable Object(MParameter)>*/;
3178 var_origmtype = var27;
3179 var28 = ((short int (*)(val*))(var_origmtype->class->vft[COLOR_model__MType__need_anchor]))(var_origmtype) /* need_anchor on <var_origmtype:MType>*/;
3180 var29 = !var28;
3181 if (var29){
3182 goto CONTINUE_label;
3183 } else {
3184 }
3185 var30 = ((val* (*)(val*))(self->class->vft[COLOR_model__MMethodDef__msignature]))(self) /* msignature on <self:MMethodDef>*/;
3186 if (var30 == NULL) {
3187 fprintf(stderr, "Runtime error: %s", "Reciever is null");
3188 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1296);
3189 exit(1);
3190 } else {
3191 var31 = ((val* (*)(val*))(var30->class->vft[COLOR_model__MSignature__mparameters]))(var30) /* mparameters on <var30:nullable MSignature>*/;
3192 }
3193 var32 = ((val* (*)(val*, long))(var31->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var31, var_i) /* [] on <var31:Array[MParameter]>*/;
3194 var33 = ((val* (*)(val*))(var32->class->vft[COLOR_model__MParameter__mtype]))(var32) /* mtype on <var32:nullable Object(MParameter)>*/;
3195 var_mtype = var33;
3196 if (varonce) {
3197 var34 = varonce;
3198 } else {
3199 var35 = "/* Covariant cast for argument ";
3200 var36 = 31;
3201 var37 = string__NativeString__to_s_with_length(var35, var36);
3202 var34 = var37;
3203 varonce = var34;
3204 }
3205 if (varonce38) {
3206 var39 = varonce38;
3207 } else {
3208 var40 = " (";
3209 var41 = 2;
3210 var42 = string__NativeString__to_s_with_length(var40, var41);
3211 var39 = var42;
3212 varonce38 = var39;
3213 }
3214 var43 = ((val* (*)(val*))(self->class->vft[COLOR_model__MMethodDef__msignature]))(self) /* msignature on <self:MMethodDef>*/;
3215 if (var43 == NULL) {
3216 fprintf(stderr, "Runtime error: %s", "Reciever is null");
3217 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1300);
3218 exit(1);
3219 } else {
3220 var44 = ((val* (*)(val*))(var43->class->vft[COLOR_model__MSignature__mparameters]))(var43) /* mparameters on <var43:nullable MSignature>*/;
3221 }
3222 var45 = ((val* (*)(val*, long))(var44->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var44, var_i) /* [] on <var44:Array[MParameter]>*/;
3223 var46 = ((val* (*)(val*))(var45->class->vft[COLOR_model__MParameter__name]))(var45) /* name on <var45:nullable Object(MParameter)>*/;
3224 if (varonce47) {
3225 var48 = varonce47;
3226 } else {
3227 var49 = ") ";
3228 var50 = 2;
3229 var51 = string__NativeString__to_s_with_length(var49, var50);
3230 var48 = var51;
3231 varonce47 = var48;
3232 }
3233 var52 = 1;
3234 { /* Inline kernel#Int#+ (var_i,var52) */
3235 var55 = var_i + var52;
3236 var53 = var55;
3237 goto RET_LABEL54;
3238 RET_LABEL54:(void)0;
3239 }
3240 var56 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var53) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
3241 var57 = ((val* (*)(val*))(var56->class->vft[COLOR_string__Object__inspect]))(var56) /* inspect on <var56:nullable Object(RuntimeVariable)>*/;
3242 if (varonce58) {
3243 var59 = varonce58;
3244 } else {
3245 var60 = " isa ";
3246 var61 = 5;
3247 var62 = string__NativeString__to_s_with_length(var60, var61);
3248 var59 = var62;
3249 varonce58 = var59;
3250 }
3251 if (varonce63) {
3252 var64 = varonce63;
3253 } else {
3254 var65 = " */";
3255 var66 = 3;
3256 var67 = string__NativeString__to_s_with_length(var65, var66);
3257 var64 = var67;
3258 varonce63 = var64;
3259 }
3260 var68 = NEW_array__Array(&type_array__Arraykernel__Object);
3261 { /* var68 = array_instance Array[Object] */
3262 var69 = 9;
3263 var70 = NEW_array__NativeArray(var69, &type_array__NativeArraykernel__Object);
3264 ((struct instance_array__NativeArray*)var70)->values[0] = (val*) var34;
3265 var71 = BOX_kernel__Int(var_i); /* autobox from Int to Object */
3266 ((struct instance_array__NativeArray*)var70)->values[1] = (val*) var71;
3267 ((struct instance_array__NativeArray*)var70)->values[2] = (val*) var39;
3268 ((struct instance_array__NativeArray*)var70)->values[3] = (val*) var46;
3269 ((struct instance_array__NativeArray*)var70)->values[4] = (val*) var48;
3270 ((struct instance_array__NativeArray*)var70)->values[5] = (val*) var57;
3271 ((struct instance_array__NativeArray*)var70)->values[6] = (val*) var59;
3272 ((struct instance_array__NativeArray*)var70)->values[7] = (val*) var_mtype;
3273 ((struct instance_array__NativeArray*)var70)->values[8] = (val*) var64;
3274 ((void (*)(val*, val*, long))(var68->class->vft[COLOR_array__Array__with_native]))(var68, var70, var69) /* with_native on <var68:Array[Object]>*/;
3275 CHECK_NEW_array__Array(var68);
3276 }
3277 var72 = ((val* (*)(val*))(var68->class->vft[COLOR_string__Object__to_s]))(var68) /* to_s on <var68:Array[Object]>*/;
3278 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var72) /* add on <var_v:AbstractCompilerVisitor>*/;
3279 var73 = 1;
3280 { /* Inline kernel#Int#+ (var_i,var73) */
3281 var76 = var_i + var73;
3282 var74 = var76;
3283 goto RET_LABEL75;
3284 RET_LABEL75:(void)0;
3285 }
3286 var77 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var74) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
3287 if (varonce78) {
3288 var79 = varonce78;
3289 } else {
3290 var80 = "covariance";
3291 var81 = 10;
3292 var82 = string__NativeString__to_s_with_length(var80, var81);
3293 var79 = var82;
3294 varonce78 = var79;
3295 }
3296 ((void (*)(val*, val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add_cast]))(var_v, var77, var_mtype, var79) /* add_cast on <var_v:AbstractCompilerVisitor>*/;
3297 CONTINUE_label: (void)0;
3298 ((void (*)(val*))(var13->class->vft[COLOR_abstract_collection__Iterator__next]))(var13) /* next on <var13:Iterator[nullable Object]>*/;
3299 }
3300 BREAK_label: (void)0;
3301 RET_LABEL:;
3302 }
3303 /* method abstract_compiler#MMethodDef#compile_parameter_check for (self: Object, AbstractCompilerVisitor, Array[RuntimeVariable]) */
3304 void VIRTUAL_abstract_compiler__MMethodDef__compile_parameter_check(val* self, val* p0, val* p1) {
3305 abstract_compiler__MMethodDef__compile_parameter_check(self, p0, p1);
3306 RET_LABEL:;
3307 }
3308 /* method abstract_compiler#APropdef#compile_to_c for (self: APropdef, AbstractCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */
3309 void abstract_compiler__APropdef__compile_to_c(val* self, val* p0, val* p1, val* p2) {
3310 val* var_v /* var v: AbstractCompilerVisitor */;
3311 val* var_mpropdef /* var mpropdef: MMethodDef */;
3312 val* var_arguments /* var arguments: Array[RuntimeVariable] */;
3313 static val* varonce;
3314 val* var /* : String */;
3315 char* var1 /* : NativeString */;
3316 long var2 /* : Int */;
3317 val* var3 /* : String */;
3318 val* var4 /* : String */;
3319 static val* varonce5;
3320 val* var6 /* : String */;
3321 char* var7 /* : NativeString */;
3322 long var8 /* : Int */;
3323 val* var9 /* : String */;
3324 static val* varonce10;
3325 val* var11 /* : String */;
3326 char* var12 /* : NativeString */;
3327 long var13 /* : Int */;
3328 val* var14 /* : String */;
3329 val* var15 /* : Location */;
3330 val* var16 /* : String */;
3331 static val* varonce17;
3332 val* var18 /* : String */;
3333 char* var19 /* : NativeString */;
3334 long var20 /* : Int */;
3335 val* var21 /* : String */;
3336 val* var22 /* : Array[Object] */;
3337 long var23 /* : Int */;
3338 val* var24 /* : NativeArray[Object] */;
3339 val* var25 /* : String */;
3340 static val* varonce26;
3341 val* var27 /* : String */;
3342 char* var28 /* : NativeString */;
3343 long var29 /* : Int */;
3344 val* var30 /* : String */;
3345 var_v = p0;
3346 var_mpropdef = p1;
3347 var_arguments = p2;
3348 if (varonce) {
3349 var = varonce;
3350 } else {
3351 var1 = "printf(\"NOT YET IMPLEMENTED ";
3352 var2 = 28;
3353 var3 = string__NativeString__to_s_with_length(var1, var2);
3354 var = var3;
3355 varonce = var;
3356 }
3357 var4 = ((val* (*)(val*))(self->class->vft[COLOR_string__Object__class_name]))(self) /* class_name on <self:APropdef>*/;
3358 if (varonce5) {
3359 var6 = varonce5;
3360 } else {
3361 var7 = " ";
3362 var8 = 1;
3363 var9 = string__NativeString__to_s_with_length(var7, var8);
3364 var6 = var9;
3365 varonce5 = var6;
3366 }
3367 if (varonce10) {
3368 var11 = varonce10;
3369 } else {
3370 var12 = " at ";
3371 var13 = 4;
3372 var14 = string__NativeString__to_s_with_length(var12, var13);
3373 var11 = var14;
3374 varonce10 = var11;
3375 }
3376 var15 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__ANode__location]))(self) /* location on <self:APropdef>*/;
3377 var16 = ((val* (*)(val*))(var15->class->vft[COLOR_string__Object__to_s]))(var15) /* to_s on <var15:Location>*/;
3378 if (varonce17) {
3379 var18 = varonce17;
3380 } else {
3381 var19 = "\\n\");";
3382 var20 = 5;
3383 var21 = string__NativeString__to_s_with_length(var19, var20);
3384 var18 = var21;
3385 varonce17 = var18;
3386 }
3387 var22 = NEW_array__Array(&type_array__Arraykernel__Object);
3388 { /* var22 = array_instance Array[Object] */
3389 var23 = 7;
3390 var24 = NEW_array__NativeArray(var23, &type_array__NativeArraykernel__Object);
3391 ((struct instance_array__NativeArray*)var24)->values[0] = (val*) var;
3392 ((struct instance_array__NativeArray*)var24)->values[1] = (val*) var4;
3393 ((struct instance_array__NativeArray*)var24)->values[2] = (val*) var6;
3394 ((struct instance_array__NativeArray*)var24)->values[3] = (val*) var_mpropdef;
3395 ((struct instance_array__NativeArray*)var24)->values[4] = (val*) var11;
3396 ((struct instance_array__NativeArray*)var24)->values[5] = (val*) var16;
3397 ((struct instance_array__NativeArray*)var24)->values[6] = (val*) var18;
3398 ((void (*)(val*, val*, long))(var22->class->vft[COLOR_array__Array__with_native]))(var22, var24, var23) /* with_native on <var22:Array[Object]>*/;
3399 CHECK_NEW_array__Array(var22);
3400 }
3401 var25 = ((val* (*)(val*))(var22->class->vft[COLOR_string__Object__to_s]))(var22) /* to_s on <var22:Array[Object]>*/;
3402 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var25) /* add on <var_v:AbstractCompilerVisitor>*/;
3403 if (varonce26) {
3404 var27 = varonce26;
3405 } else {
3406 var28 = "Not yet implemented";
3407 var29 = 19;
3408 var30 = string__NativeString__to_s_with_length(var28, var29);
3409 var27 = var30;
3410 varonce26 = var27;
3411 }
3412 ((void (*)(val*, val*))(self->class->vft[COLOR_parser_nodes__ANode__debug]))(self, var27) /* debug on <self:APropdef>*/;
3413 RET_LABEL:;
3414 }
3415 /* method abstract_compiler#APropdef#compile_to_c for (self: Object, AbstractCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */
3416 void VIRTUAL_abstract_compiler__APropdef__compile_to_c(val* self, val* p0, val* p1, val* p2) {
3417 abstract_compiler__APropdef__compile_to_c(self, p0, p1, p2);
3418 RET_LABEL:;
3419 }
3420 /* method abstract_compiler#APropdef#can_inline for (self: APropdef): Bool */
3421 short int abstract_compiler__APropdef__can_inline(val* self) {
3422 short int var /* : Bool */;
3423 short int var1 /* : Bool */;
3424 var1 = 1;
3425 var = var1;
3426 goto RET_LABEL;
3427 RET_LABEL:;
3428 return var;
3429 }
3430 /* method abstract_compiler#APropdef#can_inline for (self: Object): Bool */
3431 short int VIRTUAL_abstract_compiler__APropdef__can_inline(val* self) {
3432 short int var /* : Bool */;
3433 short int var1 /* : Bool */;
3434 var1 = abstract_compiler__APropdef__can_inline(self);
3435 var = var1;
3436 RET_LABEL:;
3437 return var;
3438 }
3439 /* method abstract_compiler#AConcreteMethPropdef#compile_to_c for (self: AConcreteMethPropdef, AbstractCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */
3440 void abstract_compiler__AConcreteMethPropdef__compile_to_c(val* self, val* p0, val* p1, val* p2) {
3441 val* var_v /* var v: AbstractCompilerVisitor */;
3442 val* var_mpropdef /* var mpropdef: MMethodDef */;
3443 val* var_arguments /* var arguments: Array[RuntimeVariable] */;
3444 val* var /* : Range[Int] */;
3445 long var1 /* : Int */;
3446 val* var2 /* : nullable MSignature */;
3447 long var3 /* : Int */;
3448 val* var4 /* : Discrete */;
3449 val* var5 /* : Discrete */;
3450 val* var6 /* : Iterator[nullable Object] */;
3451 short int var7 /* : Bool */;
3452 val* var8 /* : nullable Object */;
3453 long var_i /* var i: Int */;
3454 long var9 /* : Int */;
3455 val* var10 /* : nullable ASignature */;
3456 val* var11 /* : ANodes[AParam] */;
3457 val* var12 /* : nullable Object */;
3458 val* var13 /* : nullable Variable */;
3459 val* var_variable /* var variable: Variable */;
3460 val* var14 /* : RuntimeVariable */;
3461 long var15 /* : Int */;
3462 long var16 /* : Int */;
3463 long var18 /* : Int */;
3464 val* var19 /* : nullable Object */;
3465 val* var20 /* : nullable Array[MMethod] */;
3466 val* var_auto_super_inits /* var auto_super_inits: nullable Array[MMethod] */;
3467 val* var21 /* : null */;
3468 short int var22 /* : Bool */;
3469 val* var23 /* : Array[RuntimeVariable] */;
3470 long var24 /* : Int */;
3471 val* var_ /* var : Array[RuntimeVariable] */;
3472 val* var25 /* : nullable Object */;
3473 val* var_selfarg /* var selfarg: Array[RuntimeVariable] */;
3474 val* var26 /* : Iterator[nullable Object] */;
3475 short int var27 /* : Bool */;
3476 val* var28 /* : nullable Object */;
3477 val* var_auto_super_init /* var auto_super_init: MMethod */;
3478 val* var29 /* : MPropDef */;
3479 val* var30 /* : nullable MSignature */;
3480 long var31 /* : Int */;
3481 long var32 /* : Int */;
3482 short int var33 /* : Bool */;
3483 short int var35 /* : Bool */;
3484 val* var36 /* : nullable RuntimeVariable */;
3485 val* var37 /* : nullable RuntimeVariable */;
3486 val* var39 /* : nullable AExpr */;
3487 var_v = p0;
3488 var_mpropdef = p1;
3489 var_arguments = p2;
3490 var = NEW_range__Range(&type_range__Rangekernel__Int);
3491 var1 = 0;
3492 var2 = ((val* (*)(val*))(var_mpropdef->class->vft[COLOR_model__MMethodDef__msignature]))(var_mpropdef) /* msignature on <var_mpropdef:MMethodDef>*/;
3493 if (var2 == NULL) {
3494 fprintf(stderr, "Runtime error: %s", "Reciever is null");
3495 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1321);
3496 exit(1);
3497 } else {
3498 var3 = ((long (*)(val*))(var2->class->vft[COLOR_model__MSignature__arity]))(var2) /* arity on <var2:nullable MSignature>*/;
3499 }
3500 var4 = BOX_kernel__Int(var1); /* autobox from Int to Discrete */
3501 var5 = BOX_kernel__Int(var3); /* autobox from Int to Discrete */
3502 ((void (*)(val*, val*, val*))(var->class->vft[COLOR_range__Range__without_last]))(var, var4, var5) /* without_last on <var:Range[Int]>*/;
3503 CHECK_NEW_range__Range(var);
3504 var6 = ((val* (*)(val*))(var->class->vft[COLOR_abstract_collection__Collection__iterator]))(var) /* iterator on <var:Range[Int]>*/;
3505 for(;;) {
3506 var7 = ((short int (*)(val*))(var6->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var6) /* is_ok on <var6:Iterator[nullable Object]>*/;
3507 if(!var7) break;
3508 var8 = ((val* (*)(val*))(var6->class->vft[COLOR_abstract_collection__Iterator__item]))(var6) /* item on <var6:Iterator[nullable Object]>*/;
3509 var9 = ((struct instance_kernel__Int*)var8)->value; /* autounbox from nullable Object to Int */;
3510 var_i = var9;
3511 var10 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__AMethPropdef__n_signature]))(self) /* n_signature on <self:AConcreteMethPropdef>*/;
3512 if (var10 == NULL) {
3513 fprintf(stderr, "Runtime error: %s", "Reciever is null");
3514 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1322);
3515 exit(1);
3516 } else {
3517 var11 = ((val* (*)(val*))(var10->class->vft[COLOR_parser_nodes__ASignature__n_params]))(var10) /* n_params on <var10:nullable ASignature>*/;
3518 }
3519 var12 = ((val* (*)(val*, long))(var11->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var11, var_i) /* [] on <var11:ANodes[AParam]>*/;
3520 var13 = ((val* (*)(val*))(var12->class->vft[COLOR_scope__AParam__variable]))(var12) /* variable on <var12:nullable Object(AParam)>*/;
3521 if (var13 == NULL) {
3522 fprintf(stderr, "Runtime error: %s", "Cast failed");
3523 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1322);
3524 exit(1);
3525 }
3526 var_variable = var13;
3527 var14 = ((val* (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__variable]))(var_v, var_variable) /* variable on <var_v:AbstractCompilerVisitor>*/;
3528 var15 = 1;
3529 { /* Inline kernel#Int#+ (var_i,var15) */
3530 var18 = var_i + var15;
3531 var16 = var18;
3532 goto RET_LABEL17;
3533 RET_LABEL17:(void)0;
3534 }
3535 var19 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var16) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
3536 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__assign]))(var_v, var14, var19) /* assign on <var_v:AbstractCompilerVisitor>*/;
3537 CONTINUE_label: (void)0;
3538 ((void (*)(val*))(var6->class->vft[COLOR_abstract_collection__Iterator__next]))(var6) /* next on <var6:Iterator[nullable Object]>*/;
3539 }
3540 BREAK_label: (void)0;
3541 var20 = ((val* (*)(val*))(self->class->vft[COLOR_auto_super_init__AConcreteMethPropdef__auto_super_inits]))(self) /* auto_super_inits on <self:AConcreteMethPropdef>*/;
3542 var_auto_super_inits = var20;
3543 var21 = NULL;
3544 if (var_auto_super_inits == NULL) {
3545 var22 = 0; /* is null */
3546 } else {
3547 var22 = 1; /* arg is null and recv is not */
3548 }
3549 if (var22){
3550 var23 = NEW_array__Array(&type_array__Arrayabstract_compiler__RuntimeVariable);
3551 var24 = 1;
3552 ((void (*)(val*, long))(var23->class->vft[COLOR_array__Array__with_capacity]))(var23, var24) /* with_capacity on <var23:Array[RuntimeVariable]>*/;
3553 CHECK_NEW_array__Array(var23);
3554 var_ = var23;
3555 var25 = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__first]))(var_arguments) /* first on <var_arguments:Array[RuntimeVariable]>*/;
3556 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__Sequence__push]))(var_, var25) /* push on <var_:Array[RuntimeVariable]>*/;
3557 var_selfarg = var_;
3558 var26 = ((val* (*)(val*))(var_auto_super_inits->class->vft[COLOR_abstract_collection__Collection__iterator]))(var_auto_super_inits) /* iterator on <var_auto_super_inits:nullable Array[MMethod](Array[MMethod])>*/;
3559 for(;;) {
3560 var27 = ((short int (*)(val*))(var26->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var26) /* is_ok on <var26:Iterator[nullable Object]>*/;
3561 if(!var27) break;
3562 var28 = ((val* (*)(val*))(var26->class->vft[COLOR_abstract_collection__Iterator__item]))(var26) /* item on <var26:Iterator[nullable Object]>*/;
3563 var_auto_super_init = var28;
3564 var29 = ((val* (*)(val*))(var_auto_super_init->class->vft[COLOR_model__MProperty__intro]))(var_auto_super_init) /* intro on <var_auto_super_init:MMethod>*/;
3565 var30 = ((val* (*)(val*))(var29->class->vft[COLOR_model__MMethodDef__msignature]))(var29) /* msignature on <var29:MPropDef(MMethodDef)>*/;
3566 if (var30 == NULL) {
3567 fprintf(stderr, "Runtime error: %s", "Reciever is null");
3568 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1330);
3569 exit(1);
3570 } else {
3571 var31 = ((long (*)(val*))(var30->class->vft[COLOR_model__MSignature__arity]))(var30) /* arity on <var30:nullable MSignature>*/;
3572 }
3573 var32 = 0;
3574 { /* Inline kernel#Int#== (var31,var32) */
3575 var35 = var31 == var32;
3576 var33 = var35;
3577 goto RET_LABEL34;
3578 RET_LABEL34:(void)0;
3579 }
3580 if (var33){
3581 var36 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__send]))(var_v, var_auto_super_init, var_selfarg) /* send on <var_v:AbstractCompilerVisitor>*/;
3582 var36;
3583 } else {
3584 var37 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__send]))(var_v, var_auto_super_init, var_arguments) /* send on <var_v:AbstractCompilerVisitor>*/;
3585 var37;
3586 }
3587 CONTINUE_label38: (void)0;
3588 ((void (*)(val*))(var26->class->vft[COLOR_abstract_collection__Iterator__next]))(var26) /* next on <var26:Iterator[nullable Object]>*/;
3589 }
3590 BREAK_label38: (void)0;
3591 } else {
3592 }
3593 var39 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__AConcreteMethPropdef__n_block]))(self) /* n_block on <self:AConcreteMethPropdef>*/;
3594 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__stmt]))(var_v, var39) /* stmt on <var_v:AbstractCompilerVisitor>*/;
3595 RET_LABEL:;
3596 }
3597 /* method abstract_compiler#AConcreteMethPropdef#compile_to_c for (self: Object, AbstractCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */
3598 void VIRTUAL_abstract_compiler__AConcreteMethPropdef__compile_to_c(val* self, val* p0, val* p1, val* p2) {
3599 abstract_compiler__AConcreteMethPropdef__compile_to_c(self, p0, p1, p2);
3600 RET_LABEL:;
3601 }
3602 /* method abstract_compiler#AConcreteMethPropdef#can_inline for (self: AConcreteMethPropdef): Bool */
3603 short int abstract_compiler__AConcreteMethPropdef__can_inline(val* self) {
3604 short int var /* : Bool */;
3605 val* var1 /* : nullable Array[MMethod] */;
3606 val* var2 /* : null */;
3607 short int var3 /* : Bool */;
3608 short int var4 /* : Bool */;
3609 val* var5 /* : nullable AExpr */;
3610 val* var_nblock /* var nblock: nullable AExpr */;
3611 val* var6 /* : null */;
3612 short int var7 /* : Bool */;
3613 short int var8 /* : Bool */;
3614 short int var9 /* : Bool */;
3615 short int var10 /* : Bool */;
3616 val* var11 /* : nullable MPropDef */;
3617 val* var12 /* : MProperty */;
3618 val* var13 /* : String */;
3619 static val* varonce;
3620 val* var14 /* : String */;
3621 char* var15 /* : NativeString */;
3622 long var16 /* : Int */;
3623 val* var17 /* : String */;
3624 short int var18 /* : Bool */;
3625 short int var_ /* var : Bool */;
3626 val* var19 /* : nullable MPropDef */;
3627 val* var20 /* : MProperty */;
3628 val* var21 /* : String */;
3629 static val* varonce22;
3630 val* var23 /* : String */;
3631 char* var24 /* : NativeString */;
3632 long var25 /* : Int */;
3633 val* var26 /* : String */;
3634 short int var27 /* : Bool */;
3635 short int var_28 /* var : Bool */;
3636 val* var29 /* : nullable MPropDef */;
3637 val* var30 /* : MClassDef */;
3638 val* var31 /* : MClass */;
3639 val* var32 /* : String */;
3640 static val* varonce33;
3641 val* var34 /* : String */;
3642 char* var35 /* : NativeString */;
3643 long var36 /* : Int */;
3644 val* var37 /* : String */;
3645 short int var38 /* : Bool */;
3646 short int var39 /* : Bool */;
3647 short int var40 /* : Bool */;
3648 short int var41 /* : Bool */;
3649 int cltype;
3650 int idtype;
3651 short int var_42 /* var : Bool */;
3652 val* var43 /* : ANodes[AExpr] */;
3653 long var44 /* : Int */;
3654 long var45 /* : Int */;
3655 short int var46 /* : Bool */;
3656 short int var48 /* : Bool */;
3657 short int var49 /* : Bool */;
3658 short int var50 /* : Bool */;
3659 var1 = ((val* (*)(val*))(self->class->vft[COLOR_auto_super_init__AConcreteMethPropdef__auto_super_inits]))(self) /* auto_super_inits on <self:AConcreteMethPropdef>*/;
3660 var2 = NULL;
3661 if (var1 == NULL) {
3662 var3 = 0; /* is null */
3663 } else {
3664 var3 = 1; /* arg is null and recv is not */
3665 }
3666 if (var3){
3667 var4 = 0;
3668 var = var4;
3669 goto RET_LABEL;
3670 } else {
3671 }
3672 var5 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__AConcreteMethPropdef__n_block]))(self) /* n_block on <self:AConcreteMethPropdef>*/;
3673 var_nblock = var5;
3674 var6 = NULL;
3675 if (var_nblock == NULL) {
3676 var7 = 1; /* is null */
3677 } else {
3678 var7 = 0; /* arg is null but recv is not */
3679 }
3680 if (var7){
3681 var8 = 1;
3682 var = var8;
3683 goto RET_LABEL;
3684 } else {
3685 }
3686 var11 = ((val* (*)(val*))(self->class->vft[COLOR_modelize_property__APropdef__mpropdef]))(self) /* mpropdef on <self:AConcreteMethPropdef>*/;
3687 if (var11 == NULL) {
3688 fprintf(stderr, "Runtime error: %s", "Reciever is null");
3689 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1345);
3690 exit(1);
3691 } else {
3692 var12 = ((val* (*)(val*))(var11->class->vft[COLOR_model__MPropDef__mproperty]))(var11) /* mproperty on <var11:nullable MPropDef(nullable MMethodDef)>*/;
3693 }
3694 var13 = ((val* (*)(val*))(var12->class->vft[COLOR_model__MProperty__name]))(var12) /* name on <var12:MProperty(MMethod)>*/;
3695 if (varonce) {
3696 var14 = varonce;
3697 } else {
3698 var15 = "==";
3699 var16 = 2;
3700 var17 = string__NativeString__to_s_with_length(var15, var16);
3701 var14 = var17;
3702 varonce = var14;
3703 }
3704 var18 = ((short int (*)(val*, val*))(var13->class->vft[COLOR_kernel__Object___61d_61d]))(var13, var14) /* == on <var13:String>*/;
3705 var_ = var18;
3706 if (var18){
3707 var10 = var_;
3708 } else {
3709 var19 = ((val* (*)(val*))(self->class->vft[COLOR_modelize_property__APropdef__mpropdef]))(self) /* mpropdef on <self:AConcreteMethPropdef>*/;
3710 if (var19 == NULL) {
3711 fprintf(stderr, "Runtime error: %s", "Reciever is null");
3712 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1345);
3713 exit(1);
3714 } else {
3715 var20 = ((val* (*)(val*))(var19->class->vft[COLOR_model__MPropDef__mproperty]))(var19) /* mproperty on <var19:nullable MPropDef(nullable MMethodDef)>*/;
3716 }
3717 var21 = ((val* (*)(val*))(var20->class->vft[COLOR_model__MProperty__name]))(var20) /* name on <var20:MProperty(MMethod)>*/;
3718 if (varonce22) {
3719 var23 = varonce22;
3720 } else {
3721 var24 = "!=";
3722 var25 = 2;
3723 var26 = string__NativeString__to_s_with_length(var24, var25);
3724 var23 = var26;
3725 varonce22 = var23;
3726 }
3727 var27 = ((short int (*)(val*, val*))(var21->class->vft[COLOR_kernel__Object___61d_61d]))(var21, var23) /* == on <var21:String>*/;
3728 var10 = var27;
3729 }
3730 var_28 = var10;
3731 if (var10){
3732 var29 = ((val* (*)(val*))(self->class->vft[COLOR_modelize_property__APropdef__mpropdef]))(self) /* mpropdef on <self:AConcreteMethPropdef>*/;
3733 if (var29 == NULL) {
3734 fprintf(stderr, "Runtime error: %s", "Reciever is null");
3735 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1345);
3736 exit(1);
3737 } else {
3738 var30 = ((val* (*)(val*))(var29->class->vft[COLOR_model__MPropDef__mclassdef]))(var29) /* mclassdef on <var29:nullable MPropDef(nullable MMethodDef)>*/;
3739 }
3740 var31 = ((val* (*)(val*))(var30->class->vft[COLOR_model__MClassDef__mclass]))(var30) /* mclass on <var30:MClassDef>*/;
3741 var32 = ((val* (*)(val*))(var31->class->vft[COLOR_model__MClass__name]))(var31) /* name on <var31:MClass>*/;
3742 if (varonce33) {
3743 var34 = varonce33;
3744 } else {
3745 var35 = "Object";
3746 var36 = 6;
3747 var37 = string__NativeString__to_s_with_length(var35, var36);
3748 var34 = var37;
3749 varonce33 = var34;
3750 }
3751 var38 = ((short int (*)(val*, val*))(var32->class->vft[COLOR_kernel__Object___61d_61d]))(var32, var34) /* == on <var32:String>*/;
3752 var9 = var38;
3753 } else {
3754 var9 = var_28;
3755 }
3756 if (var9){
3757 var39 = 1;
3758 var = var39;
3759 goto RET_LABEL;
3760 } else {
3761 }
3762 /* <var_nblock:nullable AExpr(AExpr)> isa ABlockExpr */
3763 cltype = type_parser_nodes__ABlockExpr.color;
3764 idtype = type_parser_nodes__ABlockExpr.id;
3765 if(cltype >= var_nblock->type->table_size) {
3766 var41 = 0;
3767 } else {
3768 var41 = var_nblock->type->type_table[cltype] == idtype;
3769 }
3770 var_42 = var41;
3771 if (var41){
3772 var43 = ((val* (*)(val*))(var_nblock->class->vft[COLOR_parser_nodes__ABlockExpr__n_expr]))(var_nblock) /* n_expr on <var_nblock:nullable AExpr(ABlockExpr)>*/;
3773 var44 = ((long (*)(val*))(var43->class->vft[COLOR_abstract_collection__Collection__length]))(var43) /* length on <var43:ANodes[AExpr]>*/;
3774 var45 = 0;
3775 { /* Inline kernel#Int#== (var44,var45) */
3776 var48 = var44 == var45;
3777 var46 = var48;
3778 goto RET_LABEL47;
3779 RET_LABEL47:(void)0;
3780 }
3781 var40 = var46;
3782 } else {
3783 var40 = var_42;
3784 }
3785 if (var40){
3786 var49 = 1;
3787 var = var49;
3788 goto RET_LABEL;
3789 } else {
3790 }
3791 var50 = 0;
3792 var = var50;
3793 goto RET_LABEL;
3794 RET_LABEL:;
3795 return var;
3796 }
3797 /* method abstract_compiler#AConcreteMethPropdef#can_inline for (self: Object): Bool */
3798 short int VIRTUAL_abstract_compiler__AConcreteMethPropdef__can_inline(val* self) {
3799 short int var /* : Bool */;
3800 short int var1 /* : Bool */;
3801 var1 = abstract_compiler__AConcreteMethPropdef__can_inline(self);
3802 var = var1;
3803 RET_LABEL:;
3804 return var;
3805 }
3806 /* method abstract_compiler#AInternMethPropdef#compile_to_c for (self: AInternMethPropdef, AbstractCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */
3807 void abstract_compiler__AInternMethPropdef__compile_to_c(val* self, val* p0, val* p1, val* p2) {
3808 val* var_v /* var v: AbstractCompilerVisitor */;
3809 val* var_mpropdef /* var mpropdef: MMethodDef */;
3810 val* var_arguments /* var arguments: Array[RuntimeVariable] */;
3811 val* var /* : MProperty */;
3812 val* var1 /* : String */;
3813 val* var_pname /* var pname: String */;
3814 val* var2 /* : MClassDef */;
3815 val* var3 /* : MClass */;
3816 val* var4 /* : String */;
3817 val* var_cname /* var cname: String */;
3818 val* var5 /* : nullable MSignature */;
3819 val* var6 /* : nullable MType */;
3820 val* var_ret /* var ret: nullable MType */;
3821 val* var7 /* : null */;
3822 short int var8 /* : Bool */;
3823 val* var9 /* : nullable Object */;
3824 val* var10 /* : MType */;
3825 short int var11 /* : Bool */;
3826 static val* varonce;
3827 val* var12 /* : String */;
3828 char* var13 /* : NativeString */;
3829 long var14 /* : Int */;
3830 val* var15 /* : String */;
3831 short int var16 /* : Bool */;
3832 short int var_ /* var : Bool */;
3833 static val* varonce17;
3834 val* var18 /* : String */;
3835 char* var19 /* : NativeString */;
3836 long var20 /* : Int */;
3837 val* var21 /* : String */;
3838 short int var22 /* : Bool */;
3839 static val* varonce23;
3840 val* var24 /* : String */;
3841 char* var25 /* : NativeString */;
3842 long var26 /* : Int */;
3843 val* var27 /* : String */;
3844 short int var28 /* : Bool */;
3845 static val* varonce29;
3846 val* var30 /* : String */;
3847 char* var31 /* : NativeString */;
3848 long var32 /* : Int */;
3849 val* var33 /* : String */;
3850 short int var34 /* : Bool */;
3851 static val* varonce35;
3852 val* var36 /* : String */;
3853 char* var37 /* : NativeString */;
3854 long var38 /* : Int */;
3855 val* var39 /* : String */;
3856 val* var40 /* : nullable Object */;
3857 static val* varonce41;
3858 val* var42 /* : String */;
3859 char* var43 /* : NativeString */;
3860 long var44 /* : Int */;
3861 val* var45 /* : String */;
3862 val* var46 /* : Array[Object] */;
3863 long var47 /* : Int */;
3864 val* var48 /* : NativeArray[Object] */;
3865 val* var49 /* : String */;
3866 static val* varonce50;
3867 val* var51 /* : String */;
3868 char* var52 /* : NativeString */;
3869 long var53 /* : Int */;
3870 val* var54 /* : String */;
3871 short int var55 /* : Bool */;
3872 val* var56 /* : nullable Object */;
3873 static val* varonce57;
3874 val* var58 /* : String */;
3875 char* var59 /* : NativeString */;
3876 long var60 /* : Int */;
3877 val* var61 /* : String */;
3878 short int var62 /* : Bool */;
3879 long var63 /* : Int */;
3880 val* var64 /* : nullable Object */;
3881 static val* varonce65;
3882 val* var66 /* : String */;
3883 char* var67 /* : NativeString */;
3884 long var68 /* : Int */;
3885 val* var69 /* : String */;
3886 long var70 /* : Int */;
3887 val* var71 /* : nullable Object */;
3888 val* var72 /* : Array[Object] */;
3889 long var73 /* : Int */;
3890 val* var74 /* : NativeArray[Object] */;
3891 val* var75 /* : String */;
3892 val* var76 /* : RuntimeVariable */;
3893 static val* varonce77;
3894 val* var78 /* : String */;
3895 char* var79 /* : NativeString */;
3896 long var80 /* : Int */;
3897 val* var81 /* : String */;
3898 short int var82 /* : Bool */;
3899 long var83 /* : Int */;
3900 val* var84 /* : nullable Object */;
3901 static val* varonce85;
3902 val* var86 /* : String */;
3903 char* var87 /* : NativeString */;
3904 long var88 /* : Int */;
3905 val* var89 /* : String */;
3906 long var90 /* : Int */;
3907 val* var91 /* : nullable Object */;
3908 val* var92 /* : Array[Object] */;
3909 long var93 /* : Int */;
3910 val* var94 /* : NativeArray[Object] */;
3911 val* var95 /* : String */;
3912 val* var96 /* : RuntimeVariable */;
3913 static val* varonce97;
3914 val* var98 /* : String */;
3915 char* var99 /* : NativeString */;
3916 long var100 /* : Int */;
3917 val* var101 /* : String */;
3918 short int var102 /* : Bool */;
3919 static val* varonce103;
3920 val* var104 /* : String */;
3921 char* var105 /* : NativeString */;
3922 long var106 /* : Int */;
3923 val* var107 /* : String */;
3924 long var108 /* : Int */;
3925 val* var109 /* : nullable Object */;
3926 val* var110 /* : Array[Object] */;
3927 long var111 /* : Int */;
3928 val* var112 /* : NativeArray[Object] */;
3929 val* var113 /* : String */;
3930 val* var114 /* : RuntimeVariable */;
3931 static val* varonce115;
3932 val* var116 /* : String */;
3933 char* var117 /* : NativeString */;
3934 long var118 /* : Int */;
3935 val* var119 /* : String */;
3936 short int var120 /* : Bool */;
3937 long var121 /* : Int */;
3938 val* var122 /* : nullable Object */;
3939 static val* varonce123;
3940 val* var124 /* : String */;
3941 char* var125 /* : NativeString */;
3942 long var126 /* : Int */;
3943 val* var127 /* : String */;
3944 val* var128 /* : Array[Object] */;
3945 long var129 /* : Int */;
3946 val* var130 /* : NativeArray[Object] */;
3947 val* var131 /* : String */;
3948 val* var132 /* : RuntimeVariable */;
3949 static val* varonce133;
3950 val* var134 /* : String */;
3951 char* var135 /* : NativeString */;
3952 long var136 /* : Int */;
3953 val* var137 /* : String */;
3954 short int var138 /* : Bool */;
3955 long var139 /* : Int */;
3956 val* var140 /* : nullable Object */;
3957 static val* varonce141;
3958 val* var142 /* : String */;
3959 char* var143 /* : NativeString */;
3960 long var144 /* : Int */;
3961 val* var145 /* : String */;
3962 val* var146 /* : Array[Object] */;
3963 long var147 /* : Int */;
3964 val* var148 /* : NativeArray[Object] */;
3965 val* var149 /* : String */;
3966 val* var150 /* : RuntimeVariable */;
3967 static val* varonce151;
3968 val* var152 /* : String */;
3969 char* var153 /* : NativeString */;
3970 long var154 /* : Int */;
3971 val* var155 /* : String */;
3972 short int var156 /* : Bool */;
3973 long var157 /* : Int */;
3974 val* var158 /* : nullable Object */;
3975 static val* varonce159;
3976 val* var160 /* : String */;
3977 char* var161 /* : NativeString */;
3978 long var162 /* : Int */;
3979 val* var163 /* : String */;
3980 long var164 /* : Int */;
3981 val* var165 /* : nullable Object */;
3982 val* var166 /* : Array[Object] */;
3983 long var167 /* : Int */;
3984 val* var168 /* : NativeArray[Object] */;
3985 val* var169 /* : String */;
3986 val* var170 /* : RuntimeVariable */;
3987 static val* varonce171;
3988 val* var172 /* : String */;
3989 char* var173 /* : NativeString */;
3990 long var174 /* : Int */;
3991 val* var175 /* : String */;
3992 short int var176 /* : Bool */;
3993 long var177 /* : Int */;
3994 val* var178 /* : nullable Object */;
3995 static val* varonce179;
3996 val* var180 /* : String */;
3997 char* var181 /* : NativeString */;
3998 long var182 /* : Int */;
3999 val* var183 /* : String */;
4000 long var184 /* : Int */;
4001 val* var185 /* : nullable Object */;
4002 val* var186 /* : Array[Object] */;
4003 long var187 /* : Int */;
4004 val* var188 /* : NativeArray[Object] */;
4005 val* var189 /* : String */;
4006 val* var190 /* : RuntimeVariable */;
4007 static val* varonce191;
4008 val* var192 /* : String */;
4009 char* var193 /* : NativeString */;
4010 long var194 /* : Int */;
4011 val* var195 /* : String */;
4012 short int var196 /* : Bool */;
4013 long var197 /* : Int */;
4014 val* var198 /* : nullable Object */;
4015 static val* varonce199;
4016 val* var200 /* : String */;
4017 char* var201 /* : NativeString */;
4018 long var202 /* : Int */;
4019 val* var203 /* : String */;
4020 long var204 /* : Int */;
4021 val* var205 /* : nullable Object */;
4022 val* var206 /* : Array[Object] */;
4023 long var207 /* : Int */;
4024 val* var208 /* : NativeArray[Object] */;
4025 val* var209 /* : String */;
4026 val* var210 /* : RuntimeVariable */;
4027 static val* varonce211;
4028 val* var212 /* : String */;
4029 char* var213 /* : NativeString */;
4030 long var214 /* : Int */;
4031 val* var215 /* : String */;
4032 short int var216 /* : Bool */;
4033 long var217 /* : Int */;
4034 val* var218 /* : nullable Object */;
4035 static val* varonce219;
4036 val* var220 /* : String */;
4037 char* var221 /* : NativeString */;
4038 long var222 /* : Int */;
4039 val* var223 /* : String */;
4040 long var224 /* : Int */;
4041 val* var225 /* : nullable Object */;
4042 val* var226 /* : Array[Object] */;
4043 long var227 /* : Int */;
4044 val* var228 /* : NativeArray[Object] */;
4045 val* var229 /* : String */;
4046 val* var230 /* : RuntimeVariable */;
4047 static val* varonce231;
4048 val* var232 /* : String */;
4049 char* var233 /* : NativeString */;
4050 long var234 /* : Int */;
4051 val* var235 /* : String */;
4052 short int var236 /* : Bool */;
4053 long var237 /* : Int */;
4054 val* var238 /* : nullable Object */;
4055 static val* varonce239;
4056 val* var240 /* : String */;
4057 char* var241 /* : NativeString */;
4058 long var242 /* : Int */;
4059 val* var243 /* : String */;
4060 long var244 /* : Int */;
4061 val* var245 /* : nullable Object */;
4062 val* var246 /* : Array[Object] */;
4063 long var247 /* : Int */;
4064 val* var248 /* : NativeArray[Object] */;
4065 val* var249 /* : String */;
4066 val* var250 /* : RuntimeVariable */;
4067 static val* varonce251;
4068 val* var252 /* : String */;
4069 char* var253 /* : NativeString */;
4070 long var254 /* : Int */;
4071 val* var255 /* : String */;
4072 short int var256 /* : Bool */;
4073 long var257 /* : Int */;
4074 val* var258 /* : nullable Object */;
4075 long var259 /* : Int */;
4076 val* var260 /* : nullable Object */;
4077 val* var261 /* : RuntimeVariable */;
4078 static val* varonce262;
4079 val* var263 /* : String */;
4080 char* var264 /* : NativeString */;
4081 long var265 /* : Int */;
4082 val* var266 /* : String */;
4083 short int var267 /* : Bool */;
4084 long var268 /* : Int */;
4085 val* var269 /* : nullable Object */;
4086 long var270 /* : Int */;
4087 val* var271 /* : nullable Object */;
4088 val* var272 /* : RuntimeVariable */;
4089 val* var_res /* var res: RuntimeVariable */;
4090 static val* varonce273;
4091 val* var274 /* : String */;
4092 char* var275 /* : NativeString */;
4093 long var276 /* : Int */;
4094 val* var277 /* : String */;
4095 val* var278 /* : Array[Object] */;
4096 long var279 /* : Int */;
4097 val* var280 /* : NativeArray[Object] */;
4098 val* var281 /* : String */;
4099 val* var282 /* : RuntimeVariable */;
4100 static val* varonce283;
4101 val* var284 /* : String */;
4102 char* var285 /* : NativeString */;
4103 long var286 /* : Int */;
4104 val* var287 /* : String */;
4105 short int var288 /* : Bool */;
4106 long var289 /* : Int */;
4107 val* var290 /* : nullable Object */;
4108 static val* varonce291;
4109 val* var292 /* : String */;
4110 char* var293 /* : NativeString */;
4111 long var294 /* : Int */;
4112 val* var295 /* : String */;
4113 long var296 /* : Int */;
4114 val* var297 /* : nullable Object */;
4115 val* var298 /* : Array[Object] */;
4116 long var299 /* : Int */;
4117 val* var300 /* : NativeArray[Object] */;
4118 val* var301 /* : String */;
4119 val* var302 /* : RuntimeVariable */;
4120 static val* varonce303;
4121 val* var304 /* : String */;
4122 char* var305 /* : NativeString */;
4123 long var306 /* : Int */;
4124 val* var307 /* : String */;
4125 short int var308 /* : Bool */;
4126 long var309 /* : Int */;
4127 val* var310 /* : nullable Object */;
4128 static val* varonce311;
4129 val* var312 /* : String */;
4130 char* var313 /* : NativeString */;
4131 long var314 /* : Int */;
4132 val* var315 /* : String */;
4133 long var316 /* : Int */;
4134 val* var317 /* : nullable Object */;
4135 val* var318 /* : Array[Object] */;
4136 long var319 /* : Int */;
4137 val* var320 /* : NativeArray[Object] */;
4138 val* var321 /* : String */;
4139 val* var322 /* : RuntimeVariable */;
4140 static val* varonce323;
4141 val* var324 /* : String */;
4142 char* var325 /* : NativeString */;
4143 long var326 /* : Int */;
4144 val* var327 /* : String */;
4145 short int var328 /* : Bool */;
4146 long var329 /* : Int */;
4147 val* var330 /* : nullable Object */;
4148 static val* varonce331;
4149 val* var332 /* : String */;
4150 char* var333 /* : NativeString */;
4151 long var334 /* : Int */;
4152 val* var335 /* : String */;
4153 long var336 /* : Int */;
4154 val* var337 /* : nullable Object */;
4155 val* var338 /* : Array[Object] */;
4156 long var339 /* : Int */;
4157 val* var340 /* : NativeArray[Object] */;
4158 val* var341 /* : String */;
4159 val* var342 /* : RuntimeVariable */;
4160 static val* varonce343;
4161 val* var344 /* : String */;
4162 char* var345 /* : NativeString */;
4163 long var346 /* : Int */;
4164 val* var347 /* : String */;
4165 short int var348 /* : Bool */;
4166 long var349 /* : Int */;
4167 val* var350 /* : nullable Object */;
4168 static val* varonce351;
4169 val* var352 /* : String */;
4170 char* var353 /* : NativeString */;
4171 long var354 /* : Int */;
4172 val* var355 /* : String */;
4173 long var356 /* : Int */;
4174 val* var357 /* : nullable Object */;
4175 val* var358 /* : Array[Object] */;
4176 long var359 /* : Int */;
4177 val* var360 /* : NativeArray[Object] */;
4178 val* var361 /* : String */;
4179 val* var362 /* : RuntimeVariable */;
4180 static val* varonce363;
4181 val* var364 /* : String */;
4182 char* var365 /* : NativeString */;
4183 long var366 /* : Int */;
4184 val* var367 /* : String */;
4185 short int var368 /* : Bool */;
4186 static val* varonce369;
4187 val* var370 /* : String */;
4188 char* var371 /* : NativeString */;
4189 long var372 /* : Int */;
4190 val* var373 /* : String */;
4191 long var374 /* : Int */;
4192 val* var375 /* : nullable Object */;
4193 val* var376 /* : Array[Object] */;
4194 long var377 /* : Int */;
4195 val* var378 /* : NativeArray[Object] */;
4196 val* var379 /* : String */;
4197 val* var380 /* : RuntimeVariable */;
4198 static val* varonce381;
4199 val* var382 /* : String */;
4200 char* var383 /* : NativeString */;
4201 long var384 /* : Int */;
4202 val* var385 /* : String */;
4203 short int var386 /* : Bool */;
4204 long var387 /* : Int */;
4205 val* var388 /* : nullable Object */;
4206 val* var389 /* : Array[Object] */;
4207 long var390 /* : Int */;
4208 val* var391 /* : NativeArray[Object] */;
4209 val* var392 /* : String */;
4210 val* var393 /* : RuntimeVariable */;
4211 static val* varonce394;
4212 val* var395 /* : String */;
4213 char* var396 /* : NativeString */;
4214 long var397 /* : Int */;
4215 val* var398 /* : String */;
4216 short int var399 /* : Bool */;
4217 static val* varonce400;
4218 val* var401 /* : String */;
4219 char* var402 /* : NativeString */;
4220 long var403 /* : Int */;
4221 val* var404 /* : String */;
4222 short int var405 /* : Bool */;
4223 static val* varonce406;
4224 val* var407 /* : String */;
4225 char* var408 /* : NativeString */;
4226 long var409 /* : Int */;
4227 val* var410 /* : String */;
4228 val* var411 /* : nullable Object */;
4229 static val* varonce412;
4230 val* var413 /* : String */;
4231 char* var414 /* : NativeString */;
4232 long var415 /* : Int */;
4233 val* var416 /* : String */;
4234 val* var417 /* : Array[Object] */;
4235 long var418 /* : Int */;
4236 val* var419 /* : NativeArray[Object] */;
4237 val* var420 /* : String */;
4238 static val* varonce421;
4239 val* var422 /* : String */;
4240 char* var423 /* : NativeString */;
4241 long var424 /* : Int */;
4242 val* var425 /* : String */;
4243 short int var426 /* : Bool */;
4244 static val* varonce427;
4245 val* var428 /* : String */;
4246 char* var429 /* : NativeString */;
4247 long var430 /* : Int */;
4248 val* var431 /* : String */;
4249 val* var432 /* : nullable Object */;
4250 val* var433 /* : Array[Object] */;
4251 long var434 /* : Int */;
4252 val* var435 /* : NativeArray[Object] */;
4253 val* var436 /* : String */;
4254 val* var437 /* : RuntimeVariable */;
4255 static val* varonce438;
4256 val* var439 /* : String */;
4257 char* var440 /* : NativeString */;
4258 long var441 /* : Int */;
4259 val* var442 /* : String */;
4260 short int var443 /* : Bool */;
4261 long var444 /* : Int */;
4262 val* var445 /* : nullable Object */;
4263 static val* varonce446;
4264 val* var447 /* : String */;
4265 char* var448 /* : NativeString */;
4266 long var449 /* : Int */;
4267 val* var450 /* : String */;
4268 long var451 /* : Int */;
4269 val* var452 /* : nullable Object */;
4270 val* var453 /* : Array[Object] */;
4271 long var454 /* : Int */;
4272 val* var455 /* : NativeArray[Object] */;
4273 val* var456 /* : String */;
4274 val* var457 /* : RuntimeVariable */;
4275 static val* varonce458;
4276 val* var459 /* : String */;
4277 char* var460 /* : NativeString */;
4278 long var461 /* : Int */;
4279 val* var462 /* : String */;
4280 short int var463 /* : Bool */;
4281 long var464 /* : Int */;
4282 val* var465 /* : nullable Object */;
4283 static val* varonce466;
4284 val* var467 /* : String */;
4285 char* var468 /* : NativeString */;
4286 long var469 /* : Int */;
4287 val* var470 /* : String */;
4288 long var471 /* : Int */;
4289 val* var472 /* : nullable Object */;
4290 val* var473 /* : Array[Object] */;
4291 long var474 /* : Int */;
4292 val* var475 /* : NativeArray[Object] */;
4293 val* var476 /* : String */;
4294 val* var477 /* : RuntimeVariable */;
4295 static val* varonce478;
4296 val* var479 /* : String */;
4297 char* var480 /* : NativeString */;
4298 long var481 /* : Int */;
4299 val* var482 /* : String */;
4300 short int var483 /* : Bool */;
4301 long var484 /* : Int */;
4302 val* var485 /* : nullable Object */;
4303 long var486 /* : Int */;
4304 val* var487 /* : nullable Object */;
4305 val* var488 /* : RuntimeVariable */;
4306 static val* varonce489;
4307 val* var490 /* : String */;
4308 char* var491 /* : NativeString */;
4309 long var492 /* : Int */;
4310 val* var493 /* : String */;
4311 short int var494 /* : Bool */;
4312 long var495 /* : Int */;
4313 val* var496 /* : nullable Object */;
4314 long var497 /* : Int */;
4315 val* var498 /* : nullable Object */;
4316 val* var499 /* : RuntimeVariable */;
4317 val* var_res500 /* var res: RuntimeVariable */;
4318 static val* varonce501;
4319 val* var502 /* : String */;
4320 char* var503 /* : NativeString */;
4321 long var504 /* : Int */;
4322 val* var505 /* : String */;
4323 val* var506 /* : Array[Object] */;
4324 long var507 /* : Int */;
4325 val* var508 /* : NativeArray[Object] */;
4326 val* var509 /* : String */;
4327 val* var510 /* : RuntimeVariable */;
4328 static val* varonce511;
4329 val* var512 /* : String */;
4330 char* var513 /* : NativeString */;
4331 long var514 /* : Int */;
4332 val* var515 /* : String */;
4333 short int var516 /* : Bool */;
4334 long var517 /* : Int */;
4335 val* var518 /* : nullable Object */;
4336 static val* varonce519;
4337 val* var520 /* : String */;
4338 char* var521 /* : NativeString */;
4339 long var522 /* : Int */;
4340 val* var523 /* : String */;
4341 val* var524 /* : Array[Object] */;
4342 long var525 /* : Int */;
4343 val* var526 /* : NativeArray[Object] */;
4344 val* var527 /* : String */;
4345 val* var528 /* : RuntimeVariable */;
4346 static val* varonce529;
4347 val* var530 /* : String */;
4348 char* var531 /* : NativeString */;
4349 long var532 /* : Int */;
4350 val* var533 /* : String */;
4351 short int var534 /* : Bool */;
4352 long var535 /* : Int */;
4353 val* var536 /* : nullable Object */;
4354 static val* varonce537;
4355 val* var538 /* : String */;
4356 char* var539 /* : NativeString */;
4357 long var540 /* : Int */;
4358 val* var541 /* : String */;
4359 val* var542 /* : Array[Object] */;
4360 long var543 /* : Int */;
4361 val* var544 /* : NativeArray[Object] */;
4362 val* var545 /* : String */;
4363 val* var546 /* : RuntimeVariable */;
4364 static val* varonce547;
4365 val* var548 /* : String */;
4366 char* var549 /* : NativeString */;
4367 long var550 /* : Int */;
4368 val* var551 /* : String */;
4369 short int var552 /* : Bool */;
4370 long var553 /* : Int */;
4371 val* var554 /* : nullable Object */;
4372 static val* varonce555;
4373 val* var556 /* : String */;
4374 char* var557 /* : NativeString */;
4375 long var558 /* : Int */;
4376 val* var559 /* : String */;
4377 long var560 /* : Int */;
4378 val* var561 /* : nullable Object */;
4379 val* var562 /* : Array[Object] */;
4380 long var563 /* : Int */;
4381 val* var564 /* : NativeArray[Object] */;
4382 val* var565 /* : String */;
4383 val* var566 /* : RuntimeVariable */;
4384 static val* varonce567;
4385 val* var568 /* : String */;
4386 char* var569 /* : NativeString */;
4387 long var570 /* : Int */;
4388 val* var571 /* : String */;
4389 short int var572 /* : Bool */;
4390 long var573 /* : Int */;
4391 val* var574 /* : nullable Object */;
4392 static val* varonce575;
4393 val* var576 /* : String */;
4394 char* var577 /* : NativeString */;
4395 long var578 /* : Int */;
4396 val* var579 /* : String */;
4397 long var580 /* : Int */;
4398 val* var581 /* : nullable Object */;
4399 val* var582 /* : Array[Object] */;
4400 long var583 /* : Int */;
4401 val* var584 /* : NativeArray[Object] */;
4402 val* var585 /* : String */;
4403 val* var586 /* : RuntimeVariable */;
4404 static val* varonce587;
4405 val* var588 /* : String */;
4406 char* var589 /* : NativeString */;
4407 long var590 /* : Int */;
4408 val* var591 /* : String */;
4409 short int var592 /* : Bool */;
4410 long var593 /* : Int */;
4411 val* var594 /* : nullable Object */;
4412 static val* varonce595;
4413 val* var596 /* : String */;
4414 char* var597 /* : NativeString */;
4415 long var598 /* : Int */;
4416 val* var599 /* : String */;
4417 long var600 /* : Int */;
4418 val* var601 /* : nullable Object */;
4419 val* var602 /* : Array[Object] */;
4420 long var603 /* : Int */;
4421 val* var604 /* : NativeArray[Object] */;
4422 val* var605 /* : String */;
4423 val* var606 /* : RuntimeVariable */;
4424 static val* varonce607;
4425 val* var608 /* : String */;
4426 char* var609 /* : NativeString */;
4427 long var610 /* : Int */;
4428 val* var611 /* : String */;
4429 short int var612 /* : Bool */;
4430 long var613 /* : Int */;
4431 val* var614 /* : nullable Object */;
4432 static val* varonce615;
4433 val* var616 /* : String */;
4434 char* var617 /* : NativeString */;
4435 long var618 /* : Int */;
4436 val* var619 /* : String */;
4437 long var620 /* : Int */;
4438 val* var621 /* : nullable Object */;
4439 val* var622 /* : Array[Object] */;
4440 long var623 /* : Int */;
4441 val* var624 /* : NativeArray[Object] */;
4442 val* var625 /* : String */;
4443 val* var626 /* : RuntimeVariable */;
4444 static val* varonce627;
4445 val* var628 /* : String */;
4446 char* var629 /* : NativeString */;
4447 long var630 /* : Int */;
4448 val* var631 /* : String */;
4449 short int var632 /* : Bool */;
4450 long var633 /* : Int */;
4451 val* var634 /* : nullable Object */;
4452 static val* varonce635;
4453 val* var636 /* : String */;
4454 char* var637 /* : NativeString */;
4455 long var638 /* : Int */;
4456 val* var639 /* : String */;
4457 val* var640 /* : Array[Object] */;
4458 long var641 /* : Int */;
4459 val* var642 /* : NativeArray[Object] */;
4460 val* var643 /* : String */;
4461 val* var644 /* : RuntimeVariable */;
4462 static val* varonce645;
4463 val* var646 /* : String */;
4464 char* var647 /* : NativeString */;
4465 long var648 /* : Int */;
4466 val* var649 /* : String */;
4467 short int var650 /* : Bool */;
4468 static val* varonce651;
4469 val* var652 /* : String */;
4470 char* var653 /* : NativeString */;
4471 long var654 /* : Int */;
4472 val* var655 /* : String */;
4473 long var656 /* : Int */;
4474 val* var657 /* : nullable Object */;
4475 val* var658 /* : Array[Object] */;
4476 long var659 /* : Int */;
4477 val* var660 /* : NativeArray[Object] */;
4478 val* var661 /* : String */;
4479 val* var662 /* : RuntimeVariable */;
4480 static val* varonce663;
4481 val* var664 /* : String */;
4482 char* var665 /* : NativeString */;
4483 long var666 /* : Int */;
4484 val* var667 /* : String */;
4485 short int var668 /* : Bool */;
4486 static val* varonce669;
4487 val* var670 /* : String */;
4488 char* var671 /* : NativeString */;
4489 long var672 /* : Int */;
4490 val* var673 /* : String */;
4491 short int var674 /* : Bool */;
4492 static val* varonce675;
4493 val* var676 /* : String */;
4494 char* var677 /* : NativeString */;
4495 long var678 /* : Int */;
4496 val* var679 /* : String */;
4497 val* var680 /* : nullable Object */;
4498 static val* varonce681;
4499 val* var682 /* : String */;
4500 char* var683 /* : NativeString */;
4501 long var684 /* : Int */;
4502 val* var685 /* : String */;
4503 val* var686 /* : Array[Object] */;
4504 long var687 /* : Int */;
4505 val* var688 /* : NativeArray[Object] */;
4506 val* var689 /* : String */;
4507 static val* varonce690;
4508 val* var691 /* : String */;
4509 char* var692 /* : NativeString */;
4510 long var693 /* : Int */;
4511 val* var694 /* : String */;
4512 short int var695 /* : Bool */;
4513 static val* varonce696;
4514 val* var697 /* : String */;
4515 char* var698 /* : NativeString */;
4516 long var699 /* : Int */;
4517 val* var700 /* : String */;
4518 val* var701 /* : nullable Object */;
4519 val* var702 /* : Array[Object] */;
4520 long var703 /* : Int */;
4521 val* var704 /* : NativeArray[Object] */;
4522 val* var705 /* : String */;
4523 val* var706 /* : RuntimeVariable */;
4524 static val* varonce707;
4525 val* var708 /* : String */;
4526 char* var709 /* : NativeString */;
4527 long var710 /* : Int */;
4528 val* var711 /* : String */;
4529 short int var712 /* : Bool */;
4530 long var713 /* : Int */;
4531 val* var714 /* : nullable Object */;
4532 long var715 /* : Int */;
4533 val* var716 /* : nullable Object */;
4534 val* var717 /* : RuntimeVariable */;
4535 static val* varonce718;
4536 val* var719 /* : String */;
4537 char* var720 /* : NativeString */;
4538 long var721 /* : Int */;
4539 val* var722 /* : String */;
4540 short int var723 /* : Bool */;
4541 long var724 /* : Int */;
4542 val* var725 /* : nullable Object */;
4543 long var726 /* : Int */;
4544 val* var727 /* : nullable Object */;
4545 val* var728 /* : RuntimeVariable */;
4546 val* var_res729 /* var res: RuntimeVariable */;
4547 static val* varonce730;
4548 val* var731 /* : String */;
4549 char* var732 /* : NativeString */;
4550 long var733 /* : Int */;
4551 val* var734 /* : String */;
4552 val* var735 /* : Array[Object] */;
4553 long var736 /* : Int */;
4554 val* var737 /* : NativeArray[Object] */;
4555 val* var738 /* : String */;
4556 val* var739 /* : RuntimeVariable */;
4557 static val* varonce740;
4558 val* var741 /* : String */;
4559 char* var742 /* : NativeString */;
4560 long var743 /* : Int */;
4561 val* var744 /* : String */;
4562 short int var745 /* : Bool */;
4563 static val* varonce746;
4564 val* var747 /* : String */;
4565 char* var748 /* : NativeString */;
4566 long var749 /* : Int */;
4567 val* var750 /* : String */;
4568 short int var751 /* : Bool */;
4569 static val* varonce752;
4570 val* var753 /* : String */;
4571 char* var754 /* : NativeString */;
4572 long var755 /* : Int */;
4573 val* var756 /* : String */;
4574 val* var757 /* : nullable Object */;
4575 static val* varonce758;
4576 val* var759 /* : String */;
4577 char* var760 /* : NativeString */;
4578 long var761 /* : Int */;
4579 val* var762 /* : String */;
4580 val* var763 /* : Array[Object] */;
4581 long var764 /* : Int */;
4582 val* var765 /* : NativeArray[Object] */;
4583 val* var766 /* : String */;
4584 static val* varonce767;
4585 val* var768 /* : String */;
4586 char* var769 /* : NativeString */;
4587 long var770 /* : Int */;
4588 val* var771 /* : String */;
4589 short int var772 /* : Bool */;
4590 static val* varonce773;
4591 val* var774 /* : String */;
4592 char* var775 /* : NativeString */;
4593 long var776 /* : Int */;
4594 val* var777 /* : String */;
4595 val* var778 /* : nullable Object */;
4596 val* var779 /* : Array[Object] */;
4597 long var780 /* : Int */;
4598 val* var781 /* : NativeArray[Object] */;
4599 val* var782 /* : String */;
4600 val* var783 /* : RuntimeVariable */;
4601 static val* varonce784;
4602 val* var785 /* : String */;
4603 char* var786 /* : NativeString */;
4604 long var787 /* : Int */;
4605 val* var788 /* : String */;
4606 short int var789 /* : Bool */;
4607 long var790 /* : Int */;
4608 val* var791 /* : nullable Object */;
4609 static val* varonce792;
4610 val* var793 /* : String */;
4611 char* var794 /* : NativeString */;
4612 long var795 /* : Int */;
4613 val* var796 /* : String */;
4614 long var797 /* : Int */;
4615 val* var798 /* : nullable Object */;
4616 val* var799 /* : Array[Object] */;
4617 long var800 /* : Int */;
4618 val* var801 /* : NativeArray[Object] */;
4619 val* var802 /* : String */;
4620 val* var803 /* : RuntimeVariable */;
4621 static val* varonce804;
4622 val* var805 /* : String */;
4623 char* var806 /* : NativeString */;
4624 long var807 /* : Int */;
4625 val* var808 /* : String */;
4626 short int var809 /* : Bool */;
4627 long var810 /* : Int */;
4628 val* var811 /* : nullable Object */;
4629 static val* varonce812;
4630 val* var813 /* : String */;
4631 char* var814 /* : NativeString */;
4632 long var815 /* : Int */;
4633 val* var816 /* : String */;
4634 long var817 /* : Int */;
4635 val* var818 /* : nullable Object */;
4636 val* var819 /* : Array[Object] */;
4637 long var820 /* : Int */;
4638 val* var821 /* : NativeArray[Object] */;
4639 val* var822 /* : String */;
4640 val* var823 /* : RuntimeVariable */;
4641 static val* varonce824;
4642 val* var825 /* : String */;
4643 char* var826 /* : NativeString */;
4644 long var827 /* : Int */;
4645 val* var828 /* : String */;
4646 short int var829 /* : Bool */;
4647 static val* varonce830;
4648 val* var831 /* : String */;
4649 char* var832 /* : NativeString */;
4650 long var833 /* : Int */;
4651 val* var834 /* : String */;
4652 long var835 /* : Int */;
4653 val* var836 /* : nullable Object */;
4654 val* var837 /* : Array[Object] */;
4655 long var838 /* : Int */;
4656 val* var839 /* : NativeArray[Object] */;
4657 val* var840 /* : String */;
4658 val* var841 /* : RuntimeVariable */;
4659 static val* varonce842;
4660 val* var843 /* : String */;
4661 char* var844 /* : NativeString */;
4662 long var845 /* : Int */;
4663 val* var846 /* : String */;
4664 short int var847 /* : Bool */;
4665 long var848 /* : Int */;
4666 val* var849 /* : nullable Object */;
4667 static val* varonce850;
4668 val* var851 /* : String */;
4669 char* var852 /* : NativeString */;
4670 long var853 /* : Int */;
4671 val* var854 /* : String */;
4672 val* var855 /* : Array[Object] */;
4673 long var856 /* : Int */;
4674 val* var857 /* : NativeArray[Object] */;
4675 val* var858 /* : String */;
4676 val* var859 /* : RuntimeVariable */;
4677 static val* varonce860;
4678 val* var861 /* : String */;
4679 char* var862 /* : NativeString */;
4680 long var863 /* : Int */;
4681 val* var864 /* : String */;
4682 short int var865 /* : Bool */;
4683 long var866 /* : Int */;
4684 val* var867 /* : nullable Object */;
4685 static val* varonce868;
4686 val* var869 /* : String */;
4687 char* var870 /* : NativeString */;
4688 long var871 /* : Int */;
4689 val* var872 /* : String */;
4690 val* var873 /* : Array[Object] */;
4691 long var874 /* : Int */;
4692 val* var875 /* : NativeArray[Object] */;
4693 val* var876 /* : String */;
4694 val* var877 /* : RuntimeVariable */;
4695 static val* varonce878;
4696 val* var879 /* : String */;
4697 char* var880 /* : NativeString */;
4698 long var881 /* : Int */;
4699 val* var882 /* : String */;
4700 short int var883 /* : Bool */;
4701 long var884 /* : Int */;
4702 val* var885 /* : nullable Object */;
4703 static val* varonce886;
4704 val* var887 /* : String */;
4705 char* var888 /* : NativeString */;
4706 long var889 /* : Int */;
4707 val* var890 /* : String */;
4708 long var891 /* : Int */;
4709 val* var892 /* : nullable Object */;
4710 val* var893 /* : Array[Object] */;
4711 long var894 /* : Int */;
4712 val* var895 /* : NativeArray[Object] */;
4713 val* var896 /* : String */;
4714 val* var897 /* : RuntimeVariable */;
4715 static val* varonce898;
4716 val* var899 /* : String */;
4717 char* var900 /* : NativeString */;
4718 long var901 /* : Int */;
4719 val* var902 /* : String */;
4720 short int var903 /* : Bool */;
4721 long var904 /* : Int */;
4722 val* var905 /* : nullable Object */;
4723 static val* varonce906;
4724 val* var907 /* : String */;
4725 char* var908 /* : NativeString */;
4726 long var909 /* : Int */;
4727 val* var910 /* : String */;
4728 long var911 /* : Int */;
4729 val* var912 /* : nullable Object */;
4730 val* var913 /* : Array[Object] */;
4731 long var914 /* : Int */;
4732 val* var915 /* : NativeArray[Object] */;
4733 val* var916 /* : String */;
4734 val* var917 /* : RuntimeVariable */;
4735 static val* varonce918;
4736 val* var919 /* : String */;
4737 char* var920 /* : NativeString */;
4738 long var921 /* : Int */;
4739 val* var922 /* : String */;
4740 short int var923 /* : Bool */;
4741 long var924 /* : Int */;
4742 val* var925 /* : nullable Object */;
4743 long var926 /* : Int */;
4744 val* var927 /* : nullable Object */;
4745 val* var928 /* : RuntimeVariable */;
4746 static val* varonce929;
4747 val* var930 /* : String */;
4748 char* var931 /* : NativeString */;
4749 long var932 /* : Int */;
4750 val* var933 /* : String */;
4751 short int var934 /* : Bool */;
4752 long var935 /* : Int */;
4753 val* var936 /* : nullable Object */;
4754 long var937 /* : Int */;
4755 val* var938 /* : nullable Object */;
4756 val* var939 /* : RuntimeVariable */;
4757 val* var_res940 /* var res: RuntimeVariable */;
4758 static val* varonce941;
4759 val* var942 /* : String */;
4760 char* var943 /* : NativeString */;
4761 long var944 /* : Int */;
4762 val* var945 /* : String */;
4763 val* var946 /* : Array[Object] */;
4764 long var947 /* : Int */;
4765 val* var948 /* : NativeArray[Object] */;
4766 val* var949 /* : String */;
4767 val* var950 /* : RuntimeVariable */;
4768 static val* varonce951;
4769 val* var952 /* : String */;
4770 char* var953 /* : NativeString */;
4771 long var954 /* : Int */;
4772 val* var955 /* : String */;
4773 short int var956 /* : Bool */;
4774 long var957 /* : Int */;
4775 val* var958 /* : nullable Object */;
4776 static val* varonce959;
4777 val* var960 /* : String */;
4778 char* var961 /* : NativeString */;
4779 long var962 /* : Int */;
4780 val* var963 /* : String */;
4781 long var964 /* : Int */;
4782 val* var965 /* : nullable Object */;
4783 val* var966 /* : Array[Object] */;
4784 long var967 /* : Int */;
4785 val* var968 /* : NativeArray[Object] */;
4786 val* var969 /* : String */;
4787 val* var970 /* : RuntimeVariable */;
4788 static val* varonce971;
4789 val* var972 /* : String */;
4790 char* var973 /* : NativeString */;
4791 long var974 /* : Int */;
4792 val* var975 /* : String */;
4793 short int var976 /* : Bool */;
4794 long var977 /* : Int */;
4795 val* var978 /* : nullable Object */;
4796 static val* varonce979;
4797 val* var980 /* : String */;
4798 char* var981 /* : NativeString */;
4799 long var982 /* : Int */;
4800 val* var983 /* : String */;
4801 long var984 /* : Int */;
4802 val* var985 /* : nullable Object */;
4803 val* var986 /* : Array[Object] */;
4804 long var987 /* : Int */;
4805 val* var988 /* : NativeArray[Object] */;
4806 val* var989 /* : String */;
4807 val* var990 /* : RuntimeVariable */;
4808 static val* varonce991;
4809 val* var992 /* : String */;
4810 char* var993 /* : NativeString */;
4811 long var994 /* : Int */;
4812 val* var995 /* : String */;
4813 short int var996 /* : Bool */;
4814 long var997 /* : Int */;
4815 val* var998 /* : nullable Object */;
4816 static val* varonce999;
4817 val* var1000 /* : String */;
4818 char* var1001 /* : NativeString */;
4819 long var1002 /* : Int */;
4820 val* var1003 /* : String */;
4821 long var1004 /* : Int */;
4822 val* var1005 /* : nullable Object */;
4823 val* var1006 /* : Array[Object] */;
4824 long var1007 /* : Int */;
4825 val* var1008 /* : NativeArray[Object] */;
4826 val* var1009 /* : String */;
4827 val* var1010 /* : RuntimeVariable */;
4828 static val* varonce1011;
4829 val* var1012 /* : String */;
4830 char* var1013 /* : NativeString */;
4831 long var1014 /* : Int */;
4832 val* var1015 /* : String */;
4833 short int var1016 /* : Bool */;
4834 long var1017 /* : Int */;
4835 val* var1018 /* : nullable Object */;
4836 static val* varonce1019;
4837 val* var1020 /* : String */;
4838 char* var1021 /* : NativeString */;
4839 long var1022 /* : Int */;
4840 val* var1023 /* : String */;
4841 long var1024 /* : Int */;
4842 val* var1025 /* : nullable Object */;
4843 val* var1026 /* : Array[Object] */;
4844 long var1027 /* : Int */;
4845 val* var1028 /* : NativeArray[Object] */;
4846 val* var1029 /* : String */;
4847 val* var1030 /* : RuntimeVariable */;
4848 static val* varonce1031;
4849 val* var1032 /* : String */;
4850 char* var1033 /* : NativeString */;
4851 long var1034 /* : Int */;
4852 val* var1035 /* : String */;
4853 short int var1036 /* : Bool */;
4854 static val* varonce1037;
4855 val* var1038 /* : String */;
4856 char* var1039 /* : NativeString */;
4857 long var1040 /* : Int */;
4858 val* var1041 /* : String */;
4859 long var1042 /* : Int */;
4860 val* var1043 /* : nullable Object */;
4861 val* var1044 /* : Array[Object] */;
4862 long var1045 /* : Int */;
4863 val* var1046 /* : NativeArray[Object] */;
4864 val* var1047 /* : String */;
4865 val* var1048 /* : RuntimeVariable */;
4866 static val* varonce1049;
4867 val* var1050 /* : String */;
4868 char* var1051 /* : NativeString */;
4869 long var1052 /* : Int */;
4870 val* var1053 /* : String */;
4871 short int var1054 /* : Bool */;
4872 static val* varonce1055;
4873 val* var1056 /* : String */;
4874 char* var1057 /* : NativeString */;
4875 long var1058 /* : Int */;
4876 val* var1059 /* : String */;
4877 short int var1060 /* : Bool */;
4878 long var1061 /* : Int */;
4879 val* var1062 /* : nullable Object */;
4880 static val* varonce1063;
4881 val* var1064 /* : String */;
4882 char* var1065 /* : NativeString */;
4883 long var1066 /* : Int */;
4884 val* var1067 /* : String */;
4885 long var1068 /* : Int */;
4886 val* var1069 /* : nullable Object */;
4887 static val* varonce1070;
4888 val* var1071 /* : String */;
4889 char* var1072 /* : NativeString */;
4890 long var1073 /* : Int */;
4891 val* var1074 /* : String */;
4892 val* var1075 /* : Array[Object] */;
4893 long var1076 /* : Int */;
4894 val* var1077 /* : NativeArray[Object] */;
4895 val* var1078 /* : String */;
4896 val* var1079 /* : RuntimeVariable */;
4897 static val* varonce1080;
4898 val* var1081 /* : String */;
4899 char* var1082 /* : NativeString */;
4900 long var1083 /* : Int */;
4901 val* var1084 /* : String */;
4902 short int var1085 /* : Bool */;
4903 long var1086 /* : Int */;
4904 val* var1087 /* : nullable Object */;
4905 static val* varonce1088;
4906 val* var1089 /* : String */;
4907 char* var1090 /* : NativeString */;
4908 long var1091 /* : Int */;
4909 val* var1092 /* : String */;
4910 long var1093 /* : Int */;
4911 val* var1094 /* : nullable Object */;
4912 static val* varonce1095;
4913 val* var1096 /* : String */;
4914 char* var1097 /* : NativeString */;
4915 long var1098 /* : Int */;
4916 val* var1099 /* : String */;
4917 long var1100 /* : Int */;
4918 val* var1101 /* : nullable Object */;
4919 static val* varonce1102;
4920 val* var1103 /* : String */;
4921 char* var1104 /* : NativeString */;
4922 long var1105 /* : Int */;
4923 val* var1106 /* : String */;
4924 val* var1107 /* : Array[Object] */;
4925 long var1108 /* : Int */;
4926 val* var1109 /* : NativeArray[Object] */;
4927 val* var1110 /* : String */;
4928 static val* varonce1111;
4929 val* var1112 /* : String */;
4930 char* var1113 /* : NativeString */;
4931 long var1114 /* : Int */;
4932 val* var1115 /* : String */;
4933 short int var1116 /* : Bool */;
4934 static val* varonce1117;
4935 val* var1118 /* : String */;
4936 char* var1119 /* : NativeString */;
4937 long var1120 /* : Int */;
4938 val* var1121 /* : String */;
4939 long var1122 /* : Int */;
4940 val* var1123 /* : nullable Object */;
4941 static val* varonce1124;
4942 val* var1125 /* : String */;
4943 char* var1126 /* : NativeString */;
4944 long var1127 /* : Int */;
4945 val* var1128 /* : String */;
4946 long var1129 /* : Int */;
4947 val* var1130 /* : nullable Object */;
4948 static val* varonce1131;
4949 val* var1132 /* : String */;
4950 char* var1133 /* : NativeString */;
4951 long var1134 /* : Int */;
4952 val* var1135 /* : String */;
4953 long var1136 /* : Int */;
4954 val* var1137 /* : nullable Object */;
4955 static val* varonce1138;
4956 val* var1139 /* : String */;
4957 char* var1140 /* : NativeString */;
4958 long var1141 /* : Int */;
4959 val* var1142 /* : String */;
4960 long var1143 /* : Int */;
4961 val* var1144 /* : nullable Object */;
4962 static val* varonce1145;
4963 val* var1146 /* : String */;
4964 char* var1147 /* : NativeString */;
4965 long var1148 /* : Int */;
4966 val* var1149 /* : String */;
4967 long var1150 /* : Int */;
4968 val* var1151 /* : nullable Object */;
4969 static val* varonce1152;
4970 val* var1153 /* : String */;
4971 char* var1154 /* : NativeString */;
4972 long var1155 /* : Int */;
4973 val* var1156 /* : String */;
4974 val* var1157 /* : Array[Object] */;
4975 long var1158 /* : Int */;
4976 val* var1159 /* : NativeArray[Object] */;
4977 val* var1160 /* : String */;
4978 static val* varonce1161;
4979 val* var1162 /* : String */;
4980 char* var1163 /* : NativeString */;
4981 long var1164 /* : Int */;
4982 val* var1165 /* : String */;
4983 short int var1166 /* : Bool */;
4984 static val* varonce1167;
4985 val* var1168 /* : String */;
4986 char* var1169 /* : NativeString */;
4987 long var1170 /* : Int */;
4988 val* var1171 /* : String */;
4989 long var1172 /* : Int */;
4990 val* var1173 /* : nullable Object */;
4991 static val* varonce1174;
4992 val* var1175 /* : String */;
4993 char* var1176 /* : NativeString */;
4994 long var1177 /* : Int */;
4995 val* var1178 /* : String */;
4996 val* var1179 /* : Array[Object] */;
4997 long var1180 /* : Int */;
4998 val* var1181 /* : NativeArray[Object] */;
4999 val* var1182 /* : String */;
5000 val* var1183 /* : RuntimeVariable */;
5001 static val* varonce1184;
5002 val* var1185 /* : String */;
5003 char* var1186 /* : NativeString */;
5004 long var1187 /* : Int */;
5005 val* var1188 /* : String */;
5006 short int var1189 /* : Bool */;
5007 static val* varonce1190;
5008 val* var1191 /* : String */;
5009 char* var1192 /* : NativeString */;
5010 long var1193 /* : Int */;
5011 val* var1194 /* : String */;
5012 short int var1195 /* : Bool */;
5013 static val* varonce1196;
5014 val* var1197 /* : String */;
5015 char* var1198 /* : NativeString */;
5016 long var1199 /* : Int */;
5017 val* var1200 /* : String */;
5018 long var1201 /* : Int */;
5019 val* var1202 /* : nullable Object */;
5020 static val* varonce1203;
5021 val* var1204 /* : String */;
5022 char* var1205 /* : NativeString */;
5023 long var1206 /* : Int */;
5024 val* var1207 /* : String */;
5025 val* var1208 /* : Array[Object] */;
5026 long var1209 /* : Int */;
5027 val* var1210 /* : NativeArray[Object] */;
5028 val* var1211 /* : String */;
5029 static val* varonce1212;
5030 val* var1213 /* : String */;
5031 char* var1214 /* : NativeString */;
5032 long var1215 /* : Int */;
5033 val* var1216 /* : String */;
5034 short int var1217 /* : Bool */;
5035 static val* varonce1218;
5036 val* var1219 /* : String */;
5037 char* var1220 /* : NativeString */;
5038 long var1221 /* : Int */;
5039 val* var1222 /* : String */;
5040 val* var1223 /* : RuntimeVariable */;
5041 static val* varonce1224;
5042 val* var1225 /* : String */;
5043 char* var1226 /* : NativeString */;
5044 long var1227 /* : Int */;
5045 val* var1228 /* : String */;
5046 short int var1229 /* : Bool */;
5047 static val* varonce1230;
5048 val* var1231 /* : String */;
5049 char* var1232 /* : NativeString */;
5050 long var1233 /* : Int */;
5051 val* var1234 /* : String */;
5052 long var1235 /* : Int */;
5053 val* var1236 /* : nullable Object */;
5054 static val* varonce1237;
5055 val* var1238 /* : String */;
5056 char* var1239 /* : NativeString */;
5057 long var1240 /* : Int */;
5058 val* var1241 /* : String */;
5059 val* var1242 /* : Array[Object] */;
5060 long var1243 /* : Int */;
5061 val* var1244 /* : NativeArray[Object] */;
5062 val* var1245 /* : String */;
5063 val* var1246 /* : RuntimeVariable */;
5064 static val* varonce1247;
5065 val* var1248 /* : String */;
5066 char* var1249 /* : NativeString */;
5067 long var1250 /* : Int */;
5068 val* var1251 /* : String */;
5069 short int var1252 /* : Bool */;
5070 static val* varonce1253;
5071 val* var1254 /* : String */;
5072 char* var1255 /* : NativeString */;
5073 long var1256 /* : Int */;
5074 val* var1257 /* : String */;
5075 short int var1258 /* : Bool */;
5076 static val* varonce1259;
5077 val* var1260 /* : String */;
5078 char* var1261 /* : NativeString */;
5079 long var1262 /* : Int */;
5080 val* var1263 /* : String */;
5081 val* var1264 /* : nullable Object */;
5082 val* var1265 /* : Array[Object] */;
5083 long var1266 /* : Int */;
5084 val* var1267 /* : NativeArray[Object] */;
5085 val* var1268 /* : String */;
5086 val* var1269 /* : RuntimeVariable */;
5087 static val* varonce1270;
5088 val* var1271 /* : String */;
5089 char* var1272 /* : NativeString */;
5090 long var1273 /* : Int */;
5091 val* var1274 /* : String */;
5092 short int var1275 /* : Bool */;
5093 long var1276 /* : Int */;
5094 val* var1277 /* : nullable Object */;
5095 long var1278 /* : Int */;
5096 val* var1279 /* : nullable Object */;
5097 val* var1280 /* : RuntimeVariable */;
5098 static val* varonce1281;
5099 val* var1282 /* : String */;
5100 char* var1283 /* : NativeString */;
5101 long var1284 /* : Int */;
5102 val* var1285 /* : String */;
5103 short int var1286 /* : Bool */;
5104 long var1287 /* : Int */;
5105 val* var1288 /* : nullable Object */;
5106 long var1289 /* : Int */;
5107 val* var1290 /* : nullable Object */;
5108 val* var1291 /* : RuntimeVariable */;
5109 static val* varonce1292;
5110 val* var1293 /* : String */;
5111 char* var1294 /* : NativeString */;
5112 long var1295 /* : Int */;
5113 val* var1296 /* : String */;
5114 short int var1297 /* : Bool */;
5115 val* var1298 /* : nullable Object */;
5116 val* var1299 /* : String */;
5117 val* var_nat /* var nat: String */;
5118 static val* varonce1300;
5119 val* var1301 /* : String */;
5120 char* var1302 /* : NativeString */;
5121 long var1303 /* : Int */;
5122 val* var1304 /* : String */;
5123 static val* varonce1305;
5124 val* var1306 /* : String */;
5125 char* var1307 /* : NativeString */;
5126 long var1308 /* : Int */;
5127 val* var1309 /* : String */;
5128 val* var1310 /* : Array[Object] */;
5129 long var1311 /* : Int */;
5130 val* var1312 /* : NativeArray[Object] */;
5131 val* var1313 /* : String */;
5132 static val* varonce1314;
5133 val* var1315 /* : String */;
5134 char* var1316 /* : NativeString */;
5135 long var1317 /* : Int */;
5136 val* var1318 /* : String */;
5137 short int var1319 /* : Bool */;
5138 val* var1320 /* : nullable Object */;
5139 val* var1321 /* : String */;
5140 val* var_nat1322 /* var nat: String */;
5141 static val* varonce1323;
5142 val* var1324 /* : String */;
5143 char* var1325 /* : NativeString */;
5144 long var1326 /* : Int */;
5145 val* var1327 /* : String */;
5146 val* var1328 /* : Array[Object] */;
5147 long var1329 /* : Int */;
5148 val* var1330 /* : NativeArray[Object] */;
5149 val* var1331 /* : String */;
5150 val* var1332 /* : RuntimeVariable */;
5151 static val* varonce1333;
5152 val* var1334 /* : String */;
5153 char* var1335 /* : NativeString */;
5154 long var1336 /* : Int */;
5155 val* var1337 /* : String */;
5156 short int var1338 /* : Bool */;
5157 static val* varonce1339;
5158 val* var1340 /* : String */;
5159 char* var1341 /* : NativeString */;
5160 long var1342 /* : Int */;
5161 val* var1343 /* : String */;
5162 static val* varonce1344;
5163 val* var1345 /* : String */;
5164 char* var1346 /* : NativeString */;
5165 long var1347 /* : Int */;
5166 val* var1348 /* : String */;
5167 short int var1349 /* : Bool */;
5168 static val* varonce1350;
5169 val* var1351 /* : String */;
5170 char* var1352 /* : NativeString */;
5171 long var1353 /* : Int */;
5172 val* var1354 /* : String */;
5173 val* var1355 /* : RuntimeVariable */;
5174 static val* varonce1356;
5175 val* var1357 /* : String */;
5176 char* var1358 /* : NativeString */;
5177 long var1359 /* : Int */;
5178 val* var1360 /* : String */;
5179 short int var1361 /* : Bool */;
5180 static val* varonce1362;
5181 val* var1363 /* : String */;
5182 char* var1364 /* : NativeString */;
5183 long var1365 /* : Int */;
5184 val* var1366 /* : String */;
5185 long var1367 /* : Int */;
5186 val* var1368 /* : nullable Object */;
5187 static val* varonce1369;
5188 val* var1370 /* : String */;
5189 char* var1371 /* : NativeString */;
5190 long var1372 /* : Int */;
5191 val* var1373 /* : String */;
5192 val* var1374 /* : Array[Object] */;
5193 long var1375 /* : Int */;
5194 val* var1376 /* : NativeArray[Object] */;
5195 val* var1377 /* : String */;
5196 val* var1378 /* : RuntimeVariable */;
5197 static val* varonce1379;
5198 val* var1380 /* : String */;
5199 char* var1381 /* : NativeString */;
5200 long var1382 /* : Int */;
5201 val* var1383 /* : String */;
5202 val* var1384 /* : String */;
5203 static val* varonce1385;
5204 val* var1386 /* : String */;
5205 char* var1387 /* : NativeString */;
5206 long var1388 /* : Int */;
5207 val* var1389 /* : String */;
5208 static val* varonce1390;
5209 val* var1391 /* : String */;
5210 char* var1392 /* : NativeString */;
5211 long var1393 /* : Int */;
5212 val* var1394 /* : String */;
5213 val* var1395 /* : Location */;
5214 val* var1396 /* : String */;
5215 static val* varonce1397;
5216 val* var1398 /* : String */;
5217 char* var1399 /* : NativeString */;
5218 long var1400 /* : Int */;
5219 val* var1401 /* : String */;
5220 val* var1402 /* : Array[Object] */;
5221 long var1403 /* : Int */;
5222 val* var1404 /* : NativeArray[Object] */;
5223 val* var1405 /* : String */;
5224 static val* varonce1406;
5225 val* var1407 /* : String */;
5226 char* var1408 /* : NativeString */;
5227 long var1409 /* : Int */;
5228 val* var1410 /* : String */;
5229 val* var1411 /* : Array[Object] */;
5230 long var1412 /* : Int */;
5231 val* var1413 /* : NativeArray[Object] */;
5232 val* var1414 /* : String */;
5233 var_v = p0;
5234 var_mpropdef = p1;
5235 var_arguments = p2;
5236 var = ((val* (*)(val*))(var_mpropdef->class->vft[COLOR_model__MPropDef__mproperty]))(var_mpropdef) /* mproperty on <var_mpropdef:MMethodDef>*/;
5237 var1 = ((val* (*)(val*))(var->class->vft[COLOR_model__MProperty__name]))(var) /* name on <var:MProperty(MMethod)>*/;
5238 var_pname = var1;
5239 var2 = ((val* (*)(val*))(var_mpropdef->class->vft[COLOR_model__MPropDef__mclassdef]))(var_mpropdef) /* mclassdef on <var_mpropdef:MMethodDef>*/;
5240 var3 = ((val* (*)(val*))(var2->class->vft[COLOR_model__MClassDef__mclass]))(var2) /* mclass on <var2:MClassDef>*/;
5241 var4 = ((val* (*)(val*))(var3->class->vft[COLOR_model__MClass__name]))(var3) /* name on <var3:MClass>*/;
5242 var_cname = var4;
5243 var5 = ((val* (*)(val*))(var_mpropdef->class->vft[COLOR_model__MMethodDef__msignature]))(var_mpropdef) /* msignature on <var_mpropdef:MMethodDef>*/;
5244 if (var5 == NULL) {
5245 fprintf(stderr, "Runtime error: %s", "Reciever is null");
5246 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1356);
5247 exit(1);
5248 } else {
5249 var6 = ((val* (*)(val*))(var5->class->vft[COLOR_model__MSignature__return_mtype]))(var5) /* return_mtype on <var5:nullable MSignature>*/;
5250 }
5251 var_ret = var6;
5252 var7 = NULL;
5253 if (var_ret == NULL) {
5254 var8 = 0; /* is null */
5255 } else {
5256 var8 = 1; /* arg is null and recv is not */
5257 }
5258 if (var8){
5259 var9 = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__first]))(var_arguments) /* first on <var_arguments:Array[RuntimeVariable]>*/;
5260 var10 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__resolve_for]))(var_v, var_ret, var9) /* resolve_for on <var_v:AbstractCompilerVisitor>*/;
5261 var_ret = var10;
5262 } else {
5263 }
5264 if (varonce) {
5265 var12 = varonce;
5266 } else {
5267 var13 = "==";
5268 var14 = 2;
5269 var15 = string__NativeString__to_s_with_length(var13, var14);
5270 var12 = var15;
5271 varonce = var12;
5272 }
5273 var16 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___33d_61d]))(var_pname, var12) /* != on <var_pname:String>*/;
5274 var_ = var16;
5275 if (var16){
5276 if (varonce17) {
5277 var18 = varonce17;
5278 } else {
5279 var19 = "!=";
5280 var20 = 2;
5281 var21 = string__NativeString__to_s_with_length(var19, var20);
5282 var18 = var21;
5283 varonce17 = var18;
5284 }
5285 var22 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___33d_61d]))(var_pname, var18) /* != on <var_pname:String>*/;
5286 var11 = var22;
5287 } else {
5288 var11 = var_;
5289 }
5290 if (var11){
5291 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__adapt_signature]))(var_v, var_mpropdef, var_arguments) /* adapt_signature on <var_v:AbstractCompilerVisitor>*/;
5292 } else {
5293 }
5294 if (varonce23) {
5295 var24 = varonce23;
5296 } else {
5297 var25 = "Int";
5298 var26 = 3;
5299 var27 = string__NativeString__to_s_with_length(var25, var26);
5300 var24 = var27;
5301 varonce23 = var24;
5302 }
5303 var28 = ((short int (*)(val*, val*))(var_cname->class->vft[COLOR_kernel__Object___61d_61d]))(var_cname, var24) /* == on <var_cname:String>*/;
5304 if (var28){
5305 if (varonce29) {
5306 var30 = varonce29;
5307 } else {
5308 var31 = "output";
5309 var32 = 6;
5310 var33 = string__NativeString__to_s_with_length(var31, var32);
5311 var30 = var33;
5312 varonce29 = var30;
5313 }
5314 var34 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var30) /* == on <var_pname:String>*/;
5315 if (var34){
5316 if (varonce35) {
5317 var36 = varonce35;
5318 } else {
5319 var37 = "printf(\"%ld\\n\", ";
5320 var38 = 16;
5321 var39 = string__NativeString__to_s_with_length(var37, var38);
5322 var36 = var39;
5323 varonce35 = var36;
5324 }
5325 var40 = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__first]))(var_arguments) /* first on <var_arguments:Array[RuntimeVariable]>*/;
5326 if (varonce41) {
5327 var42 = varonce41;
5328 } else {
5329 var43 = ");";
5330 var44 = 2;
5331 var45 = string__NativeString__to_s_with_length(var43, var44);
5332 var42 = var45;
5333 varonce41 = var42;
5334 }
5335 var46 = NEW_array__Array(&type_array__Arraykernel__Object);
5336 { /* var46 = array_instance Array[Object] */
5337 var47 = 3;
5338 var48 = NEW_array__NativeArray(var47, &type_array__NativeArraykernel__Object);
5339 ((struct instance_array__NativeArray*)var48)->values[0] = (val*) var36;
5340 ((struct instance_array__NativeArray*)var48)->values[1] = (val*) var40;
5341 ((struct instance_array__NativeArray*)var48)->values[2] = (val*) var42;
5342 ((void (*)(val*, val*, long))(var46->class->vft[COLOR_array__Array__with_native]))(var46, var48, var47) /* with_native on <var46:Array[Object]>*/;
5343 CHECK_NEW_array__Array(var46);
5344 }
5345 var49 = ((val* (*)(val*))(var46->class->vft[COLOR_string__Object__to_s]))(var46) /* to_s on <var46:Array[Object]>*/;
5346 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var49) /* add on <var_v:AbstractCompilerVisitor>*/;
5347 goto RET_LABEL;
5348 } else {
5349 if (varonce50) {
5350 var51 = varonce50;
5351 } else {
5352 var52 = "object_id";
5353 var53 = 9;
5354 var54 = string__NativeString__to_s_with_length(var52, var53);
5355 var51 = var54;
5356 varonce50 = var51;
5357 }
5358 var55 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var51) /* == on <var_pname:String>*/;
5359 if (var55){
5360 var56 = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__first]))(var_arguments) /* first on <var_arguments:Array[RuntimeVariable]>*/;
5361 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var56) /* ret on <var_v:AbstractCompilerVisitor>*/;
5362 goto RET_LABEL;
5363 } else {
5364 if (varonce57) {
5365 var58 = varonce57;
5366 } else {
5367 var59 = "+";
5368 var60 = 1;
5369 var61 = string__NativeString__to_s_with_length(var59, var60);
5370 var58 = var61;
5371 varonce57 = var58;
5372 }
5373 var62 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var58) /* == on <var_pname:String>*/;
5374 if (var62){
5375 var63 = 0;
5376 var64 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var63) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5377 if (varonce65) {
5378 var66 = varonce65;
5379 } else {
5380 var67 = " + ";
5381 var68 = 3;
5382 var69 = string__NativeString__to_s_with_length(var67, var68);
5383 var66 = var69;
5384 varonce65 = var66;
5385 }
5386 var70 = 1;
5387 var71 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var70) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5388 var72 = NEW_array__Array(&type_array__Arraykernel__Object);
5389 { /* var72 = array_instance Array[Object] */
5390 var73 = 3;
5391 var74 = NEW_array__NativeArray(var73, &type_array__NativeArraykernel__Object);
5392 ((struct instance_array__NativeArray*)var74)->values[0] = (val*) var64;
5393 ((struct instance_array__NativeArray*)var74)->values[1] = (val*) var66;
5394 ((struct instance_array__NativeArray*)var74)->values[2] = (val*) var71;
5395 ((void (*)(val*, val*, long))(var72->class->vft[COLOR_array__Array__with_native]))(var72, var74, var73) /* with_native on <var72:Array[Object]>*/;
5396 CHECK_NEW_array__Array(var72);
5397 }
5398 var75 = ((val* (*)(val*))(var72->class->vft[COLOR_string__Object__to_s]))(var72) /* to_s on <var72:Array[Object]>*/;
5399 if (var_ret == NULL) {
5400 fprintf(stderr, "Runtime error: %s", "Cast failed");
5401 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1371);
5402 exit(1);
5403 }
5404 var76 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var75, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
5405 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var76) /* ret on <var_v:AbstractCompilerVisitor>*/;
5406 goto RET_LABEL;
5407 } else {
5408 if (varonce77) {
5409 var78 = varonce77;
5410 } else {
5411 var79 = "-";
5412 var80 = 1;
5413 var81 = string__NativeString__to_s_with_length(var79, var80);
5414 var78 = var81;
5415 varonce77 = var78;
5416 }
5417 var82 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var78) /* == on <var_pname:String>*/;
5418 if (var82){
5419 var83 = 0;
5420 var84 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var83) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5421 if (varonce85) {
5422 var86 = varonce85;
5423 } else {
5424 var87 = " - ";
5425 var88 = 3;
5426 var89 = string__NativeString__to_s_with_length(var87, var88);
5427 var86 = var89;
5428 varonce85 = var86;
5429 }
5430 var90 = 1;
5431 var91 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var90) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5432 var92 = NEW_array__Array(&type_array__Arraykernel__Object);
5433 { /* var92 = array_instance Array[Object] */
5434 var93 = 3;
5435 var94 = NEW_array__NativeArray(var93, &type_array__NativeArraykernel__Object);
5436 ((struct instance_array__NativeArray*)var94)->values[0] = (val*) var84;
5437 ((struct instance_array__NativeArray*)var94)->values[1] = (val*) var86;
5438 ((struct instance_array__NativeArray*)var94)->values[2] = (val*) var91;
5439 ((void (*)(val*, val*, long))(var92->class->vft[COLOR_array__Array__with_native]))(var92, var94, var93) /* with_native on <var92:Array[Object]>*/;
5440 CHECK_NEW_array__Array(var92);
5441 }
5442 var95 = ((val* (*)(val*))(var92->class->vft[COLOR_string__Object__to_s]))(var92) /* to_s on <var92:Array[Object]>*/;
5443 if (var_ret == NULL) {
5444 fprintf(stderr, "Runtime error: %s", "Cast failed");
5445 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1374);
5446 exit(1);
5447 }
5448 var96 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var95, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
5449 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var96) /* ret on <var_v:AbstractCompilerVisitor>*/;
5450 goto RET_LABEL;
5451 } else {
5452 if (varonce97) {
5453 var98 = varonce97;
5454 } else {
5455 var99 = "unary -";
5456 var100 = 7;
5457 var101 = string__NativeString__to_s_with_length(var99, var100);
5458 var98 = var101;
5459 varonce97 = var98;
5460 }
5461 var102 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var98) /* == on <var_pname:String>*/;
5462 if (var102){
5463 if (varonce103) {
5464 var104 = varonce103;
5465 } else {
5466 var105 = "-";
5467 var106 = 1;
5468 var107 = string__NativeString__to_s_with_length(var105, var106);
5469 var104 = var107;
5470 varonce103 = var104;
5471 }
5472 var108 = 0;
5473 var109 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var108) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5474 var110 = NEW_array__Array(&type_array__Arraykernel__Object);
5475 { /* var110 = array_instance Array[Object] */
5476 var111 = 2;
5477 var112 = NEW_array__NativeArray(var111, &type_array__NativeArraykernel__Object);
5478 ((struct instance_array__NativeArray*)var112)->values[0] = (val*) var104;
5479 ((struct instance_array__NativeArray*)var112)->values[1] = (val*) var109;
5480 ((void (*)(val*, val*, long))(var110->class->vft[COLOR_array__Array__with_native]))(var110, var112, var111) /* with_native on <var110:Array[Object]>*/;
5481 CHECK_NEW_array__Array(var110);
5482 }
5483 var113 = ((val* (*)(val*))(var110->class->vft[COLOR_string__Object__to_s]))(var110) /* to_s on <var110:Array[Object]>*/;
5484 if (var_ret == NULL) {
5485 fprintf(stderr, "Runtime error: %s", "Cast failed");
5486 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1377);
5487 exit(1);
5488 }
5489 var114 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var113, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
5490 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var114) /* ret on <var_v:AbstractCompilerVisitor>*/;
5491 goto RET_LABEL;
5492 } else {
5493 if (varonce115) {
5494 var116 = varonce115;
5495 } else {
5496 var117 = "succ";
5497 var118 = 4;
5498 var119 = string__NativeString__to_s_with_length(var117, var118);
5499 var116 = var119;
5500 varonce115 = var116;
5501 }
5502 var120 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var116) /* == on <var_pname:String>*/;
5503 if (var120){
5504 var121 = 0;
5505 var122 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var121) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5506 if (varonce123) {
5507 var124 = varonce123;
5508 } else {
5509 var125 = "+1";
5510 var126 = 2;
5511 var127 = string__NativeString__to_s_with_length(var125, var126);
5512 var124 = var127;
5513 varonce123 = var124;
5514 }
5515 var128 = NEW_array__Array(&type_array__Arraykernel__Object);
5516 { /* var128 = array_instance Array[Object] */
5517 var129 = 2;
5518 var130 = NEW_array__NativeArray(var129, &type_array__NativeArraykernel__Object);
5519 ((struct instance_array__NativeArray*)var130)->values[0] = (val*) var122;
5520 ((struct instance_array__NativeArray*)var130)->values[1] = (val*) var124;
5521 ((void (*)(val*, val*, long))(var128->class->vft[COLOR_array__Array__with_native]))(var128, var130, var129) /* with_native on <var128:Array[Object]>*/;
5522 CHECK_NEW_array__Array(var128);
5523 }
5524 var131 = ((val* (*)(val*))(var128->class->vft[COLOR_string__Object__to_s]))(var128) /* to_s on <var128:Array[Object]>*/;
5525 if (var_ret == NULL) {
5526 fprintf(stderr, "Runtime error: %s", "Cast failed");
5527 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1380);
5528 exit(1);
5529 }
5530 var132 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var131, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
5531 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var132) /* ret on <var_v:AbstractCompilerVisitor>*/;
5532 goto RET_LABEL;
5533 } else {
5534 if (varonce133) {
5535 var134 = varonce133;
5536 } else {
5537 var135 = "prec";
5538 var136 = 4;
5539 var137 = string__NativeString__to_s_with_length(var135, var136);
5540 var134 = var137;
5541 varonce133 = var134;
5542 }
5543 var138 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var134) /* == on <var_pname:String>*/;
5544 if (var138){
5545 var139 = 0;
5546 var140 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var139) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5547 if (varonce141) {
5548 var142 = varonce141;
5549 } else {
5550 var143 = "-1";
5551 var144 = 2;
5552 var145 = string__NativeString__to_s_with_length(var143, var144);
5553 var142 = var145;
5554 varonce141 = var142;
5555 }
5556 var146 = NEW_array__Array(&type_array__Arraykernel__Object);
5557 { /* var146 = array_instance Array[Object] */
5558 var147 = 2;
5559 var148 = NEW_array__NativeArray(var147, &type_array__NativeArraykernel__Object);
5560 ((struct instance_array__NativeArray*)var148)->values[0] = (val*) var140;
5561 ((struct instance_array__NativeArray*)var148)->values[1] = (val*) var142;
5562 ((void (*)(val*, val*, long))(var146->class->vft[COLOR_array__Array__with_native]))(var146, var148, var147) /* with_native on <var146:Array[Object]>*/;
5563 CHECK_NEW_array__Array(var146);
5564 }
5565 var149 = ((val* (*)(val*))(var146->class->vft[COLOR_string__Object__to_s]))(var146) /* to_s on <var146:Array[Object]>*/;
5566 if (var_ret == NULL) {
5567 fprintf(stderr, "Runtime error: %s", "Cast failed");
5568 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1383);
5569 exit(1);
5570 }
5571 var150 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var149, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
5572 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var150) /* ret on <var_v:AbstractCompilerVisitor>*/;
5573 goto RET_LABEL;
5574 } else {
5575 if (varonce151) {
5576 var152 = varonce151;
5577 } else {
5578 var153 = "*";
5579 var154 = 1;
5580 var155 = string__NativeString__to_s_with_length(var153, var154);
5581 var152 = var155;
5582 varonce151 = var152;
5583 }
5584 var156 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var152) /* == on <var_pname:String>*/;
5585 if (var156){
5586 var157 = 0;
5587 var158 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var157) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5588 if (varonce159) {
5589 var160 = varonce159;
5590 } else {
5591 var161 = " * ";
5592 var162 = 3;
5593 var163 = string__NativeString__to_s_with_length(var161, var162);
5594 var160 = var163;
5595 varonce159 = var160;
5596 }
5597 var164 = 1;
5598 var165 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var164) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5599 var166 = NEW_array__Array(&type_array__Arraykernel__Object);
5600 { /* var166 = array_instance Array[Object] */
5601 var167 = 3;
5602 var168 = NEW_array__NativeArray(var167, &type_array__NativeArraykernel__Object);
5603 ((struct instance_array__NativeArray*)var168)->values[0] = (val*) var158;
5604 ((struct instance_array__NativeArray*)var168)->values[1] = (val*) var160;
5605 ((struct instance_array__NativeArray*)var168)->values[2] = (val*) var165;
5606 ((void (*)(val*, val*, long))(var166->class->vft[COLOR_array__Array__with_native]))(var166, var168, var167) /* with_native on <var166:Array[Object]>*/;
5607 CHECK_NEW_array__Array(var166);
5608 }
5609 var169 = ((val* (*)(val*))(var166->class->vft[COLOR_string__Object__to_s]))(var166) /* to_s on <var166:Array[Object]>*/;
5610 if (var_ret == NULL) {
5611 fprintf(stderr, "Runtime error: %s", "Cast failed");
5612 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1386);
5613 exit(1);
5614 }
5615 var170 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var169, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
5616 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var170) /* ret on <var_v:AbstractCompilerVisitor>*/;
5617 goto RET_LABEL;
5618 } else {
5619 if (varonce171) {
5620 var172 = varonce171;
5621 } else {
5622 var173 = "/";
5623 var174 = 1;
5624 var175 = string__NativeString__to_s_with_length(var173, var174);
5625 var172 = var175;
5626 varonce171 = var172;
5627 }
5628 var176 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var172) /* == on <var_pname:String>*/;
5629 if (var176){
5630 var177 = 0;
5631 var178 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var177) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5632 if (varonce179) {
5633 var180 = varonce179;
5634 } else {
5635 var181 = " / ";
5636 var182 = 3;
5637 var183 = string__NativeString__to_s_with_length(var181, var182);
5638 var180 = var183;
5639 varonce179 = var180;
5640 }
5641 var184 = 1;
5642 var185 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var184) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5643 var186 = NEW_array__Array(&type_array__Arraykernel__Object);
5644 { /* var186 = array_instance Array[Object] */
5645 var187 = 3;
5646 var188 = NEW_array__NativeArray(var187, &type_array__NativeArraykernel__Object);
5647 ((struct instance_array__NativeArray*)var188)->values[0] = (val*) var178;
5648 ((struct instance_array__NativeArray*)var188)->values[1] = (val*) var180;
5649 ((struct instance_array__NativeArray*)var188)->values[2] = (val*) var185;
5650 ((void (*)(val*, val*, long))(var186->class->vft[COLOR_array__Array__with_native]))(var186, var188, var187) /* with_native on <var186:Array[Object]>*/;
5651 CHECK_NEW_array__Array(var186);
5652 }
5653 var189 = ((val* (*)(val*))(var186->class->vft[COLOR_string__Object__to_s]))(var186) /* to_s on <var186:Array[Object]>*/;
5654 if (var_ret == NULL) {
5655 fprintf(stderr, "Runtime error: %s", "Cast failed");
5656 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1389);
5657 exit(1);
5658 }
5659 var190 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var189, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
5660 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var190) /* ret on <var_v:AbstractCompilerVisitor>*/;
5661 goto RET_LABEL;
5662 } else {
5663 if (varonce191) {
5664 var192 = varonce191;
5665 } else {
5666 var193 = "%";
5667 var194 = 1;
5668 var195 = string__NativeString__to_s_with_length(var193, var194);
5669 var192 = var195;
5670 varonce191 = var192;
5671 }
5672 var196 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var192) /* == on <var_pname:String>*/;
5673 if (var196){
5674 var197 = 0;
5675 var198 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var197) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5676 if (varonce199) {
5677 var200 = varonce199;
5678 } else {
5679 var201 = " % ";
5680 var202 = 3;
5681 var203 = string__NativeString__to_s_with_length(var201, var202);
5682 var200 = var203;
5683 varonce199 = var200;
5684 }
5685 var204 = 1;
5686 var205 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var204) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5687 var206 = NEW_array__Array(&type_array__Arraykernel__Object);
5688 { /* var206 = array_instance Array[Object] */
5689 var207 = 3;
5690 var208 = NEW_array__NativeArray(var207, &type_array__NativeArraykernel__Object);
5691 ((struct instance_array__NativeArray*)var208)->values[0] = (val*) var198;
5692 ((struct instance_array__NativeArray*)var208)->values[1] = (val*) var200;
5693 ((struct instance_array__NativeArray*)var208)->values[2] = (val*) var205;
5694 ((void (*)(val*, val*, long))(var206->class->vft[COLOR_array__Array__with_native]))(var206, var208, var207) /* with_native on <var206:Array[Object]>*/;
5695 CHECK_NEW_array__Array(var206);
5696 }
5697 var209 = ((val* (*)(val*))(var206->class->vft[COLOR_string__Object__to_s]))(var206) /* to_s on <var206:Array[Object]>*/;
5698 if (var_ret == NULL) {
5699 fprintf(stderr, "Runtime error: %s", "Cast failed");
5700 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1392);
5701 exit(1);
5702 }
5703 var210 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var209, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
5704 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var210) /* ret on <var_v:AbstractCompilerVisitor>*/;
5705 goto RET_LABEL;
5706 } else {
5707 if (varonce211) {
5708 var212 = varonce211;
5709 } else {
5710 var213 = "lshift";
5711 var214 = 6;
5712 var215 = string__NativeString__to_s_with_length(var213, var214);
5713 var212 = var215;
5714 varonce211 = var212;
5715 }
5716 var216 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var212) /* == on <var_pname:String>*/;
5717 if (var216){
5718 var217 = 0;
5719 var218 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var217) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5720 if (varonce219) {
5721 var220 = varonce219;
5722 } else {
5723 var221 = " << ";
5724 var222 = 4;
5725 var223 = string__NativeString__to_s_with_length(var221, var222);
5726 var220 = var223;
5727 varonce219 = var220;
5728 }
5729 var224 = 1;
5730 var225 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var224) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5731 var226 = NEW_array__Array(&type_array__Arraykernel__Object);
5732 { /* var226 = array_instance Array[Object] */
5733 var227 = 3;
5734 var228 = NEW_array__NativeArray(var227, &type_array__NativeArraykernel__Object);
5735 ((struct instance_array__NativeArray*)var228)->values[0] = (val*) var218;
5736 ((struct instance_array__NativeArray*)var228)->values[1] = (val*) var220;
5737 ((struct instance_array__NativeArray*)var228)->values[2] = (val*) var225;
5738 ((void (*)(val*, val*, long))(var226->class->vft[COLOR_array__Array__with_native]))(var226, var228, var227) /* with_native on <var226:Array[Object]>*/;
5739 CHECK_NEW_array__Array(var226);
5740 }
5741 var229 = ((val* (*)(val*))(var226->class->vft[COLOR_string__Object__to_s]))(var226) /* to_s on <var226:Array[Object]>*/;
5742 if (var_ret == NULL) {
5743 fprintf(stderr, "Runtime error: %s", "Cast failed");
5744 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1395);
5745 exit(1);
5746 }
5747 var230 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var229, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
5748 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var230) /* ret on <var_v:AbstractCompilerVisitor>*/;
5749 goto RET_LABEL;
5750 } else {
5751 if (varonce231) {
5752 var232 = varonce231;
5753 } else {
5754 var233 = "rshift";
5755 var234 = 6;
5756 var235 = string__NativeString__to_s_with_length(var233, var234);
5757 var232 = var235;
5758 varonce231 = var232;
5759 }
5760 var236 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var232) /* == on <var_pname:String>*/;
5761 if (var236){
5762 var237 = 0;
5763 var238 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var237) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5764 if (varonce239) {
5765 var240 = varonce239;
5766 } else {
5767 var241 = " >> ";
5768 var242 = 4;
5769 var243 = string__NativeString__to_s_with_length(var241, var242);
5770 var240 = var243;
5771 varonce239 = var240;
5772 }
5773 var244 = 1;
5774 var245 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var244) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5775 var246 = NEW_array__Array(&type_array__Arraykernel__Object);
5776 { /* var246 = array_instance Array[Object] */
5777 var247 = 3;
5778 var248 = NEW_array__NativeArray(var247, &type_array__NativeArraykernel__Object);
5779 ((struct instance_array__NativeArray*)var248)->values[0] = (val*) var238;
5780 ((struct instance_array__NativeArray*)var248)->values[1] = (val*) var240;
5781 ((struct instance_array__NativeArray*)var248)->values[2] = (val*) var245;
5782 ((void (*)(val*, val*, long))(var246->class->vft[COLOR_array__Array__with_native]))(var246, var248, var247) /* with_native on <var246:Array[Object]>*/;
5783 CHECK_NEW_array__Array(var246);
5784 }
5785 var249 = ((val* (*)(val*))(var246->class->vft[COLOR_string__Object__to_s]))(var246) /* to_s on <var246:Array[Object]>*/;
5786 if (var_ret == NULL) {
5787 fprintf(stderr, "Runtime error: %s", "Cast failed");
5788 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1398);
5789 exit(1);
5790 }
5791 var250 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var249, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
5792 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var250) /* ret on <var_v:AbstractCompilerVisitor>*/;
5793 goto RET_LABEL;
5794 } else {
5795 if (varonce251) {
5796 var252 = varonce251;
5797 } else {
5798 var253 = "==";
5799 var254 = 2;
5800 var255 = string__NativeString__to_s_with_length(var253, var254);
5801 var252 = var255;
5802 varonce251 = var252;
5803 }
5804 var256 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var252) /* == on <var_pname:String>*/;
5805 if (var256){
5806 var257 = 0;
5807 var258 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var257) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5808 var259 = 1;
5809 var260 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var259) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5810 var261 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__equal_test]))(var_v, var258, var260) /* equal_test on <var_v:AbstractCompilerVisitor>*/;
5811 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var261) /* ret on <var_v:AbstractCompilerVisitor>*/;
5812 goto RET_LABEL;
5813 } else {
5814 if (varonce262) {
5815 var263 = varonce262;
5816 } else {
5817 var264 = "!=";
5818 var265 = 2;
5819 var266 = string__NativeString__to_s_with_length(var264, var265);
5820 var263 = var266;
5821 varonce262 = var263;
5822 }
5823 var267 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var263) /* == on <var_pname:String>*/;
5824 if (var267){
5825 var268 = 0;
5826 var269 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var268) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5827 var270 = 1;
5828 var271 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var270) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5829 var272 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__equal_test]))(var_v, var269, var271) /* equal_test on <var_v:AbstractCompilerVisitor>*/;
5830 var_res = var272;
5831 if (varonce273) {
5832 var274 = varonce273;
5833 } else {
5834 var275 = "!";
5835 var276 = 1;
5836 var277 = string__NativeString__to_s_with_length(var275, var276);
5837 var274 = var277;
5838 varonce273 = var274;
5839 }
5840 var278 = NEW_array__Array(&type_array__Arraykernel__Object);
5841 { /* var278 = array_instance Array[Object] */
5842 var279 = 2;
5843 var280 = NEW_array__NativeArray(var279, &type_array__NativeArraykernel__Object);
5844 ((struct instance_array__NativeArray*)var280)->values[0] = (val*) var274;
5845 ((struct instance_array__NativeArray*)var280)->values[1] = (val*) var_res;
5846 ((void (*)(val*, val*, long))(var278->class->vft[COLOR_array__Array__with_native]))(var278, var280, var279) /* with_native on <var278:Array[Object]>*/;
5847 CHECK_NEW_array__Array(var278);
5848 }
5849 var281 = ((val* (*)(val*))(var278->class->vft[COLOR_string__Object__to_s]))(var278) /* to_s on <var278:Array[Object]>*/;
5850 if (var_ret == NULL) {
5851 fprintf(stderr, "Runtime error: %s", "Cast failed");
5852 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1405);
5853 exit(1);
5854 }
5855 var282 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var281, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
5856 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var282) /* ret on <var_v:AbstractCompilerVisitor>*/;
5857 goto RET_LABEL;
5858 } else {
5859 if (varonce283) {
5860 var284 = varonce283;
5861 } else {
5862 var285 = "<";
5863 var286 = 1;
5864 var287 = string__NativeString__to_s_with_length(var285, var286);
5865 var284 = var287;
5866 varonce283 = var284;
5867 }
5868 var288 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var284) /* == on <var_pname:String>*/;
5869 if (var288){
5870 var289 = 0;
5871 var290 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var289) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5872 if (varonce291) {
5873 var292 = varonce291;
5874 } else {
5875 var293 = " < ";
5876 var294 = 3;
5877 var295 = string__NativeString__to_s_with_length(var293, var294);
5878 var292 = var295;
5879 varonce291 = var292;
5880 }
5881 var296 = 1;
5882 var297 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var296) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5883 var298 = NEW_array__Array(&type_array__Arraykernel__Object);
5884 { /* var298 = array_instance Array[Object] */
5885 var299 = 3;
5886 var300 = NEW_array__NativeArray(var299, &type_array__NativeArraykernel__Object);
5887 ((struct instance_array__NativeArray*)var300)->values[0] = (val*) var290;
5888 ((struct instance_array__NativeArray*)var300)->values[1] = (val*) var292;
5889 ((struct instance_array__NativeArray*)var300)->values[2] = (val*) var297;
5890 ((void (*)(val*, val*, long))(var298->class->vft[COLOR_array__Array__with_native]))(var298, var300, var299) /* with_native on <var298:Array[Object]>*/;
5891 CHECK_NEW_array__Array(var298);
5892 }
5893 var301 = ((val* (*)(val*))(var298->class->vft[COLOR_string__Object__to_s]))(var298) /* to_s on <var298:Array[Object]>*/;
5894 if (var_ret == NULL) {
5895 fprintf(stderr, "Runtime error: %s", "Cast failed");
5896 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1408);
5897 exit(1);
5898 }
5899 var302 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var301, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
5900 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var302) /* ret on <var_v:AbstractCompilerVisitor>*/;
5901 goto RET_LABEL;
5902 } else {
5903 if (varonce303) {
5904 var304 = varonce303;
5905 } else {
5906 var305 = ">";
5907 var306 = 1;
5908 var307 = string__NativeString__to_s_with_length(var305, var306);
5909 var304 = var307;
5910 varonce303 = var304;
5911 }
5912 var308 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var304) /* == on <var_pname:String>*/;
5913 if (var308){
5914 var309 = 0;
5915 var310 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var309) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5916 if (varonce311) {
5917 var312 = varonce311;
5918 } else {
5919 var313 = " > ";
5920 var314 = 3;
5921 var315 = string__NativeString__to_s_with_length(var313, var314);
5922 var312 = var315;
5923 varonce311 = var312;
5924 }
5925 var316 = 1;
5926 var317 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var316) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5927 var318 = NEW_array__Array(&type_array__Arraykernel__Object);
5928 { /* var318 = array_instance Array[Object] */
5929 var319 = 3;
5930 var320 = NEW_array__NativeArray(var319, &type_array__NativeArraykernel__Object);
5931 ((struct instance_array__NativeArray*)var320)->values[0] = (val*) var310;
5932 ((struct instance_array__NativeArray*)var320)->values[1] = (val*) var312;
5933 ((struct instance_array__NativeArray*)var320)->values[2] = (val*) var317;
5934 ((void (*)(val*, val*, long))(var318->class->vft[COLOR_array__Array__with_native]))(var318, var320, var319) /* with_native on <var318:Array[Object]>*/;
5935 CHECK_NEW_array__Array(var318);
5936 }
5937 var321 = ((val* (*)(val*))(var318->class->vft[COLOR_string__Object__to_s]))(var318) /* to_s on <var318:Array[Object]>*/;
5938 if (var_ret == NULL) {
5939 fprintf(stderr, "Runtime error: %s", "Cast failed");
5940 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1411);
5941 exit(1);
5942 }
5943 var322 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var321, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
5944 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var322) /* ret on <var_v:AbstractCompilerVisitor>*/;
5945 goto RET_LABEL;
5946 } else {
5947 if (varonce323) {
5948 var324 = varonce323;
5949 } else {
5950 var325 = "<=";
5951 var326 = 2;
5952 var327 = string__NativeString__to_s_with_length(var325, var326);
5953 var324 = var327;
5954 varonce323 = var324;
5955 }
5956 var328 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var324) /* == on <var_pname:String>*/;
5957 if (var328){
5958 var329 = 0;
5959 var330 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var329) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5960 if (varonce331) {
5961 var332 = varonce331;
5962 } else {
5963 var333 = " <= ";
5964 var334 = 4;
5965 var335 = string__NativeString__to_s_with_length(var333, var334);
5966 var332 = var335;
5967 varonce331 = var332;
5968 }
5969 var336 = 1;
5970 var337 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var336) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
5971 var338 = NEW_array__Array(&type_array__Arraykernel__Object);
5972 { /* var338 = array_instance Array[Object] */
5973 var339 = 3;
5974 var340 = NEW_array__NativeArray(var339, &type_array__NativeArraykernel__Object);
5975 ((struct instance_array__NativeArray*)var340)->values[0] = (val*) var330;
5976 ((struct instance_array__NativeArray*)var340)->values[1] = (val*) var332;
5977 ((struct instance_array__NativeArray*)var340)->values[2] = (val*) var337;
5978 ((void (*)(val*, val*, long))(var338->class->vft[COLOR_array__Array__with_native]))(var338, var340, var339) /* with_native on <var338:Array[Object]>*/;
5979 CHECK_NEW_array__Array(var338);
5980 }
5981 var341 = ((val* (*)(val*))(var338->class->vft[COLOR_string__Object__to_s]))(var338) /* to_s on <var338:Array[Object]>*/;
5982 if (var_ret == NULL) {
5983 fprintf(stderr, "Runtime error: %s", "Cast failed");
5984 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1414);
5985 exit(1);
5986 }
5987 var342 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var341, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
5988 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var342) /* ret on <var_v:AbstractCompilerVisitor>*/;
5989 goto RET_LABEL;
5990 } else {
5991 if (varonce343) {
5992 var344 = varonce343;
5993 } else {
5994 var345 = ">=";
5995 var346 = 2;
5996 var347 = string__NativeString__to_s_with_length(var345, var346);
5997 var344 = var347;
5998 varonce343 = var344;
5999 }
6000 var348 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var344) /* == on <var_pname:String>*/;
6001 if (var348){
6002 var349 = 0;
6003 var350 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var349) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6004 if (varonce351) {
6005 var352 = varonce351;
6006 } else {
6007 var353 = " >= ";
6008 var354 = 4;
6009 var355 = string__NativeString__to_s_with_length(var353, var354);
6010 var352 = var355;
6011 varonce351 = var352;
6012 }
6013 var356 = 1;
6014 var357 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var356) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6015 var358 = NEW_array__Array(&type_array__Arraykernel__Object);
6016 { /* var358 = array_instance Array[Object] */
6017 var359 = 3;
6018 var360 = NEW_array__NativeArray(var359, &type_array__NativeArraykernel__Object);
6019 ((struct instance_array__NativeArray*)var360)->values[0] = (val*) var350;
6020 ((struct instance_array__NativeArray*)var360)->values[1] = (val*) var352;
6021 ((struct instance_array__NativeArray*)var360)->values[2] = (val*) var357;
6022 ((void (*)(val*, val*, long))(var358->class->vft[COLOR_array__Array__with_native]))(var358, var360, var359) /* with_native on <var358:Array[Object]>*/;
6023 CHECK_NEW_array__Array(var358);
6024 }
6025 var361 = ((val* (*)(val*))(var358->class->vft[COLOR_string__Object__to_s]))(var358) /* to_s on <var358:Array[Object]>*/;
6026 if (var_ret == NULL) {
6027 fprintf(stderr, "Runtime error: %s", "Cast failed");
6028 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1417);
6029 exit(1);
6030 }
6031 var362 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var361, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
6032 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var362) /* ret on <var_v:AbstractCompilerVisitor>*/;
6033 goto RET_LABEL;
6034 } else {
6035 if (varonce363) {
6036 var364 = varonce363;
6037 } else {
6038 var365 = "to_f";
6039 var366 = 4;
6040 var367 = string__NativeString__to_s_with_length(var365, var366);
6041 var364 = var367;
6042 varonce363 = var364;
6043 }
6044 var368 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var364) /* == on <var_pname:String>*/;
6045 if (var368){
6046 if (varonce369) {
6047 var370 = varonce369;
6048 } else {
6049 var371 = "(double)";
6050 var372 = 8;
6051 var373 = string__NativeString__to_s_with_length(var371, var372);
6052 var370 = var373;
6053 varonce369 = var370;
6054 }
6055 var374 = 0;
6056 var375 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var374) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6057 var376 = NEW_array__Array(&type_array__Arraykernel__Object);
6058 { /* var376 = array_instance Array[Object] */
6059 var377 = 2;
6060 var378 = NEW_array__NativeArray(var377, &type_array__NativeArraykernel__Object);
6061 ((struct instance_array__NativeArray*)var378)->values[0] = (val*) var370;
6062 ((struct instance_array__NativeArray*)var378)->values[1] = (val*) var375;
6063 ((void (*)(val*, val*, long))(var376->class->vft[COLOR_array__Array__with_native]))(var376, var378, var377) /* with_native on <var376:Array[Object]>*/;
6064 CHECK_NEW_array__Array(var376);
6065 }
6066 var379 = ((val* (*)(val*))(var376->class->vft[COLOR_string__Object__to_s]))(var376) /* to_s on <var376:Array[Object]>*/;
6067 if (var_ret == NULL) {
6068 fprintf(stderr, "Runtime error: %s", "Cast failed");
6069 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1420);
6070 exit(1);
6071 }
6072 var380 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var379, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
6073 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var380) /* ret on <var_v:AbstractCompilerVisitor>*/;
6074 goto RET_LABEL;
6075 } else {
6076 if (varonce381) {
6077 var382 = varonce381;
6078 } else {
6079 var383 = "ascii";
6080 var384 = 5;
6081 var385 = string__NativeString__to_s_with_length(var383, var384);
6082 var382 = var385;
6083 varonce381 = var382;
6084 }
6085 var386 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var382) /* == on <var_pname:String>*/;
6086 if (var386){
6087 var387 = 0;
6088 var388 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var387) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6089 var389 = NEW_array__Array(&type_array__Arraykernel__Object);
6090 { /* var389 = array_instance Array[Object] */
6091 var390 = 1;
6092 var391 = NEW_array__NativeArray(var390, &type_array__NativeArraykernel__Object);
6093 ((struct instance_array__NativeArray*)var391)->values[0] = (val*) var388;
6094 ((void (*)(val*, val*, long))(var389->class->vft[COLOR_array__Array__with_native]))(var389, var391, var390) /* with_native on <var389:Array[Object]>*/;
6095 CHECK_NEW_array__Array(var389);
6096 }
6097 var392 = ((val* (*)(val*))(var389->class->vft[COLOR_string__Object__to_s]))(var389) /* to_s on <var389:Array[Object]>*/;
6098 if (var_ret == NULL) {
6099 fprintf(stderr, "Runtime error: %s", "Cast failed");
6100 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1423);
6101 exit(1);
6102 }
6103 var393 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var392, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
6104 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var393) /* ret on <var_v:AbstractCompilerVisitor>*/;
6105 goto RET_LABEL;
6106 } else {
6107 }
6108 }
6109 }
6110 }
6111 }
6112 }
6113 }
6114 }
6115 }
6116 }
6117 }
6118 }
6119 }
6120 }
6121 }
6122 }
6123 }
6124 }
6125 }
6126 }
6127 } else {
6128 if (varonce394) {
6129 var395 = varonce394;
6130 } else {
6131 var396 = "Char";
6132 var397 = 4;
6133 var398 = string__NativeString__to_s_with_length(var396, var397);
6134 var395 = var398;
6135 varonce394 = var395;
6136 }
6137 var399 = ((short int (*)(val*, val*))(var_cname->class->vft[COLOR_kernel__Object___61d_61d]))(var_cname, var395) /* == on <var_cname:String>*/;
6138 if (var399){
6139 if (varonce400) {
6140 var401 = varonce400;
6141 } else {
6142 var402 = "output";
6143 var403 = 6;
6144 var404 = string__NativeString__to_s_with_length(var402, var403);
6145 var401 = var404;
6146 varonce400 = var401;
6147 }
6148 var405 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var401) /* == on <var_pname:String>*/;
6149 if (var405){
6150 if (varonce406) {
6151 var407 = varonce406;
6152 } else {
6153 var408 = "printf(\"%c\", ";
6154 var409 = 13;
6155 var410 = string__NativeString__to_s_with_length(var408, var409);
6156 var407 = var410;
6157 varonce406 = var407;
6158 }
6159 var411 = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__first]))(var_arguments) /* first on <var_arguments:Array[RuntimeVariable]>*/;
6160 if (varonce412) {
6161 var413 = varonce412;
6162 } else {
6163 var414 = ");";
6164 var415 = 2;
6165 var416 = string__NativeString__to_s_with_length(var414, var415);
6166 var413 = var416;
6167 varonce412 = var413;
6168 }
6169 var417 = NEW_array__Array(&type_array__Arraykernel__Object);
6170 { /* var417 = array_instance Array[Object] */
6171 var418 = 3;
6172 var419 = NEW_array__NativeArray(var418, &type_array__NativeArraykernel__Object);
6173 ((struct instance_array__NativeArray*)var419)->values[0] = (val*) var407;
6174 ((struct instance_array__NativeArray*)var419)->values[1] = (val*) var411;
6175 ((struct instance_array__NativeArray*)var419)->values[2] = (val*) var413;
6176 ((void (*)(val*, val*, long))(var417->class->vft[COLOR_array__Array__with_native]))(var417, var419, var418) /* with_native on <var417:Array[Object]>*/;
6177 CHECK_NEW_array__Array(var417);
6178 }
6179 var420 = ((val* (*)(val*))(var417->class->vft[COLOR_string__Object__to_s]))(var417) /* to_s on <var417:Array[Object]>*/;
6180 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var420) /* add on <var_v:AbstractCompilerVisitor>*/;
6181 goto RET_LABEL;
6182 } else {
6183 if (varonce421) {
6184 var422 = varonce421;
6185 } else {
6186 var423 = "object_id";
6187 var424 = 9;
6188 var425 = string__NativeString__to_s_with_length(var423, var424);
6189 var422 = var425;
6190 varonce421 = var422;
6191 }
6192 var426 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var422) /* == on <var_pname:String>*/;
6193 if (var426){
6194 if (varonce427) {
6195 var428 = varonce427;
6196 } else {
6197 var429 = "(long)";
6198 var430 = 6;
6199 var431 = string__NativeString__to_s_with_length(var429, var430);
6200 var428 = var431;
6201 varonce427 = var428;
6202 }
6203 var432 = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__first]))(var_arguments) /* first on <var_arguments:Array[RuntimeVariable]>*/;
6204 var433 = NEW_array__Array(&type_array__Arraykernel__Object);
6205 { /* var433 = array_instance Array[Object] */
6206 var434 = 2;
6207 var435 = NEW_array__NativeArray(var434, &type_array__NativeArraykernel__Object);
6208 ((struct instance_array__NativeArray*)var435)->values[0] = (val*) var428;
6209 ((struct instance_array__NativeArray*)var435)->values[1] = (val*) var432;
6210 ((void (*)(val*, val*, long))(var433->class->vft[COLOR_array__Array__with_native]))(var433, var435, var434) /* with_native on <var433:Array[Object]>*/;
6211 CHECK_NEW_array__Array(var433);
6212 }
6213 var436 = ((val* (*)(val*))(var433->class->vft[COLOR_string__Object__to_s]))(var433) /* to_s on <var433:Array[Object]>*/;
6214 if (var_ret == NULL) {
6215 fprintf(stderr, "Runtime error: %s", "Cast failed");
6216 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1431);
6217 exit(1);
6218 }
6219 var437 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var436, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
6220 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var437) /* ret on <var_v:AbstractCompilerVisitor>*/;
6221 goto RET_LABEL;
6222 } else {
6223 if (varonce438) {
6224 var439 = varonce438;
6225 } else {
6226 var440 = "+";
6227 var441 = 1;
6228 var442 = string__NativeString__to_s_with_length(var440, var441);
6229 var439 = var442;
6230 varonce438 = var439;
6231 }
6232 var443 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var439) /* == on <var_pname:String>*/;
6233 if (var443){
6234 var444 = 0;
6235 var445 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var444) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6236 if (varonce446) {
6237 var447 = varonce446;
6238 } else {
6239 var448 = " + ";
6240 var449 = 3;
6241 var450 = string__NativeString__to_s_with_length(var448, var449);
6242 var447 = var450;
6243 varonce446 = var447;
6244 }
6245 var451 = 1;
6246 var452 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var451) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6247 var453 = NEW_array__Array(&type_array__Arraykernel__Object);
6248 { /* var453 = array_instance Array[Object] */
6249 var454 = 3;
6250 var455 = NEW_array__NativeArray(var454, &type_array__NativeArraykernel__Object);
6251 ((struct instance_array__NativeArray*)var455)->values[0] = (val*) var445;
6252 ((struct instance_array__NativeArray*)var455)->values[1] = (val*) var447;
6253 ((struct instance_array__NativeArray*)var455)->values[2] = (val*) var452;
6254 ((void (*)(val*, val*, long))(var453->class->vft[COLOR_array__Array__with_native]))(var453, var455, var454) /* with_native on <var453:Array[Object]>*/;
6255 CHECK_NEW_array__Array(var453);
6256 }
6257 var456 = ((val* (*)(val*))(var453->class->vft[COLOR_string__Object__to_s]))(var453) /* to_s on <var453:Array[Object]>*/;
6258 if (var_ret == NULL) {
6259 fprintf(stderr, "Runtime error: %s", "Cast failed");
6260 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1434);
6261 exit(1);
6262 }
6263 var457 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var456, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
6264 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var457) /* ret on <var_v:AbstractCompilerVisitor>*/;
6265 goto RET_LABEL;
6266 } else {
6267 if (varonce458) {
6268 var459 = varonce458;
6269 } else {
6270 var460 = "-";
6271 var461 = 1;
6272 var462 = string__NativeString__to_s_with_length(var460, var461);
6273 var459 = var462;
6274 varonce458 = var459;
6275 }
6276 var463 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var459) /* == on <var_pname:String>*/;
6277 if (var463){
6278 var464 = 0;
6279 var465 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var464) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6280 if (varonce466) {
6281 var467 = varonce466;
6282 } else {
6283 var468 = " - ";
6284 var469 = 3;
6285 var470 = string__NativeString__to_s_with_length(var468, var469);
6286 var467 = var470;
6287 varonce466 = var467;
6288 }
6289 var471 = 1;
6290 var472 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var471) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6291 var473 = NEW_array__Array(&type_array__Arraykernel__Object);
6292 { /* var473 = array_instance Array[Object] */
6293 var474 = 3;
6294 var475 = NEW_array__NativeArray(var474, &type_array__NativeArraykernel__Object);
6295 ((struct instance_array__NativeArray*)var475)->values[0] = (val*) var465;
6296 ((struct instance_array__NativeArray*)var475)->values[1] = (val*) var467;
6297 ((struct instance_array__NativeArray*)var475)->values[2] = (val*) var472;
6298 ((void (*)(val*, val*, long))(var473->class->vft[COLOR_array__Array__with_native]))(var473, var475, var474) /* with_native on <var473:Array[Object]>*/;
6299 CHECK_NEW_array__Array(var473);
6300 }
6301 var476 = ((val* (*)(val*))(var473->class->vft[COLOR_string__Object__to_s]))(var473) /* to_s on <var473:Array[Object]>*/;
6302 if (var_ret == NULL) {
6303 fprintf(stderr, "Runtime error: %s", "Cast failed");
6304 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1437);
6305 exit(1);
6306 }
6307 var477 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var476, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
6308 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var477) /* ret on <var_v:AbstractCompilerVisitor>*/;
6309 goto RET_LABEL;
6310 } else {
6311 if (varonce478) {
6312 var479 = varonce478;
6313 } else {
6314 var480 = "==";
6315 var481 = 2;
6316 var482 = string__NativeString__to_s_with_length(var480, var481);
6317 var479 = var482;
6318 varonce478 = var479;
6319 }
6320 var483 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var479) /* == on <var_pname:String>*/;
6321 if (var483){
6322 var484 = 0;
6323 var485 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var484) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6324 var486 = 1;
6325 var487 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var486) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6326 var488 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__equal_test]))(var_v, var485, var487) /* equal_test on <var_v:AbstractCompilerVisitor>*/;
6327 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var488) /* ret on <var_v:AbstractCompilerVisitor>*/;
6328 goto RET_LABEL;
6329 } else {
6330 if (varonce489) {
6331 var490 = varonce489;
6332 } else {
6333 var491 = "!=";
6334 var492 = 2;
6335 var493 = string__NativeString__to_s_with_length(var491, var492);
6336 var490 = var493;
6337 varonce489 = var490;
6338 }
6339 var494 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var490) /* == on <var_pname:String>*/;
6340 if (var494){
6341 var495 = 0;
6342 var496 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var495) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6343 var497 = 1;
6344 var498 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var497) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6345 var499 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__equal_test]))(var_v, var496, var498) /* equal_test on <var_v:AbstractCompilerVisitor>*/;
6346 var_res500 = var499;
6347 if (varonce501) {
6348 var502 = varonce501;
6349 } else {
6350 var503 = "!";
6351 var504 = 1;
6352 var505 = string__NativeString__to_s_with_length(var503, var504);
6353 var502 = var505;
6354 varonce501 = var502;
6355 }
6356 var506 = NEW_array__Array(&type_array__Arraykernel__Object);
6357 { /* var506 = array_instance Array[Object] */
6358 var507 = 2;
6359 var508 = NEW_array__NativeArray(var507, &type_array__NativeArraykernel__Object);
6360 ((struct instance_array__NativeArray*)var508)->values[0] = (val*) var502;
6361 ((struct instance_array__NativeArray*)var508)->values[1] = (val*) var_res500;
6362 ((void (*)(val*, val*, long))(var506->class->vft[COLOR_array__Array__with_native]))(var506, var508, var507) /* with_native on <var506:Array[Object]>*/;
6363 CHECK_NEW_array__Array(var506);
6364 }
6365 var509 = ((val* (*)(val*))(var506->class->vft[COLOR_string__Object__to_s]))(var506) /* to_s on <var506:Array[Object]>*/;
6366 if (var_ret == NULL) {
6367 fprintf(stderr, "Runtime error: %s", "Cast failed");
6368 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1444);
6369 exit(1);
6370 }
6371 var510 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var509, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
6372 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var510) /* ret on <var_v:AbstractCompilerVisitor>*/;
6373 goto RET_LABEL;
6374 } else {
6375 if (varonce511) {
6376 var512 = varonce511;
6377 } else {
6378 var513 = "succ";
6379 var514 = 4;
6380 var515 = string__NativeString__to_s_with_length(var513, var514);
6381 var512 = var515;
6382 varonce511 = var512;
6383 }
6384 var516 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var512) /* == on <var_pname:String>*/;
6385 if (var516){
6386 var517 = 0;
6387 var518 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var517) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6388 if (varonce519) {
6389 var520 = varonce519;
6390 } else {
6391 var521 = "+1";
6392 var522 = 2;
6393 var523 = string__NativeString__to_s_with_length(var521, var522);
6394 var520 = var523;
6395 varonce519 = var520;
6396 }
6397 var524 = NEW_array__Array(&type_array__Arraykernel__Object);
6398 { /* var524 = array_instance Array[Object] */
6399 var525 = 2;
6400 var526 = NEW_array__NativeArray(var525, &type_array__NativeArraykernel__Object);
6401 ((struct instance_array__NativeArray*)var526)->values[0] = (val*) var518;
6402 ((struct instance_array__NativeArray*)var526)->values[1] = (val*) var520;
6403 ((void (*)(val*, val*, long))(var524->class->vft[COLOR_array__Array__with_native]))(var524, var526, var525) /* with_native on <var524:Array[Object]>*/;
6404 CHECK_NEW_array__Array(var524);
6405 }
6406 var527 = ((val* (*)(val*))(var524->class->vft[COLOR_string__Object__to_s]))(var524) /* to_s on <var524:Array[Object]>*/;
6407 if (var_ret == NULL) {
6408 fprintf(stderr, "Runtime error: %s", "Cast failed");
6409 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1447);
6410 exit(1);
6411 }
6412 var528 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var527, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
6413 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var528) /* ret on <var_v:AbstractCompilerVisitor>*/;
6414 goto RET_LABEL;
6415 } else {
6416 if (varonce529) {
6417 var530 = varonce529;
6418 } else {
6419 var531 = "prec";
6420 var532 = 4;
6421 var533 = string__NativeString__to_s_with_length(var531, var532);
6422 var530 = var533;
6423 varonce529 = var530;
6424 }
6425 var534 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var530) /* == on <var_pname:String>*/;
6426 if (var534){
6427 var535 = 0;
6428 var536 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var535) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6429 if (varonce537) {
6430 var538 = varonce537;
6431 } else {
6432 var539 = "-1";
6433 var540 = 2;
6434 var541 = string__NativeString__to_s_with_length(var539, var540);
6435 var538 = var541;
6436 varonce537 = var538;
6437 }
6438 var542 = NEW_array__Array(&type_array__Arraykernel__Object);
6439 { /* var542 = array_instance Array[Object] */
6440 var543 = 2;
6441 var544 = NEW_array__NativeArray(var543, &type_array__NativeArraykernel__Object);
6442 ((struct instance_array__NativeArray*)var544)->values[0] = (val*) var536;
6443 ((struct instance_array__NativeArray*)var544)->values[1] = (val*) var538;
6444 ((void (*)(val*, val*, long))(var542->class->vft[COLOR_array__Array__with_native]))(var542, var544, var543) /* with_native on <var542:Array[Object]>*/;
6445 CHECK_NEW_array__Array(var542);
6446 }
6447 var545 = ((val* (*)(val*))(var542->class->vft[COLOR_string__Object__to_s]))(var542) /* to_s on <var542:Array[Object]>*/;
6448 if (var_ret == NULL) {
6449 fprintf(stderr, "Runtime error: %s", "Cast failed");
6450 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1450);
6451 exit(1);
6452 }
6453 var546 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var545, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
6454 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var546) /* ret on <var_v:AbstractCompilerVisitor>*/;
6455 goto RET_LABEL;
6456 } else {
6457 if (varonce547) {
6458 var548 = varonce547;
6459 } else {
6460 var549 = "<";
6461 var550 = 1;
6462 var551 = string__NativeString__to_s_with_length(var549, var550);
6463 var548 = var551;
6464 varonce547 = var548;
6465 }
6466 var552 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var548) /* == on <var_pname:String>*/;
6467 if (var552){
6468 var553 = 0;
6469 var554 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var553) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6470 if (varonce555) {
6471 var556 = varonce555;
6472 } else {
6473 var557 = " < ";
6474 var558 = 3;
6475 var559 = string__NativeString__to_s_with_length(var557, var558);
6476 var556 = var559;
6477 varonce555 = var556;
6478 }
6479 var560 = 1;
6480 var561 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var560) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6481 var562 = NEW_array__Array(&type_array__Arraykernel__Object);
6482 { /* var562 = array_instance Array[Object] */
6483 var563 = 3;
6484 var564 = NEW_array__NativeArray(var563, &type_array__NativeArraykernel__Object);
6485 ((struct instance_array__NativeArray*)var564)->values[0] = (val*) var554;
6486 ((struct instance_array__NativeArray*)var564)->values[1] = (val*) var556;
6487 ((struct instance_array__NativeArray*)var564)->values[2] = (val*) var561;
6488 ((void (*)(val*, val*, long))(var562->class->vft[COLOR_array__Array__with_native]))(var562, var564, var563) /* with_native on <var562:Array[Object]>*/;
6489 CHECK_NEW_array__Array(var562);
6490 }
6491 var565 = ((val* (*)(val*))(var562->class->vft[COLOR_string__Object__to_s]))(var562) /* to_s on <var562:Array[Object]>*/;
6492 if (var_ret == NULL) {
6493 fprintf(stderr, "Runtime error: %s", "Cast failed");
6494 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1453);
6495 exit(1);
6496 }
6497 var566 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var565, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
6498 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var566) /* ret on <var_v:AbstractCompilerVisitor>*/;
6499 goto RET_LABEL;
6500 } else {
6501 if (varonce567) {
6502 var568 = varonce567;
6503 } else {
6504 var569 = ">";
6505 var570 = 1;
6506 var571 = string__NativeString__to_s_with_length(var569, var570);
6507 var568 = var571;
6508 varonce567 = var568;
6509 }
6510 var572 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var568) /* == on <var_pname:String>*/;
6511 if (var572){
6512 var573 = 0;
6513 var574 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var573) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6514 if (varonce575) {
6515 var576 = varonce575;
6516 } else {
6517 var577 = " > ";
6518 var578 = 3;
6519 var579 = string__NativeString__to_s_with_length(var577, var578);
6520 var576 = var579;
6521 varonce575 = var576;
6522 }
6523 var580 = 1;
6524 var581 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var580) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6525 var582 = NEW_array__Array(&type_array__Arraykernel__Object);
6526 { /* var582 = array_instance Array[Object] */
6527 var583 = 3;
6528 var584 = NEW_array__NativeArray(var583, &type_array__NativeArraykernel__Object);
6529 ((struct instance_array__NativeArray*)var584)->values[0] = (val*) var574;
6530 ((struct instance_array__NativeArray*)var584)->values[1] = (val*) var576;
6531 ((struct instance_array__NativeArray*)var584)->values[2] = (val*) var581;
6532 ((void (*)(val*, val*, long))(var582->class->vft[COLOR_array__Array__with_native]))(var582, var584, var583) /* with_native on <var582:Array[Object]>*/;
6533 CHECK_NEW_array__Array(var582);
6534 }
6535 var585 = ((val* (*)(val*))(var582->class->vft[COLOR_string__Object__to_s]))(var582) /* to_s on <var582:Array[Object]>*/;
6536 if (var_ret == NULL) {
6537 fprintf(stderr, "Runtime error: %s", "Cast failed");
6538 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1456);
6539 exit(1);
6540 }
6541 var586 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var585, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
6542 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var586) /* ret on <var_v:AbstractCompilerVisitor>*/;
6543 goto RET_LABEL;
6544 } else {
6545 if (varonce587) {
6546 var588 = varonce587;
6547 } else {
6548 var589 = "<=";
6549 var590 = 2;
6550 var591 = string__NativeString__to_s_with_length(var589, var590);
6551 var588 = var591;
6552 varonce587 = var588;
6553 }
6554 var592 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var588) /* == on <var_pname:String>*/;
6555 if (var592){
6556 var593 = 0;
6557 var594 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var593) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6558 if (varonce595) {
6559 var596 = varonce595;
6560 } else {
6561 var597 = " <= ";
6562 var598 = 4;
6563 var599 = string__NativeString__to_s_with_length(var597, var598);
6564 var596 = var599;
6565 varonce595 = var596;
6566 }
6567 var600 = 1;
6568 var601 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var600) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6569 var602 = NEW_array__Array(&type_array__Arraykernel__Object);
6570 { /* var602 = array_instance Array[Object] */
6571 var603 = 3;
6572 var604 = NEW_array__NativeArray(var603, &type_array__NativeArraykernel__Object);
6573 ((struct instance_array__NativeArray*)var604)->values[0] = (val*) var594;
6574 ((struct instance_array__NativeArray*)var604)->values[1] = (val*) var596;
6575 ((struct instance_array__NativeArray*)var604)->values[2] = (val*) var601;
6576 ((void (*)(val*, val*, long))(var602->class->vft[COLOR_array__Array__with_native]))(var602, var604, var603) /* with_native on <var602:Array[Object]>*/;
6577 CHECK_NEW_array__Array(var602);
6578 }
6579 var605 = ((val* (*)(val*))(var602->class->vft[COLOR_string__Object__to_s]))(var602) /* to_s on <var602:Array[Object]>*/;
6580 if (var_ret == NULL) {
6581 fprintf(stderr, "Runtime error: %s", "Cast failed");
6582 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1459);
6583 exit(1);
6584 }
6585 var606 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var605, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
6586 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var606) /* ret on <var_v:AbstractCompilerVisitor>*/;
6587 goto RET_LABEL;
6588 } else {
6589 if (varonce607) {
6590 var608 = varonce607;
6591 } else {
6592 var609 = ">=";
6593 var610 = 2;
6594 var611 = string__NativeString__to_s_with_length(var609, var610);
6595 var608 = var611;
6596 varonce607 = var608;
6597 }
6598 var612 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var608) /* == on <var_pname:String>*/;
6599 if (var612){
6600 var613 = 0;
6601 var614 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var613) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6602 if (varonce615) {
6603 var616 = varonce615;
6604 } else {
6605 var617 = " >= ";
6606 var618 = 4;
6607 var619 = string__NativeString__to_s_with_length(var617, var618);
6608 var616 = var619;
6609 varonce615 = var616;
6610 }
6611 var620 = 1;
6612 var621 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var620) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6613 var622 = NEW_array__Array(&type_array__Arraykernel__Object);
6614 { /* var622 = array_instance Array[Object] */
6615 var623 = 3;
6616 var624 = NEW_array__NativeArray(var623, &type_array__NativeArraykernel__Object);
6617 ((struct instance_array__NativeArray*)var624)->values[0] = (val*) var614;
6618 ((struct instance_array__NativeArray*)var624)->values[1] = (val*) var616;
6619 ((struct instance_array__NativeArray*)var624)->values[2] = (val*) var621;
6620 ((void (*)(val*, val*, long))(var622->class->vft[COLOR_array__Array__with_native]))(var622, var624, var623) /* with_native on <var622:Array[Object]>*/;
6621 CHECK_NEW_array__Array(var622);
6622 }
6623 var625 = ((val* (*)(val*))(var622->class->vft[COLOR_string__Object__to_s]))(var622) /* to_s on <var622:Array[Object]>*/;
6624 if (var_ret == NULL) {
6625 fprintf(stderr, "Runtime error: %s", "Cast failed");
6626 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1462);
6627 exit(1);
6628 }
6629 var626 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var625, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
6630 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var626) /* ret on <var_v:AbstractCompilerVisitor>*/;
6631 goto RET_LABEL;
6632 } else {
6633 if (varonce627) {
6634 var628 = varonce627;
6635 } else {
6636 var629 = "to_i";
6637 var630 = 4;
6638 var631 = string__NativeString__to_s_with_length(var629, var630);
6639 var628 = var631;
6640 varonce627 = var628;
6641 }
6642 var632 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var628) /* == on <var_pname:String>*/;
6643 if (var632){
6644 var633 = 0;
6645 var634 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var633) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6646 if (varonce635) {
6647 var636 = varonce635;
6648 } else {
6649 var637 = "-\'0\'";
6650 var638 = 4;
6651 var639 = string__NativeString__to_s_with_length(var637, var638);
6652 var636 = var639;
6653 varonce635 = var636;
6654 }
6655 var640 = NEW_array__Array(&type_array__Arraykernel__Object);
6656 { /* var640 = array_instance Array[Object] */
6657 var641 = 2;
6658 var642 = NEW_array__NativeArray(var641, &type_array__NativeArraykernel__Object);
6659 ((struct instance_array__NativeArray*)var642)->values[0] = (val*) var634;
6660 ((struct instance_array__NativeArray*)var642)->values[1] = (val*) var636;
6661 ((void (*)(val*, val*, long))(var640->class->vft[COLOR_array__Array__with_native]))(var640, var642, var641) /* with_native on <var640:Array[Object]>*/;
6662 CHECK_NEW_array__Array(var640);
6663 }
6664 var643 = ((val* (*)(val*))(var640->class->vft[COLOR_string__Object__to_s]))(var640) /* to_s on <var640:Array[Object]>*/;
6665 if (var_ret == NULL) {
6666 fprintf(stderr, "Runtime error: %s", "Cast failed");
6667 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1465);
6668 exit(1);
6669 }
6670 var644 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var643, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
6671 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var644) /* ret on <var_v:AbstractCompilerVisitor>*/;
6672 goto RET_LABEL;
6673 } else {
6674 if (varonce645) {
6675 var646 = varonce645;
6676 } else {
6677 var647 = "ascii";
6678 var648 = 5;
6679 var649 = string__NativeString__to_s_with_length(var647, var648);
6680 var646 = var649;
6681 varonce645 = var646;
6682 }
6683 var650 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var646) /* == on <var_pname:String>*/;
6684 if (var650){
6685 if (varonce651) {
6686 var652 = varonce651;
6687 } else {
6688 var653 = "(unsigned char)";
6689 var654 = 15;
6690 var655 = string__NativeString__to_s_with_length(var653, var654);
6691 var652 = var655;
6692 varonce651 = var652;
6693 }
6694 var656 = 0;
6695 var657 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var656) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6696 var658 = NEW_array__Array(&type_array__Arraykernel__Object);
6697 { /* var658 = array_instance Array[Object] */
6698 var659 = 2;
6699 var660 = NEW_array__NativeArray(var659, &type_array__NativeArraykernel__Object);
6700 ((struct instance_array__NativeArray*)var660)->values[0] = (val*) var652;
6701 ((struct instance_array__NativeArray*)var660)->values[1] = (val*) var657;
6702 ((void (*)(val*, val*, long))(var658->class->vft[COLOR_array__Array__with_native]))(var658, var660, var659) /* with_native on <var658:Array[Object]>*/;
6703 CHECK_NEW_array__Array(var658);
6704 }
6705 var661 = ((val* (*)(val*))(var658->class->vft[COLOR_string__Object__to_s]))(var658) /* to_s on <var658:Array[Object]>*/;
6706 if (var_ret == NULL) {
6707 fprintf(stderr, "Runtime error: %s", "Cast failed");
6708 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1468);
6709 exit(1);
6710 }
6711 var662 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var661, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
6712 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var662) /* ret on <var_v:AbstractCompilerVisitor>*/;
6713 goto RET_LABEL;
6714 } else {
6715 }
6716 }
6717 }
6718 }
6719 }
6720 }
6721 }
6722 }
6723 }
6724 }
6725 }
6726 }
6727 }
6728 }
6729 } else {
6730 if (varonce663) {
6731 var664 = varonce663;
6732 } else {
6733 var665 = "Bool";
6734 var666 = 4;
6735 var667 = string__NativeString__to_s_with_length(var665, var666);
6736 var664 = var667;
6737 varonce663 = var664;
6738 }
6739 var668 = ((short int (*)(val*, val*))(var_cname->class->vft[COLOR_kernel__Object___61d_61d]))(var_cname, var664) /* == on <var_cname:String>*/;
6740 if (var668){
6741 if (varonce669) {
6742 var670 = varonce669;
6743 } else {
6744 var671 = "output";
6745 var672 = 6;
6746 var673 = string__NativeString__to_s_with_length(var671, var672);
6747 var670 = var673;
6748 varonce669 = var670;
6749 }
6750 var674 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var670) /* == on <var_pname:String>*/;
6751 if (var674){
6752 if (varonce675) {
6753 var676 = varonce675;
6754 } else {
6755 var677 = "printf(";
6756 var678 = 7;
6757 var679 = string__NativeString__to_s_with_length(var677, var678);
6758 var676 = var679;
6759 varonce675 = var676;
6760 }
6761 var680 = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__first]))(var_arguments) /* first on <var_arguments:Array[RuntimeVariable]>*/;
6762 if (varonce681) {
6763 var682 = varonce681;
6764 } else {
6765 var683 = "?\"true\\n\":\"false\\n\");";
6766 var684 = 21;
6767 var685 = string__NativeString__to_s_with_length(var683, var684);
6768 var682 = var685;
6769 varonce681 = var682;
6770 }
6771 var686 = NEW_array__Array(&type_array__Arraykernel__Object);
6772 { /* var686 = array_instance Array[Object] */
6773 var687 = 3;
6774 var688 = NEW_array__NativeArray(var687, &type_array__NativeArraykernel__Object);
6775 ((struct instance_array__NativeArray*)var688)->values[0] = (val*) var676;
6776 ((struct instance_array__NativeArray*)var688)->values[1] = (val*) var680;
6777 ((struct instance_array__NativeArray*)var688)->values[2] = (val*) var682;
6778 ((void (*)(val*, val*, long))(var686->class->vft[COLOR_array__Array__with_native]))(var686, var688, var687) /* with_native on <var686:Array[Object]>*/;
6779 CHECK_NEW_array__Array(var686);
6780 }
6781 var689 = ((val* (*)(val*))(var686->class->vft[COLOR_string__Object__to_s]))(var686) /* to_s on <var686:Array[Object]>*/;
6782 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var689) /* add on <var_v:AbstractCompilerVisitor>*/;
6783 goto RET_LABEL;
6784 } else {
6785 if (varonce690) {
6786 var691 = varonce690;
6787 } else {
6788 var692 = "object_id";
6789 var693 = 9;
6790 var694 = string__NativeString__to_s_with_length(var692, var693);
6791 var691 = var694;
6792 varonce690 = var691;
6793 }
6794 var695 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var691) /* == on <var_pname:String>*/;
6795 if (var695){
6796 if (varonce696) {
6797 var697 = varonce696;
6798 } else {
6799 var698 = "(long)";
6800 var699 = 6;
6801 var700 = string__NativeString__to_s_with_length(var698, var699);
6802 var697 = var700;
6803 varonce696 = var697;
6804 }
6805 var701 = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__first]))(var_arguments) /* first on <var_arguments:Array[RuntimeVariable]>*/;
6806 var702 = NEW_array__Array(&type_array__Arraykernel__Object);
6807 { /* var702 = array_instance Array[Object] */
6808 var703 = 2;
6809 var704 = NEW_array__NativeArray(var703, &type_array__NativeArraykernel__Object);
6810 ((struct instance_array__NativeArray*)var704)->values[0] = (val*) var697;
6811 ((struct instance_array__NativeArray*)var704)->values[1] = (val*) var701;
6812 ((void (*)(val*, val*, long))(var702->class->vft[COLOR_array__Array__with_native]))(var702, var704, var703) /* with_native on <var702:Array[Object]>*/;
6813 CHECK_NEW_array__Array(var702);
6814 }
6815 var705 = ((val* (*)(val*))(var702->class->vft[COLOR_string__Object__to_s]))(var702) /* to_s on <var702:Array[Object]>*/;
6816 if (var_ret == NULL) {
6817 fprintf(stderr, "Runtime error: %s", "Cast failed");
6818 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1476);
6819 exit(1);
6820 }
6821 var706 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var705, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
6822 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var706) /* ret on <var_v:AbstractCompilerVisitor>*/;
6823 goto RET_LABEL;
6824 } else {
6825 if (varonce707) {
6826 var708 = varonce707;
6827 } else {
6828 var709 = "==";
6829 var710 = 2;
6830 var711 = string__NativeString__to_s_with_length(var709, var710);
6831 var708 = var711;
6832 varonce707 = var708;
6833 }
6834 var712 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var708) /* == on <var_pname:String>*/;
6835 if (var712){
6836 var713 = 0;
6837 var714 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var713) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6838 var715 = 1;
6839 var716 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var715) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6840 var717 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__equal_test]))(var_v, var714, var716) /* equal_test on <var_v:AbstractCompilerVisitor>*/;
6841 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var717) /* ret on <var_v:AbstractCompilerVisitor>*/;
6842 goto RET_LABEL;
6843 } else {
6844 if (varonce718) {
6845 var719 = varonce718;
6846 } else {
6847 var720 = "!=";
6848 var721 = 2;
6849 var722 = string__NativeString__to_s_with_length(var720, var721);
6850 var719 = var722;
6851 varonce718 = var719;
6852 }
6853 var723 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var719) /* == on <var_pname:String>*/;
6854 if (var723){
6855 var724 = 0;
6856 var725 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var724) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6857 var726 = 1;
6858 var727 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var726) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
6859 var728 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__equal_test]))(var_v, var725, var727) /* equal_test on <var_v:AbstractCompilerVisitor>*/;
6860 var_res729 = var728;
6861 if (varonce730) {
6862 var731 = varonce730;
6863 } else {
6864 var732 = "!";
6865 var733 = 1;
6866 var734 = string__NativeString__to_s_with_length(var732, var733);
6867 var731 = var734;
6868 varonce730 = var731;
6869 }
6870 var735 = NEW_array__Array(&type_array__Arraykernel__Object);
6871 { /* var735 = array_instance Array[Object] */
6872 var736 = 2;
6873 var737 = NEW_array__NativeArray(var736, &type_array__NativeArraykernel__Object);
6874 ((struct instance_array__NativeArray*)var737)->values[0] = (val*) var731;
6875 ((struct instance_array__NativeArray*)var737)->values[1] = (val*) var_res729;
6876 ((void (*)(val*, val*, long))(var735->class->vft[COLOR_array__Array__with_native]))(var735, var737, var736) /* with_native on <var735:Array[Object]>*/;
6877 CHECK_NEW_array__Array(var735);
6878 }
6879 var738 = ((val* (*)(val*))(var735->class->vft[COLOR_string__Object__to_s]))(var735) /* to_s on <var735:Array[Object]>*/;
6880 if (var_ret == NULL) {
6881 fprintf(stderr, "Runtime error: %s", "Cast failed");
6882 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1483);
6883 exit(1);
6884 }
6885 var739 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var738, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
6886 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var739) /* ret on <var_v:AbstractCompilerVisitor>*/;
6887 goto RET_LABEL;
6888 } else {
6889 }
6890 }
6891 }
6892 }
6893 } else {
6894 if (varonce740) {
6895 var741 = varonce740;
6896 } else {
6897 var742 = "Float";
6898 var743 = 5;
6899 var744 = string__NativeString__to_s_with_length(var742, var743);
6900 var741 = var744;
6901 varonce740 = var741;
6902 }
6903 var745 = ((short int (*)(val*, val*))(var_cname->class->vft[COLOR_kernel__Object___61d_61d]))(var_cname, var741) /* == on <var_cname:String>*/;
6904 if (var745){
6905 if (varonce746) {
6906 var747 = varonce746;
6907 } else {
6908 var748 = "output";
6909 var749 = 6;
6910 var750 = string__NativeString__to_s_with_length(var748, var749);
6911 var747 = var750;
6912 varonce746 = var747;
6913 }
6914 var751 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var747) /* == on <var_pname:String>*/;
6915 if (var751){
6916 if (varonce752) {
6917 var753 = varonce752;
6918 } else {
6919 var754 = "printf(\"%f\\n\", ";
6920 var755 = 15;
6921 var756 = string__NativeString__to_s_with_length(var754, var755);
6922 var753 = var756;
6923 varonce752 = var753;
6924 }
6925 var757 = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__first]))(var_arguments) /* first on <var_arguments:Array[RuntimeVariable]>*/;
6926 if (varonce758) {
6927 var759 = varonce758;
6928 } else {
6929 var760 = ");";
6930 var761 = 2;
6931 var762 = string__NativeString__to_s_with_length(var760, var761);
6932 var759 = var762;
6933 varonce758 = var759;
6934 }
6935 var763 = NEW_array__Array(&type_array__Arraykernel__Object);
6936 { /* var763 = array_instance Array[Object] */
6937 var764 = 3;
6938 var765 = NEW_array__NativeArray(var764, &type_array__NativeArraykernel__Object);
6939 ((struct instance_array__NativeArray*)var765)->values[0] = (val*) var753;
6940 ((struct instance_array__NativeArray*)var765)->values[1] = (val*) var757;
6941 ((struct instance_array__NativeArray*)var765)->values[2] = (val*) var759;
6942 ((void (*)(val*, val*, long))(var763->class->vft[COLOR_array__Array__with_native]))(var763, var765, var764) /* with_native on <var763:Array[Object]>*/;
6943 CHECK_NEW_array__Array(var763);
6944 }
6945 var766 = ((val* (*)(val*))(var763->class->vft[COLOR_string__Object__to_s]))(var763) /* to_s on <var763:Array[Object]>*/;
6946 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var766) /* add on <var_v:AbstractCompilerVisitor>*/;
6947 goto RET_LABEL;
6948 } else {
6949 if (varonce767) {
6950 var768 = varonce767;
6951 } else {
6952 var769 = "object_id";
6953 var770 = 9;
6954 var771 = string__NativeString__to_s_with_length(var769, var770);
6955 var768 = var771;
6956 varonce767 = var768;
6957 }
6958 var772 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var768) /* == on <var_pname:String>*/;
6959 if (var772){
6960 if (varonce773) {
6961 var774 = varonce773;
6962 } else {
6963 var775 = "(double)";
6964 var776 = 8;
6965 var777 = string__NativeString__to_s_with_length(var775, var776);
6966 var774 = var777;
6967 varonce773 = var774;
6968 }
6969 var778 = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__first]))(var_arguments) /* first on <var_arguments:Array[RuntimeVariable]>*/;
6970 var779 = NEW_array__Array(&type_array__Arraykernel__Object);
6971 { /* var779 = array_instance Array[Object] */
6972 var780 = 2;
6973 var781 = NEW_array__NativeArray(var780, &type_array__NativeArraykernel__Object);
6974 ((struct instance_array__NativeArray*)var781)->values[0] = (val*) var774;
6975 ((struct instance_array__NativeArray*)var781)->values[1] = (val*) var778;
6976 ((void (*)(val*, val*, long))(var779->class->vft[COLOR_array__Array__with_native]))(var779, var781, var780) /* with_native on <var779:Array[Object]>*/;
6977 CHECK_NEW_array__Array(var779);
6978 }
6979 var782 = ((val* (*)(val*))(var779->class->vft[COLOR_string__Object__to_s]))(var779) /* to_s on <var779:Array[Object]>*/;
6980 if (var_ret == NULL) {
6981 fprintf(stderr, "Runtime error: %s", "Cast failed");
6982 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1491);
6983 exit(1);
6984 }
6985 var783 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var782, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
6986 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var783) /* ret on <var_v:AbstractCompilerVisitor>*/;
6987 goto RET_LABEL;
6988 } else {
6989 if (varonce784) {
6990 var785 = varonce784;
6991 } else {
6992 var786 = "+";
6993 var787 = 1;
6994 var788 = string__NativeString__to_s_with_length(var786, var787);
6995 var785 = var788;
6996 varonce784 = var785;
6997 }
6998 var789 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var785) /* == on <var_pname:String>*/;
6999 if (var789){
7000 var790 = 0;
7001 var791 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var790) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7002 if (varonce792) {
7003 var793 = varonce792;
7004 } else {
7005 var794 = " + ";
7006 var795 = 3;
7007 var796 = string__NativeString__to_s_with_length(var794, var795);
7008 var793 = var796;
7009 varonce792 = var793;
7010 }
7011 var797 = 1;
7012 var798 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var797) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7013 var799 = NEW_array__Array(&type_array__Arraykernel__Object);
7014 { /* var799 = array_instance Array[Object] */
7015 var800 = 3;
7016 var801 = NEW_array__NativeArray(var800, &type_array__NativeArraykernel__Object);
7017 ((struct instance_array__NativeArray*)var801)->values[0] = (val*) var791;
7018 ((struct instance_array__NativeArray*)var801)->values[1] = (val*) var793;
7019 ((struct instance_array__NativeArray*)var801)->values[2] = (val*) var798;
7020 ((void (*)(val*, val*, long))(var799->class->vft[COLOR_array__Array__with_native]))(var799, var801, var800) /* with_native on <var799:Array[Object]>*/;
7021 CHECK_NEW_array__Array(var799);
7022 }
7023 var802 = ((val* (*)(val*))(var799->class->vft[COLOR_string__Object__to_s]))(var799) /* to_s on <var799:Array[Object]>*/;
7024 if (var_ret == NULL) {
7025 fprintf(stderr, "Runtime error: %s", "Cast failed");
7026 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1494);
7027 exit(1);
7028 }
7029 var803 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var802, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
7030 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var803) /* ret on <var_v:AbstractCompilerVisitor>*/;
7031 goto RET_LABEL;
7032 } else {
7033 if (varonce804) {
7034 var805 = varonce804;
7035 } else {
7036 var806 = "-";
7037 var807 = 1;
7038 var808 = string__NativeString__to_s_with_length(var806, var807);
7039 var805 = var808;
7040 varonce804 = var805;
7041 }
7042 var809 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var805) /* == on <var_pname:String>*/;
7043 if (var809){
7044 var810 = 0;
7045 var811 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var810) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7046 if (varonce812) {
7047 var813 = varonce812;
7048 } else {
7049 var814 = " - ";
7050 var815 = 3;
7051 var816 = string__NativeString__to_s_with_length(var814, var815);
7052 var813 = var816;
7053 varonce812 = var813;
7054 }
7055 var817 = 1;
7056 var818 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var817) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7057 var819 = NEW_array__Array(&type_array__Arraykernel__Object);
7058 { /* var819 = array_instance Array[Object] */
7059 var820 = 3;
7060 var821 = NEW_array__NativeArray(var820, &type_array__NativeArraykernel__Object);
7061 ((struct instance_array__NativeArray*)var821)->values[0] = (val*) var811;
7062 ((struct instance_array__NativeArray*)var821)->values[1] = (val*) var813;
7063 ((struct instance_array__NativeArray*)var821)->values[2] = (val*) var818;
7064 ((void (*)(val*, val*, long))(var819->class->vft[COLOR_array__Array__with_native]))(var819, var821, var820) /* with_native on <var819:Array[Object]>*/;
7065 CHECK_NEW_array__Array(var819);
7066 }
7067 var822 = ((val* (*)(val*))(var819->class->vft[COLOR_string__Object__to_s]))(var819) /* to_s on <var819:Array[Object]>*/;
7068 if (var_ret == NULL) {
7069 fprintf(stderr, "Runtime error: %s", "Cast failed");
7070 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1497);
7071 exit(1);
7072 }
7073 var823 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var822, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
7074 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var823) /* ret on <var_v:AbstractCompilerVisitor>*/;
7075 goto RET_LABEL;
7076 } else {
7077 if (varonce824) {
7078 var825 = varonce824;
7079 } else {
7080 var826 = "unary -";
7081 var827 = 7;
7082 var828 = string__NativeString__to_s_with_length(var826, var827);
7083 var825 = var828;
7084 varonce824 = var825;
7085 }
7086 var829 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var825) /* == on <var_pname:String>*/;
7087 if (var829){
7088 if (varonce830) {
7089 var831 = varonce830;
7090 } else {
7091 var832 = "-";
7092 var833 = 1;
7093 var834 = string__NativeString__to_s_with_length(var832, var833);
7094 var831 = var834;
7095 varonce830 = var831;
7096 }
7097 var835 = 0;
7098 var836 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var835) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7099 var837 = NEW_array__Array(&type_array__Arraykernel__Object);
7100 { /* var837 = array_instance Array[Object] */
7101 var838 = 2;
7102 var839 = NEW_array__NativeArray(var838, &type_array__NativeArraykernel__Object);
7103 ((struct instance_array__NativeArray*)var839)->values[0] = (val*) var831;
7104 ((struct instance_array__NativeArray*)var839)->values[1] = (val*) var836;
7105 ((void (*)(val*, val*, long))(var837->class->vft[COLOR_array__Array__with_native]))(var837, var839, var838) /* with_native on <var837:Array[Object]>*/;
7106 CHECK_NEW_array__Array(var837);
7107 }
7108 var840 = ((val* (*)(val*))(var837->class->vft[COLOR_string__Object__to_s]))(var837) /* to_s on <var837:Array[Object]>*/;
7109 if (var_ret == NULL) {
7110 fprintf(stderr, "Runtime error: %s", "Cast failed");
7111 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1500);
7112 exit(1);
7113 }
7114 var841 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var840, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
7115 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var841) /* ret on <var_v:AbstractCompilerVisitor>*/;
7116 goto RET_LABEL;
7117 } else {
7118 if (varonce842) {
7119 var843 = varonce842;
7120 } else {
7121 var844 = "succ";
7122 var845 = 4;
7123 var846 = string__NativeString__to_s_with_length(var844, var845);
7124 var843 = var846;
7125 varonce842 = var843;
7126 }
7127 var847 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var843) /* == on <var_pname:String>*/;
7128 if (var847){
7129 var848 = 0;
7130 var849 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var848) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7131 if (varonce850) {
7132 var851 = varonce850;
7133 } else {
7134 var852 = "+1";
7135 var853 = 2;
7136 var854 = string__NativeString__to_s_with_length(var852, var853);
7137 var851 = var854;
7138 varonce850 = var851;
7139 }
7140 var855 = NEW_array__Array(&type_array__Arraykernel__Object);
7141 { /* var855 = array_instance Array[Object] */
7142 var856 = 2;
7143 var857 = NEW_array__NativeArray(var856, &type_array__NativeArraykernel__Object);
7144 ((struct instance_array__NativeArray*)var857)->values[0] = (val*) var849;
7145 ((struct instance_array__NativeArray*)var857)->values[1] = (val*) var851;
7146 ((void (*)(val*, val*, long))(var855->class->vft[COLOR_array__Array__with_native]))(var855, var857, var856) /* with_native on <var855:Array[Object]>*/;
7147 CHECK_NEW_array__Array(var855);
7148 }
7149 var858 = ((val* (*)(val*))(var855->class->vft[COLOR_string__Object__to_s]))(var855) /* to_s on <var855:Array[Object]>*/;
7150 if (var_ret == NULL) {
7151 fprintf(stderr, "Runtime error: %s", "Cast failed");
7152 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1503);
7153 exit(1);
7154 }
7155 var859 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var858, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
7156 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var859) /* ret on <var_v:AbstractCompilerVisitor>*/;
7157 goto RET_LABEL;
7158 } else {
7159 if (varonce860) {
7160 var861 = varonce860;
7161 } else {
7162 var862 = "prec";
7163 var863 = 4;
7164 var864 = string__NativeString__to_s_with_length(var862, var863);
7165 var861 = var864;
7166 varonce860 = var861;
7167 }
7168 var865 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var861) /* == on <var_pname:String>*/;
7169 if (var865){
7170 var866 = 0;
7171 var867 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var866) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7172 if (varonce868) {
7173 var869 = varonce868;
7174 } else {
7175 var870 = "-1";
7176 var871 = 2;
7177 var872 = string__NativeString__to_s_with_length(var870, var871);
7178 var869 = var872;
7179 varonce868 = var869;
7180 }
7181 var873 = NEW_array__Array(&type_array__Arraykernel__Object);
7182 { /* var873 = array_instance Array[Object] */
7183 var874 = 2;
7184 var875 = NEW_array__NativeArray(var874, &type_array__NativeArraykernel__Object);
7185 ((struct instance_array__NativeArray*)var875)->values[0] = (val*) var867;
7186 ((struct instance_array__NativeArray*)var875)->values[1] = (val*) var869;
7187 ((void (*)(val*, val*, long))(var873->class->vft[COLOR_array__Array__with_native]))(var873, var875, var874) /* with_native on <var873:Array[Object]>*/;
7188 CHECK_NEW_array__Array(var873);
7189 }
7190 var876 = ((val* (*)(val*))(var873->class->vft[COLOR_string__Object__to_s]))(var873) /* to_s on <var873:Array[Object]>*/;
7191 if (var_ret == NULL) {
7192 fprintf(stderr, "Runtime error: %s", "Cast failed");
7193 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1506);
7194 exit(1);
7195 }
7196 var877 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var876, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
7197 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var877) /* ret on <var_v:AbstractCompilerVisitor>*/;
7198 goto RET_LABEL;
7199 } else {
7200 if (varonce878) {
7201 var879 = varonce878;
7202 } else {
7203 var880 = "*";
7204 var881 = 1;
7205 var882 = string__NativeString__to_s_with_length(var880, var881);
7206 var879 = var882;
7207 varonce878 = var879;
7208 }
7209 var883 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var879) /* == on <var_pname:String>*/;
7210 if (var883){
7211 var884 = 0;
7212 var885 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var884) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7213 if (varonce886) {
7214 var887 = varonce886;
7215 } else {
7216 var888 = " * ";
7217 var889 = 3;
7218 var890 = string__NativeString__to_s_with_length(var888, var889);
7219 var887 = var890;
7220 varonce886 = var887;
7221 }
7222 var891 = 1;
7223 var892 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var891) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7224 var893 = NEW_array__Array(&type_array__Arraykernel__Object);
7225 { /* var893 = array_instance Array[Object] */
7226 var894 = 3;
7227 var895 = NEW_array__NativeArray(var894, &type_array__NativeArraykernel__Object);
7228 ((struct instance_array__NativeArray*)var895)->values[0] = (val*) var885;
7229 ((struct instance_array__NativeArray*)var895)->values[1] = (val*) var887;
7230 ((struct instance_array__NativeArray*)var895)->values[2] = (val*) var892;
7231 ((void (*)(val*, val*, long))(var893->class->vft[COLOR_array__Array__with_native]))(var893, var895, var894) /* with_native on <var893:Array[Object]>*/;
7232 CHECK_NEW_array__Array(var893);
7233 }
7234 var896 = ((val* (*)(val*))(var893->class->vft[COLOR_string__Object__to_s]))(var893) /* to_s on <var893:Array[Object]>*/;
7235 if (var_ret == NULL) {
7236 fprintf(stderr, "Runtime error: %s", "Cast failed");
7237 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1509);
7238 exit(1);
7239 }
7240 var897 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var896, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
7241 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var897) /* ret on <var_v:AbstractCompilerVisitor>*/;
7242 goto RET_LABEL;
7243 } else {
7244 if (varonce898) {
7245 var899 = varonce898;
7246 } else {
7247 var900 = "/";
7248 var901 = 1;
7249 var902 = string__NativeString__to_s_with_length(var900, var901);
7250 var899 = var902;
7251 varonce898 = var899;
7252 }
7253 var903 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var899) /* == on <var_pname:String>*/;
7254 if (var903){
7255 var904 = 0;
7256 var905 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var904) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7257 if (varonce906) {
7258 var907 = varonce906;
7259 } else {
7260 var908 = " / ";
7261 var909 = 3;
7262 var910 = string__NativeString__to_s_with_length(var908, var909);
7263 var907 = var910;
7264 varonce906 = var907;
7265 }
7266 var911 = 1;
7267 var912 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var911) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7268 var913 = NEW_array__Array(&type_array__Arraykernel__Object);
7269 { /* var913 = array_instance Array[Object] */
7270 var914 = 3;
7271 var915 = NEW_array__NativeArray(var914, &type_array__NativeArraykernel__Object);
7272 ((struct instance_array__NativeArray*)var915)->values[0] = (val*) var905;
7273 ((struct instance_array__NativeArray*)var915)->values[1] = (val*) var907;
7274 ((struct instance_array__NativeArray*)var915)->values[2] = (val*) var912;
7275 ((void (*)(val*, val*, long))(var913->class->vft[COLOR_array__Array__with_native]))(var913, var915, var914) /* with_native on <var913:Array[Object]>*/;
7276 CHECK_NEW_array__Array(var913);
7277 }
7278 var916 = ((val* (*)(val*))(var913->class->vft[COLOR_string__Object__to_s]))(var913) /* to_s on <var913:Array[Object]>*/;
7279 if (var_ret == NULL) {
7280 fprintf(stderr, "Runtime error: %s", "Cast failed");
7281 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1512);
7282 exit(1);
7283 }
7284 var917 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var916, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
7285 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var917) /* ret on <var_v:AbstractCompilerVisitor>*/;
7286 goto RET_LABEL;
7287 } else {
7288 if (varonce918) {
7289 var919 = varonce918;
7290 } else {
7291 var920 = "==";
7292 var921 = 2;
7293 var922 = string__NativeString__to_s_with_length(var920, var921);
7294 var919 = var922;
7295 varonce918 = var919;
7296 }
7297 var923 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var919) /* == on <var_pname:String>*/;
7298 if (var923){
7299 var924 = 0;
7300 var925 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var924) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7301 var926 = 1;
7302 var927 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var926) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7303 var928 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__equal_test]))(var_v, var925, var927) /* equal_test on <var_v:AbstractCompilerVisitor>*/;
7304 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var928) /* ret on <var_v:AbstractCompilerVisitor>*/;
7305 goto RET_LABEL;
7306 } else {
7307 if (varonce929) {
7308 var930 = varonce929;
7309 } else {
7310 var931 = "!=";
7311 var932 = 2;
7312 var933 = string__NativeString__to_s_with_length(var931, var932);
7313 var930 = var933;
7314 varonce929 = var930;
7315 }
7316 var934 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var930) /* == on <var_pname:String>*/;
7317 if (var934){
7318 var935 = 0;
7319 var936 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var935) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7320 var937 = 1;
7321 var938 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var937) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7322 var939 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__equal_test]))(var_v, var936, var938) /* equal_test on <var_v:AbstractCompilerVisitor>*/;
7323 var_res940 = var939;
7324 if (varonce941) {
7325 var942 = varonce941;
7326 } else {
7327 var943 = "!";
7328 var944 = 1;
7329 var945 = string__NativeString__to_s_with_length(var943, var944);
7330 var942 = var945;
7331 varonce941 = var942;
7332 }
7333 var946 = NEW_array__Array(&type_array__Arraykernel__Object);
7334 { /* var946 = array_instance Array[Object] */
7335 var947 = 2;
7336 var948 = NEW_array__NativeArray(var947, &type_array__NativeArraykernel__Object);
7337 ((struct instance_array__NativeArray*)var948)->values[0] = (val*) var942;
7338 ((struct instance_array__NativeArray*)var948)->values[1] = (val*) var_res940;
7339 ((void (*)(val*, val*, long))(var946->class->vft[COLOR_array__Array__with_native]))(var946, var948, var947) /* with_native on <var946:Array[Object]>*/;
7340 CHECK_NEW_array__Array(var946);
7341 }
7342 var949 = ((val* (*)(val*))(var946->class->vft[COLOR_string__Object__to_s]))(var946) /* to_s on <var946:Array[Object]>*/;
7343 if (var_ret == NULL) {
7344 fprintf(stderr, "Runtime error: %s", "Cast failed");
7345 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1519);
7346 exit(1);
7347 }
7348 var950 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var949, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
7349 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var950) /* ret on <var_v:AbstractCompilerVisitor>*/;
7350 goto RET_LABEL;
7351 } else {
7352 if (varonce951) {
7353 var952 = varonce951;
7354 } else {
7355 var953 = "<";
7356 var954 = 1;
7357 var955 = string__NativeString__to_s_with_length(var953, var954);
7358 var952 = var955;
7359 varonce951 = var952;
7360 }
7361 var956 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var952) /* == on <var_pname:String>*/;
7362 if (var956){
7363 var957 = 0;
7364 var958 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var957) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7365 if (varonce959) {
7366 var960 = varonce959;
7367 } else {
7368 var961 = " < ";
7369 var962 = 3;
7370 var963 = string__NativeString__to_s_with_length(var961, var962);
7371 var960 = var963;
7372 varonce959 = var960;
7373 }
7374 var964 = 1;
7375 var965 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var964) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7376 var966 = NEW_array__Array(&type_array__Arraykernel__Object);
7377 { /* var966 = array_instance Array[Object] */
7378 var967 = 3;
7379 var968 = NEW_array__NativeArray(var967, &type_array__NativeArraykernel__Object);
7380 ((struct instance_array__NativeArray*)var968)->values[0] = (val*) var958;
7381 ((struct instance_array__NativeArray*)var968)->values[1] = (val*) var960;
7382 ((struct instance_array__NativeArray*)var968)->values[2] = (val*) var965;
7383 ((void (*)(val*, val*, long))(var966->class->vft[COLOR_array__Array__with_native]))(var966, var968, var967) /* with_native on <var966:Array[Object]>*/;
7384 CHECK_NEW_array__Array(var966);
7385 }
7386 var969 = ((val* (*)(val*))(var966->class->vft[COLOR_string__Object__to_s]))(var966) /* to_s on <var966:Array[Object]>*/;
7387 if (var_ret == NULL) {
7388 fprintf(stderr, "Runtime error: %s", "Cast failed");
7389 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1522);
7390 exit(1);
7391 }
7392 var970 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var969, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
7393 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var970) /* ret on <var_v:AbstractCompilerVisitor>*/;
7394 goto RET_LABEL;
7395 } else {
7396 if (varonce971) {
7397 var972 = varonce971;
7398 } else {
7399 var973 = ">";
7400 var974 = 1;
7401 var975 = string__NativeString__to_s_with_length(var973, var974);
7402 var972 = var975;
7403 varonce971 = var972;
7404 }
7405 var976 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var972) /* == on <var_pname:String>*/;
7406 if (var976){
7407 var977 = 0;
7408 var978 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var977) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7409 if (varonce979) {
7410 var980 = varonce979;
7411 } else {
7412 var981 = " > ";
7413 var982 = 3;
7414 var983 = string__NativeString__to_s_with_length(var981, var982);
7415 var980 = var983;
7416 varonce979 = var980;
7417 }
7418 var984 = 1;
7419 var985 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var984) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7420 var986 = NEW_array__Array(&type_array__Arraykernel__Object);
7421 { /* var986 = array_instance Array[Object] */
7422 var987 = 3;
7423 var988 = NEW_array__NativeArray(var987, &type_array__NativeArraykernel__Object);
7424 ((struct instance_array__NativeArray*)var988)->values[0] = (val*) var978;
7425 ((struct instance_array__NativeArray*)var988)->values[1] = (val*) var980;
7426 ((struct instance_array__NativeArray*)var988)->values[2] = (val*) var985;
7427 ((void (*)(val*, val*, long))(var986->class->vft[COLOR_array__Array__with_native]))(var986, var988, var987) /* with_native on <var986:Array[Object]>*/;
7428 CHECK_NEW_array__Array(var986);
7429 }
7430 var989 = ((val* (*)(val*))(var986->class->vft[COLOR_string__Object__to_s]))(var986) /* to_s on <var986:Array[Object]>*/;
7431 if (var_ret == NULL) {
7432 fprintf(stderr, "Runtime error: %s", "Cast failed");
7433 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1525);
7434 exit(1);
7435 }
7436 var990 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var989, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
7437 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var990) /* ret on <var_v:AbstractCompilerVisitor>*/;
7438 goto RET_LABEL;
7439 } else {
7440 if (varonce991) {
7441 var992 = varonce991;
7442 } else {
7443 var993 = "<=";
7444 var994 = 2;
7445 var995 = string__NativeString__to_s_with_length(var993, var994);
7446 var992 = var995;
7447 varonce991 = var992;
7448 }
7449 var996 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var992) /* == on <var_pname:String>*/;
7450 if (var996){
7451 var997 = 0;
7452 var998 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var997) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7453 if (varonce999) {
7454 var1000 = varonce999;
7455 } else {
7456 var1001 = " <= ";
7457 var1002 = 4;
7458 var1003 = string__NativeString__to_s_with_length(var1001, var1002);
7459 var1000 = var1003;
7460 varonce999 = var1000;
7461 }
7462 var1004 = 1;
7463 var1005 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1004) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7464 var1006 = NEW_array__Array(&type_array__Arraykernel__Object);
7465 { /* var1006 = array_instance Array[Object] */
7466 var1007 = 3;
7467 var1008 = NEW_array__NativeArray(var1007, &type_array__NativeArraykernel__Object);
7468 ((struct instance_array__NativeArray*)var1008)->values[0] = (val*) var998;
7469 ((struct instance_array__NativeArray*)var1008)->values[1] = (val*) var1000;
7470 ((struct instance_array__NativeArray*)var1008)->values[2] = (val*) var1005;
7471 ((void (*)(val*, val*, long))(var1006->class->vft[COLOR_array__Array__with_native]))(var1006, var1008, var1007) /* with_native on <var1006:Array[Object]>*/;
7472 CHECK_NEW_array__Array(var1006);
7473 }
7474 var1009 = ((val* (*)(val*))(var1006->class->vft[COLOR_string__Object__to_s]))(var1006) /* to_s on <var1006:Array[Object]>*/;
7475 if (var_ret == NULL) {
7476 fprintf(stderr, "Runtime error: %s", "Cast failed");
7477 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1528);
7478 exit(1);
7479 }
7480 var1010 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var1009, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
7481 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var1010) /* ret on <var_v:AbstractCompilerVisitor>*/;
7482 goto RET_LABEL;
7483 } else {
7484 if (varonce1011) {
7485 var1012 = varonce1011;
7486 } else {
7487 var1013 = ">=";
7488 var1014 = 2;
7489 var1015 = string__NativeString__to_s_with_length(var1013, var1014);
7490 var1012 = var1015;
7491 varonce1011 = var1012;
7492 }
7493 var1016 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var1012) /* == on <var_pname:String>*/;
7494 if (var1016){
7495 var1017 = 0;
7496 var1018 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1017) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7497 if (varonce1019) {
7498 var1020 = varonce1019;
7499 } else {
7500 var1021 = " >= ";
7501 var1022 = 4;
7502 var1023 = string__NativeString__to_s_with_length(var1021, var1022);
7503 var1020 = var1023;
7504 varonce1019 = var1020;
7505 }
7506 var1024 = 1;
7507 var1025 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1024) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7508 var1026 = NEW_array__Array(&type_array__Arraykernel__Object);
7509 { /* var1026 = array_instance Array[Object] */
7510 var1027 = 3;
7511 var1028 = NEW_array__NativeArray(var1027, &type_array__NativeArraykernel__Object);
7512 ((struct instance_array__NativeArray*)var1028)->values[0] = (val*) var1018;
7513 ((struct instance_array__NativeArray*)var1028)->values[1] = (val*) var1020;
7514 ((struct instance_array__NativeArray*)var1028)->values[2] = (val*) var1025;
7515 ((void (*)(val*, val*, long))(var1026->class->vft[COLOR_array__Array__with_native]))(var1026, var1028, var1027) /* with_native on <var1026:Array[Object]>*/;
7516 CHECK_NEW_array__Array(var1026);
7517 }
7518 var1029 = ((val* (*)(val*))(var1026->class->vft[COLOR_string__Object__to_s]))(var1026) /* to_s on <var1026:Array[Object]>*/;
7519 if (var_ret == NULL) {
7520 fprintf(stderr, "Runtime error: %s", "Cast failed");
7521 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1531);
7522 exit(1);
7523 }
7524 var1030 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var1029, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
7525 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var1030) /* ret on <var_v:AbstractCompilerVisitor>*/;
7526 goto RET_LABEL;
7527 } else {
7528 if (varonce1031) {
7529 var1032 = varonce1031;
7530 } else {
7531 var1033 = "to_i";
7532 var1034 = 4;
7533 var1035 = string__NativeString__to_s_with_length(var1033, var1034);
7534 var1032 = var1035;
7535 varonce1031 = var1032;
7536 }
7537 var1036 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var1032) /* == on <var_pname:String>*/;
7538 if (var1036){
7539 if (varonce1037) {
7540 var1038 = varonce1037;
7541 } else {
7542 var1039 = "(long)";
7543 var1040 = 6;
7544 var1041 = string__NativeString__to_s_with_length(var1039, var1040);
7545 var1038 = var1041;
7546 varonce1037 = var1038;
7547 }
7548 var1042 = 0;
7549 var1043 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1042) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7550 var1044 = NEW_array__Array(&type_array__Arraykernel__Object);
7551 { /* var1044 = array_instance Array[Object] */
7552 var1045 = 2;
7553 var1046 = NEW_array__NativeArray(var1045, &type_array__NativeArraykernel__Object);
7554 ((struct instance_array__NativeArray*)var1046)->values[0] = (val*) var1038;
7555 ((struct instance_array__NativeArray*)var1046)->values[1] = (val*) var1043;
7556 ((void (*)(val*, val*, long))(var1044->class->vft[COLOR_array__Array__with_native]))(var1044, var1046, var1045) /* with_native on <var1044:Array[Object]>*/;
7557 CHECK_NEW_array__Array(var1044);
7558 }
7559 var1047 = ((val* (*)(val*))(var1044->class->vft[COLOR_string__Object__to_s]))(var1044) /* to_s on <var1044:Array[Object]>*/;
7560 if (var_ret == NULL) {
7561 fprintf(stderr, "Runtime error: %s", "Cast failed");
7562 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1534);
7563 exit(1);
7564 }
7565 var1048 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var1047, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
7566 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var1048) /* ret on <var_v:AbstractCompilerVisitor>*/;
7567 goto RET_LABEL;
7568 } else {
7569 }
7570 }
7571 }
7572 }
7573 }
7574 }
7575 }
7576 }
7577 }
7578 }
7579 }
7580 }
7581 }
7582 }
7583 }
7584 }
7585 } else {
7586 if (varonce1049) {
7587 var1050 = varonce1049;
7588 } else {
7589 var1051 = "NativeString";
7590 var1052 = 12;
7591 var1053 = string__NativeString__to_s_with_length(var1051, var1052);
7592 var1050 = var1053;
7593 varonce1049 = var1050;
7594 }
7595 var1054 = ((short int (*)(val*, val*))(var_cname->class->vft[COLOR_kernel__Object___61d_61d]))(var_cname, var1050) /* == on <var_cname:String>*/;
7596 if (var1054){
7597 if (varonce1055) {
7598 var1056 = varonce1055;
7599 } else {
7600 var1057 = "[]";
7601 var1058 = 2;
7602 var1059 = string__NativeString__to_s_with_length(var1057, var1058);
7603 var1056 = var1059;
7604 varonce1055 = var1056;
7605 }
7606 var1060 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var1056) /* == on <var_pname:String>*/;
7607 if (var1060){
7608 var1061 = 0;
7609 var1062 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1061) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7610 if (varonce1063) {
7611 var1064 = varonce1063;
7612 } else {
7613 var1065 = "[";
7614 var1066 = 1;
7615 var1067 = string__NativeString__to_s_with_length(var1065, var1066);
7616 var1064 = var1067;
7617 varonce1063 = var1064;
7618 }
7619 var1068 = 1;
7620 var1069 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1068) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7621 if (varonce1070) {
7622 var1071 = varonce1070;
7623 } else {
7624 var1072 = "]";
7625 var1073 = 1;
7626 var1074 = string__NativeString__to_s_with_length(var1072, var1073);
7627 var1071 = var1074;
7628 varonce1070 = var1071;
7629 }
7630 var1075 = NEW_array__Array(&type_array__Arraykernel__Object);
7631 { /* var1075 = array_instance Array[Object] */
7632 var1076 = 4;
7633 var1077 = NEW_array__NativeArray(var1076, &type_array__NativeArraykernel__Object);
7634 ((struct instance_array__NativeArray*)var1077)->values[0] = (val*) var1062;
7635 ((struct instance_array__NativeArray*)var1077)->values[1] = (val*) var1064;
7636 ((struct instance_array__NativeArray*)var1077)->values[2] = (val*) var1069;
7637 ((struct instance_array__NativeArray*)var1077)->values[3] = (val*) var1071;
7638 ((void (*)(val*, val*, long))(var1075->class->vft[COLOR_array__Array__with_native]))(var1075, var1077, var1076) /* with_native on <var1075:Array[Object]>*/;
7639 CHECK_NEW_array__Array(var1075);
7640 }
7641 var1078 = ((val* (*)(val*))(var1075->class->vft[COLOR_string__Object__to_s]))(var1075) /* to_s on <var1075:Array[Object]>*/;
7642 if (var_ret == NULL) {
7643 fprintf(stderr, "Runtime error: %s", "Cast failed");
7644 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1539);
7645 exit(1);
7646 }
7647 var1079 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var1078, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
7648 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var1079) /* ret on <var_v:AbstractCompilerVisitor>*/;
7649 goto RET_LABEL;
7650 } else {
7651 if (varonce1080) {
7652 var1081 = varonce1080;
7653 } else {
7654 var1082 = "[]=";
7655 var1083 = 3;
7656 var1084 = string__NativeString__to_s_with_length(var1082, var1083);
7657 var1081 = var1084;
7658 varonce1080 = var1081;
7659 }
7660 var1085 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var1081) /* == on <var_pname:String>*/;
7661 if (var1085){
7662 var1086 = 0;
7663 var1087 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1086) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7664 if (varonce1088) {
7665 var1089 = varonce1088;
7666 } else {
7667 var1090 = "[";
7668 var1091 = 1;
7669 var1092 = string__NativeString__to_s_with_length(var1090, var1091);
7670 var1089 = var1092;
7671 varonce1088 = var1089;
7672 }
7673 var1093 = 1;
7674 var1094 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1093) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7675 if (varonce1095) {
7676 var1096 = varonce1095;
7677 } else {
7678 var1097 = "]=";
7679 var1098 = 2;
7680 var1099 = string__NativeString__to_s_with_length(var1097, var1098);
7681 var1096 = var1099;
7682 varonce1095 = var1096;
7683 }
7684 var1100 = 2;
7685 var1101 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1100) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7686 if (varonce1102) {
7687 var1103 = varonce1102;
7688 } else {
7689 var1104 = ";";
7690 var1105 = 1;
7691 var1106 = string__NativeString__to_s_with_length(var1104, var1105);
7692 var1103 = var1106;
7693 varonce1102 = var1103;
7694 }
7695 var1107 = NEW_array__Array(&type_array__Arraykernel__Object);
7696 { /* var1107 = array_instance Array[Object] */
7697 var1108 = 6;
7698 var1109 = NEW_array__NativeArray(var1108, &type_array__NativeArraykernel__Object);
7699 ((struct instance_array__NativeArray*)var1109)->values[0] = (val*) var1087;
7700 ((struct instance_array__NativeArray*)var1109)->values[1] = (val*) var1089;
7701 ((struct instance_array__NativeArray*)var1109)->values[2] = (val*) var1094;
7702 ((struct instance_array__NativeArray*)var1109)->values[3] = (val*) var1096;
7703 ((struct instance_array__NativeArray*)var1109)->values[4] = (val*) var1101;
7704 ((struct instance_array__NativeArray*)var1109)->values[5] = (val*) var1103;
7705 ((void (*)(val*, val*, long))(var1107->class->vft[COLOR_array__Array__with_native]))(var1107, var1109, var1108) /* with_native on <var1107:Array[Object]>*/;
7706 CHECK_NEW_array__Array(var1107);
7707 }
7708 var1110 = ((val* (*)(val*))(var1107->class->vft[COLOR_string__Object__to_s]))(var1107) /* to_s on <var1107:Array[Object]>*/;
7709 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var1110) /* add on <var_v:AbstractCompilerVisitor>*/;
7710 goto RET_LABEL;
7711 } else {
7712 if (varonce1111) {
7713 var1112 = varonce1111;
7714 } else {
7715 var1113 = "copy_to";
7716 var1114 = 7;
7717 var1115 = string__NativeString__to_s_with_length(var1113, var1114);
7718 var1112 = var1115;
7719 varonce1111 = var1112;
7720 }
7721 var1116 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var1112) /* == on <var_pname:String>*/;
7722 if (var1116){
7723 if (varonce1117) {
7724 var1118 = varonce1117;
7725 } else {
7726 var1119 = "memcpy(";
7727 var1120 = 7;
7728 var1121 = string__NativeString__to_s_with_length(var1119, var1120);
7729 var1118 = var1121;
7730 varonce1117 = var1118;
7731 }
7732 var1122 = 1;
7733 var1123 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1122) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7734 if (varonce1124) {
7735 var1125 = varonce1124;
7736 } else {
7737 var1126 = "+";
7738 var1127 = 1;
7739 var1128 = string__NativeString__to_s_with_length(var1126, var1127);
7740 var1125 = var1128;
7741 varonce1124 = var1125;
7742 }
7743 var1129 = 4;
7744 var1130 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1129) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7745 if (varonce1131) {
7746 var1132 = varonce1131;
7747 } else {
7748 var1133 = ",";
7749 var1134 = 1;
7750 var1135 = string__NativeString__to_s_with_length(var1133, var1134);
7751 var1132 = var1135;
7752 varonce1131 = var1132;
7753 }
7754 var1136 = 0;
7755 var1137 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1136) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7756 if (varonce1138) {
7757 var1139 = varonce1138;
7758 } else {
7759 var1140 = "+";
7760 var1141 = 1;
7761 var1142 = string__NativeString__to_s_with_length(var1140, var1141);
7762 var1139 = var1142;
7763 varonce1138 = var1139;
7764 }
7765 var1143 = 3;
7766 var1144 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1143) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7767 if (varonce1145) {
7768 var1146 = varonce1145;
7769 } else {
7770 var1147 = ",";
7771 var1148 = 1;
7772 var1149 = string__NativeString__to_s_with_length(var1147, var1148);
7773 var1146 = var1149;
7774 varonce1145 = var1146;
7775 }
7776 var1150 = 2;
7777 var1151 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1150) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7778 if (varonce1152) {
7779 var1153 = varonce1152;
7780 } else {
7781 var1154 = ");";
7782 var1155 = 2;
7783 var1156 = string__NativeString__to_s_with_length(var1154, var1155);
7784 var1153 = var1156;
7785 varonce1152 = var1153;
7786 }
7787 var1157 = NEW_array__Array(&type_array__Arraykernel__Object);
7788 { /* var1157 = array_instance Array[Object] */
7789 var1158 = 11;
7790 var1159 = NEW_array__NativeArray(var1158, &type_array__NativeArraykernel__Object);
7791 ((struct instance_array__NativeArray*)var1159)->values[0] = (val*) var1118;
7792 ((struct instance_array__NativeArray*)var1159)->values[1] = (val*) var1123;
7793 ((struct instance_array__NativeArray*)var1159)->values[2] = (val*) var1125;
7794 ((struct instance_array__NativeArray*)var1159)->values[3] = (val*) var1130;
7795 ((struct instance_array__NativeArray*)var1159)->values[4] = (val*) var1132;
7796 ((struct instance_array__NativeArray*)var1159)->values[5] = (val*) var1137;
7797 ((struct instance_array__NativeArray*)var1159)->values[6] = (val*) var1139;
7798 ((struct instance_array__NativeArray*)var1159)->values[7] = (val*) var1144;
7799 ((struct instance_array__NativeArray*)var1159)->values[8] = (val*) var1146;
7800 ((struct instance_array__NativeArray*)var1159)->values[9] = (val*) var1151;
7801 ((struct instance_array__NativeArray*)var1159)->values[10] = (val*) var1153;
7802 ((void (*)(val*, val*, long))(var1157->class->vft[COLOR_array__Array__with_native]))(var1157, var1159, var1158) /* with_native on <var1157:Array[Object]>*/;
7803 CHECK_NEW_array__Array(var1157);
7804 }
7805 var1160 = ((val* (*)(val*))(var1157->class->vft[COLOR_string__Object__to_s]))(var1157) /* to_s on <var1157:Array[Object]>*/;
7806 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var1160) /* add on <var_v:AbstractCompilerVisitor>*/;
7807 goto RET_LABEL;
7808 } else {
7809 if (varonce1161) {
7810 var1162 = varonce1161;
7811 } else {
7812 var1163 = "atoi";
7813 var1164 = 4;
7814 var1165 = string__NativeString__to_s_with_length(var1163, var1164);
7815 var1162 = var1165;
7816 varonce1161 = var1162;
7817 }
7818 var1166 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var1162) /* == on <var_pname:String>*/;
7819 if (var1166){
7820 if (varonce1167) {
7821 var1168 = varonce1167;
7822 } else {
7823 var1169 = "atoi(";
7824 var1170 = 5;
7825 var1171 = string__NativeString__to_s_with_length(var1169, var1170);
7826 var1168 = var1171;
7827 varonce1167 = var1168;
7828 }
7829 var1172 = 0;
7830 var1173 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1172) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7831 if (varonce1174) {
7832 var1175 = varonce1174;
7833 } else {
7834 var1176 = ");";
7835 var1177 = 2;
7836 var1178 = string__NativeString__to_s_with_length(var1176, var1177);
7837 var1175 = var1178;
7838 varonce1174 = var1175;
7839 }
7840 var1179 = NEW_array__Array(&type_array__Arraykernel__Object);
7841 { /* var1179 = array_instance Array[Object] */
7842 var1180 = 3;
7843 var1181 = NEW_array__NativeArray(var1180, &type_array__NativeArraykernel__Object);
7844 ((struct instance_array__NativeArray*)var1181)->values[0] = (val*) var1168;
7845 ((struct instance_array__NativeArray*)var1181)->values[1] = (val*) var1173;
7846 ((struct instance_array__NativeArray*)var1181)->values[2] = (val*) var1175;
7847 ((void (*)(val*, val*, long))(var1179->class->vft[COLOR_array__Array__with_native]))(var1179, var1181, var1180) /* with_native on <var1179:Array[Object]>*/;
7848 CHECK_NEW_array__Array(var1179);
7849 }
7850 var1182 = ((val* (*)(val*))(var1179->class->vft[COLOR_string__Object__to_s]))(var1179) /* to_s on <var1179:Array[Object]>*/;
7851 if (var_ret == NULL) {
7852 fprintf(stderr, "Runtime error: %s", "Cast failed");
7853 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1548);
7854 exit(1);
7855 }
7856 var1183 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var1182, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
7857 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var1183) /* ret on <var_v:AbstractCompilerVisitor>*/;
7858 goto RET_LABEL;
7859 } else {
7860 }
7861 }
7862 }
7863 }
7864 } else {
7865 if (varonce1184) {
7866 var1185 = varonce1184;
7867 } else {
7868 var1186 = "NativeArray";
7869 var1187 = 11;
7870 var1188 = string__NativeString__to_s_with_length(var1186, var1187);
7871 var1185 = var1188;
7872 varonce1184 = var1185;
7873 }
7874 var1189 = ((short int (*)(val*, val*))(var_cname->class->vft[COLOR_kernel__Object___61d_61d]))(var_cname, var1185) /* == on <var_cname:String>*/;
7875 if (var1189){
7876 ((void (*)(val*, val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__native_array_def]))(var_v, var_pname, var_ret, var_arguments) /* native_array_def on <var_v:AbstractCompilerVisitor>*/;
7877 goto RET_LABEL;
7878 } else {
7879 }
7880 }
7881 }
7882 }
7883 }
7884 }
7885 if (varonce1190) {
7886 var1191 = varonce1190;
7887 } else {
7888 var1192 = "exit";
7889 var1193 = 4;
7890 var1194 = string__NativeString__to_s_with_length(var1192, var1193);
7891 var1191 = var1194;
7892 varonce1190 = var1191;
7893 }
7894 var1195 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var1191) /* == on <var_pname:String>*/;
7895 if (var1195){
7896 if (varonce1196) {
7897 var1197 = varonce1196;
7898 } else {
7899 var1198 = "exit(";
7900 var1199 = 5;
7901 var1200 = string__NativeString__to_s_with_length(var1198, var1199);
7902 var1197 = var1200;
7903 varonce1196 = var1197;
7904 }
7905 var1201 = 1;
7906 var1202 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1201) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7907 if (varonce1203) {
7908 var1204 = varonce1203;
7909 } else {
7910 var1205 = ");";
7911 var1206 = 2;
7912 var1207 = string__NativeString__to_s_with_length(var1205, var1206);
7913 var1204 = var1207;
7914 varonce1203 = var1204;
7915 }
7916 var1208 = NEW_array__Array(&type_array__Arraykernel__Object);
7917 { /* var1208 = array_instance Array[Object] */
7918 var1209 = 3;
7919 var1210 = NEW_array__NativeArray(var1209, &type_array__NativeArraykernel__Object);
7920 ((struct instance_array__NativeArray*)var1210)->values[0] = (val*) var1197;
7921 ((struct instance_array__NativeArray*)var1210)->values[1] = (val*) var1202;
7922 ((struct instance_array__NativeArray*)var1210)->values[2] = (val*) var1204;
7923 ((void (*)(val*, val*, long))(var1208->class->vft[COLOR_array__Array__with_native]))(var1208, var1210, var1209) /* with_native on <var1208:Array[Object]>*/;
7924 CHECK_NEW_array__Array(var1208);
7925 }
7926 var1211 = ((val* (*)(val*))(var1208->class->vft[COLOR_string__Object__to_s]))(var1208) /* to_s on <var1208:Array[Object]>*/;
7927 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var1211) /* add on <var_v:AbstractCompilerVisitor>*/;
7928 goto RET_LABEL;
7929 } else {
7930 if (varonce1212) {
7931 var1213 = varonce1212;
7932 } else {
7933 var1214 = "sys";
7934 var1215 = 3;
7935 var1216 = string__NativeString__to_s_with_length(var1214, var1215);
7936 var1213 = var1216;
7937 varonce1212 = var1213;
7938 }
7939 var1217 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var1213) /* == on <var_pname:String>*/;
7940 if (var1217){
7941 if (varonce1218) {
7942 var1219 = varonce1218;
7943 } else {
7944 var1220 = "glob_sys";
7945 var1221 = 8;
7946 var1222 = string__NativeString__to_s_with_length(var1220, var1221);
7947 var1219 = var1222;
7948 varonce1218 = var1219;
7949 }
7950 if (var_ret == NULL) {
7951 fprintf(stderr, "Runtime error: %s", "Cast failed");
7952 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1559);
7953 exit(1);
7954 }
7955 var1223 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var1219, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
7956 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var1223) /* ret on <var_v:AbstractCompilerVisitor>*/;
7957 goto RET_LABEL;
7958 } else {
7959 if (varonce1224) {
7960 var1225 = varonce1224;
7961 } else {
7962 var1226 = "calloc_string";
7963 var1227 = 13;
7964 var1228 = string__NativeString__to_s_with_length(var1226, var1227);
7965 var1225 = var1228;
7966 varonce1224 = var1225;
7967 }
7968 var1229 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var1225) /* == on <var_pname:String>*/;
7969 if (var1229){
7970 if (varonce1230) {
7971 var1231 = varonce1230;
7972 } else {
7973 var1232 = "(char*)nit_alloc(";
7974 var1233 = 17;
7975 var1234 = string__NativeString__to_s_with_length(var1232, var1233);
7976 var1231 = var1234;
7977 varonce1230 = var1231;
7978 }
7979 var1235 = 1;
7980 var1236 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1235) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
7981 if (varonce1237) {
7982 var1238 = varonce1237;
7983 } else {
7984 var1239 = ")";
7985 var1240 = 1;
7986 var1241 = string__NativeString__to_s_with_length(var1239, var1240);
7987 var1238 = var1241;
7988 varonce1237 = var1238;
7989 }
7990 var1242 = NEW_array__Array(&type_array__Arraykernel__Object);
7991 { /* var1242 = array_instance Array[Object] */
7992 var1243 = 3;
7993 var1244 = NEW_array__NativeArray(var1243, &type_array__NativeArraykernel__Object);
7994 ((struct instance_array__NativeArray*)var1244)->values[0] = (val*) var1231;
7995 ((struct instance_array__NativeArray*)var1244)->values[1] = (val*) var1236;
7996 ((struct instance_array__NativeArray*)var1244)->values[2] = (val*) var1238;
7997 ((void (*)(val*, val*, long))(var1242->class->vft[COLOR_array__Array__with_native]))(var1242, var1244, var1243) /* with_native on <var1242:Array[Object]>*/;
7998 CHECK_NEW_array__Array(var1242);
7999 }
8000 var1245 = ((val* (*)(val*))(var1242->class->vft[COLOR_string__Object__to_s]))(var1242) /* to_s on <var1242:Array[Object]>*/;
8001 if (var_ret == NULL) {
8002 fprintf(stderr, "Runtime error: %s", "Cast failed");
8003 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1562);
8004 exit(1);
8005 }
8006 var1246 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var1245, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
8007 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var1246) /* ret on <var_v:AbstractCompilerVisitor>*/;
8008 goto RET_LABEL;
8009 } else {
8010 if (varonce1247) {
8011 var1248 = varonce1247;
8012 } else {
8013 var1249 = "calloc_array";
8014 var1250 = 12;
8015 var1251 = string__NativeString__to_s_with_length(var1249, var1250);
8016 var1248 = var1251;
8017 varonce1247 = var1248;
8018 }
8019 var1252 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var1248) /* == on <var_pname:String>*/;
8020 if (var1252){
8021 if (var_ret == NULL) {
8022 fprintf(stderr, "Runtime error: %s", "Cast failed");
8023 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1565);
8024 exit(1);
8025 }
8026 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__calloc_array]))(var_v, var_ret, var_arguments) /* calloc_array on <var_v:AbstractCompilerVisitor>*/;
8027 goto RET_LABEL;
8028 } else {
8029 if (varonce1253) {
8030 var1254 = varonce1253;
8031 } else {
8032 var1255 = "object_id";
8033 var1256 = 9;
8034 var1257 = string__NativeString__to_s_with_length(var1255, var1256);
8035 var1254 = var1257;
8036 varonce1253 = var1254;
8037 }
8038 var1258 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var1254) /* == on <var_pname:String>*/;
8039 if (var1258){
8040 if (varonce1259) {
8041 var1260 = varonce1259;
8042 } else {
8043 var1261 = "(long)";
8044 var1262 = 6;
8045 var1263 = string__NativeString__to_s_with_length(var1261, var1262);
8046 var1260 = var1263;
8047 varonce1259 = var1260;
8048 }
8049 var1264 = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__first]))(var_arguments) /* first on <var_arguments:Array[RuntimeVariable]>*/;
8050 var1265 = NEW_array__Array(&type_array__Arraykernel__Object);
8051 { /* var1265 = array_instance Array[Object] */
8052 var1266 = 2;
8053 var1267 = NEW_array__NativeArray(var1266, &type_array__NativeArraykernel__Object);
8054 ((struct instance_array__NativeArray*)var1267)->values[0] = (val*) var1260;
8055 ((struct instance_array__NativeArray*)var1267)->values[1] = (val*) var1264;
8056 ((void (*)(val*, val*, long))(var1265->class->vft[COLOR_array__Array__with_native]))(var1265, var1267, var1266) /* with_native on <var1265:Array[Object]>*/;
8057 CHECK_NEW_array__Array(var1265);
8058 }
8059 var1268 = ((val* (*)(val*))(var1265->class->vft[COLOR_string__Object__to_s]))(var1265) /* to_s on <var1265:Array[Object]>*/;
8060 if (var_ret == NULL) {
8061 fprintf(stderr, "Runtime error: %s", "Cast failed");
8062 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1568);
8063 exit(1);
8064 }
8065 var1269 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var1268, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
8066 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var1269) /* ret on <var_v:AbstractCompilerVisitor>*/;
8067 goto RET_LABEL;
8068 } else {
8069 if (varonce1270) {
8070 var1271 = varonce1270;
8071 } else {
8072 var1272 = "is_same_type";
8073 var1273 = 12;
8074 var1274 = string__NativeString__to_s_with_length(var1272, var1273);
8075 var1271 = var1274;
8076 varonce1270 = var1271;
8077 }
8078 var1275 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var1271) /* == on <var_pname:String>*/;
8079 if (var1275){
8080 var1276 = 0;
8081 var1277 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1276) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
8082 var1278 = 1;
8083 var1279 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1278) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
8084 var1280 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__is_same_type_test]))(var_v, var1277, var1279) /* is_same_type_test on <var_v:AbstractCompilerVisitor>*/;
8085 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var1280) /* ret on <var_v:AbstractCompilerVisitor>*/;
8086 goto RET_LABEL;
8087 } else {
8088 if (varonce1281) {
8089 var1282 = varonce1281;
8090 } else {
8091 var1283 = "is_same_instance";
8092 var1284 = 16;
8093 var1285 = string__NativeString__to_s_with_length(var1283, var1284);
8094 var1282 = var1285;
8095 varonce1281 = var1282;
8096 }
8097 var1286 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var1282) /* == on <var_pname:String>*/;
8098 if (var1286){
8099 var1287 = 0;
8100 var1288 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1287) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
8101 var1289 = 1;
8102 var1290 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1289) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
8103 var1291 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__equal_test]))(var_v, var1288, var1290) /* equal_test on <var_v:AbstractCompilerVisitor>*/;
8104 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var1291) /* ret on <var_v:AbstractCompilerVisitor>*/;
8105 goto RET_LABEL;
8106 } else {
8107 if (varonce1292) {
8108 var1293 = varonce1292;
8109 } else {
8110 var1294 = "output_class_name";
8111 var1295 = 17;
8112 var1296 = string__NativeString__to_s_with_length(var1294, var1295);
8113 var1293 = var1296;
8114 varonce1292 = var1293;
8115 }
8116 var1297 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var1293) /* == on <var_pname:String>*/;
8117 if (var1297){
8118 var1298 = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__first]))(var_arguments) /* first on <var_arguments:Array[RuntimeVariable]>*/;
8119 var1299 = ((val* (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__class_name_string]))(var_v, var1298) /* class_name_string on <var_v:AbstractCompilerVisitor>*/;
8120 var_nat = var1299;
8121 if (varonce1300) {
8122 var1301 = varonce1300;
8123 } else {
8124 var1302 = "printf(\"%s\\n\", ";
8125 var1303 = 15;
8126 var1304 = string__NativeString__to_s_with_length(var1302, var1303);
8127 var1301 = var1304;
8128 varonce1300 = var1301;
8129 }
8130 if (varonce1305) {
8131 var1306 = varonce1305;
8132 } else {
8133 var1307 = ");";
8134 var1308 = 2;
8135 var1309 = string__NativeString__to_s_with_length(var1307, var1308);
8136 var1306 = var1309;
8137 varonce1305 = var1306;
8138 }
8139 var1310 = NEW_array__Array(&type_array__Arraykernel__Object);
8140 { /* var1310 = array_instance Array[Object] */
8141 var1311 = 3;
8142 var1312 = NEW_array__NativeArray(var1311, &type_array__NativeArraykernel__Object);
8143 ((struct instance_array__NativeArray*)var1312)->values[0] = (val*) var1301;
8144 ((struct instance_array__NativeArray*)var1312)->values[1] = (val*) var_nat;
8145 ((struct instance_array__NativeArray*)var1312)->values[2] = (val*) var1306;
8146 ((void (*)(val*, val*, long))(var1310->class->vft[COLOR_array__Array__with_native]))(var1310, var1312, var1311) /* with_native on <var1310:Array[Object]>*/;
8147 CHECK_NEW_array__Array(var1310);
8148 }
8149 var1313 = ((val* (*)(val*))(var1310->class->vft[COLOR_string__Object__to_s]))(var1310) /* to_s on <var1310:Array[Object]>*/;
8150 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var1313) /* add on <var_v:AbstractCompilerVisitor>*/;
8151 goto RET_LABEL;
8152 } else {
8153 if (varonce1314) {
8154 var1315 = varonce1314;
8155 } else {
8156 var1316 = "native_class_name";
8157 var1317 = 17;
8158 var1318 = string__NativeString__to_s_with_length(var1316, var1317);
8159 var1315 = var1318;
8160 varonce1314 = var1315;
8161 }
8162 var1319 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var1315) /* == on <var_pname:String>*/;
8163 if (var1319){
8164 var1320 = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__first]))(var_arguments) /* first on <var_arguments:Array[RuntimeVariable]>*/;
8165 var1321 = ((val* (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__class_name_string]))(var_v, var1320) /* class_name_string on <var_v:AbstractCompilerVisitor>*/;
8166 var_nat1322 = var1321;
8167 if (varonce1323) {
8168 var1324 = varonce1323;
8169 } else {
8170 var1325 = "(char*)";
8171 var1326 = 7;
8172 var1327 = string__NativeString__to_s_with_length(var1325, var1326);
8173 var1324 = var1327;
8174 varonce1323 = var1324;
8175 }
8176 var1328 = NEW_array__Array(&type_array__Arraykernel__Object);
8177 { /* var1328 = array_instance Array[Object] */
8178 var1329 = 2;
8179 var1330 = NEW_array__NativeArray(var1329, &type_array__NativeArraykernel__Object);
8180 ((struct instance_array__NativeArray*)var1330)->values[0] = (val*) var1324;
8181 ((struct instance_array__NativeArray*)var1330)->values[1] = (val*) var_nat1322;
8182 ((void (*)(val*, val*, long))(var1328->class->vft[COLOR_array__Array__with_native]))(var1328, var1330, var1329) /* with_native on <var1328:Array[Object]>*/;
8183 CHECK_NEW_array__Array(var1328);
8184 }
8185 var1331 = ((val* (*)(val*))(var1328->class->vft[COLOR_string__Object__to_s]))(var1328) /* to_s on <var1328:Array[Object]>*/;
8186 if (var_ret == NULL) {
8187 fprintf(stderr, "Runtime error: %s", "Cast failed");
8188 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1582);
8189 exit(1);
8190 }
8191 var1332 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var1331, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
8192 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var1332) /* ret on <var_v:AbstractCompilerVisitor>*/;
8193 goto RET_LABEL;
8194 } else {
8195 if (varonce1333) {
8196 var1334 = varonce1333;
8197 } else {
8198 var1335 = "force_garbage_collection";
8199 var1336 = 24;
8200 var1337 = string__NativeString__to_s_with_length(var1335, var1336);
8201 var1334 = var1337;
8202 varonce1333 = var1334;
8203 }
8204 var1338 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var1334) /* == on <var_pname:String>*/;
8205 if (var1338){
8206 if (varonce1339) {
8207 var1340 = varonce1339;
8208 } else {
8209 var1341 = "nit_gcollect();";
8210 var1342 = 15;
8211 var1343 = string__NativeString__to_s_with_length(var1341, var1342);
8212 var1340 = var1343;
8213 varonce1339 = var1340;
8214 }
8215 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var1340) /* add on <var_v:AbstractCompilerVisitor>*/;
8216 goto RET_LABEL;
8217 } else {
8218 if (varonce1344) {
8219 var1345 = varonce1344;
8220 } else {
8221 var1346 = "native_argc";
8222 var1347 = 11;
8223 var1348 = string__NativeString__to_s_with_length(var1346, var1347);
8224 var1345 = var1348;
8225 varonce1344 = var1345;
8226 }
8227 var1349 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var1345) /* == on <var_pname:String>*/;
8228 if (var1349){
8229 if (varonce1350) {
8230 var1351 = varonce1350;
8231 } else {
8232 var1352 = "glob_argc";
8233 var1353 = 9;
8234 var1354 = string__NativeString__to_s_with_length(var1352, var1353);
8235 var1351 = var1354;
8236 varonce1350 = var1351;
8237 }
8238 if (var_ret == NULL) {
8239 fprintf(stderr, "Runtime error: %s", "Cast failed");
8240 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1588);
8241 exit(1);
8242 }
8243 var1355 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var1351, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
8244 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var1355) /* ret on <var_v:AbstractCompilerVisitor>*/;
8245 goto RET_LABEL;
8246 } else {
8247 if (varonce1356) {
8248 var1357 = varonce1356;
8249 } else {
8250 var1358 = "native_argv";
8251 var1359 = 11;
8252 var1360 = string__NativeString__to_s_with_length(var1358, var1359);
8253 var1357 = var1360;
8254 varonce1356 = var1357;
8255 }
8256 var1361 = ((short int (*)(val*, val*))(var_pname->class->vft[COLOR_kernel__Object___61d_61d]))(var_pname, var1357) /* == on <var_pname:String>*/;
8257 if (var1361){
8258 if (varonce1362) {
8259 var1363 = varonce1362;
8260 } else {
8261 var1364 = "glob_argv[";
8262 var1365 = 10;
8263 var1366 = string__NativeString__to_s_with_length(var1364, var1365);
8264 var1363 = var1366;
8265 varonce1362 = var1363;
8266 }
8267 var1367 = 1;
8268 var1368 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var1367) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
8269 if (varonce1369) {
8270 var1370 = varonce1369;
8271 } else {
8272 var1371 = "]";
8273 var1372 = 1;
8274 var1373 = string__NativeString__to_s_with_length(var1371, var1372);
8275 var1370 = var1373;
8276 varonce1369 = var1370;
8277 }
8278 var1374 = NEW_array__Array(&type_array__Arraykernel__Object);
8279 { /* var1374 = array_instance Array[Object] */
8280 var1375 = 3;
8281 var1376 = NEW_array__NativeArray(var1375, &type_array__NativeArraykernel__Object);
8282 ((struct instance_array__NativeArray*)var1376)->values[0] = (val*) var1363;
8283 ((struct instance_array__NativeArray*)var1376)->values[1] = (val*) var1368;
8284 ((struct instance_array__NativeArray*)var1376)->values[2] = (val*) var1370;
8285 ((void (*)(val*, val*, long))(var1374->class->vft[COLOR_array__Array__with_native]))(var1374, var1376, var1375) /* with_native on <var1374:Array[Object]>*/;
8286 CHECK_NEW_array__Array(var1374);
8287 }
8288 var1377 = ((val* (*)(val*))(var1374->class->vft[COLOR_string__Object__to_s]))(var1374) /* to_s on <var1374:Array[Object]>*/;
8289 if (var_ret == NULL) {
8290 fprintf(stderr, "Runtime error: %s", "Cast failed");
8291 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1591);
8292 exit(1);
8293 }
8294 var1378 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_expr]))(var_v, var1377, var_ret) /* new_expr on <var_v:AbstractCompilerVisitor>*/;
8295 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var1378) /* ret on <var_v:AbstractCompilerVisitor>*/;
8296 goto RET_LABEL;
8297 } else {
8298 }
8299 }
8300 }
8301 }
8302 }
8303 }
8304 }
8305 }
8306 }
8307 }
8308 }
8309 }
8310 if (varonce1379) {
8311 var1380 = varonce1379;
8312 } else {
8313 var1381 = "printf(\"NOT YET IMPLEMENTED ";
8314 var1382 = 28;
8315 var1383 = string__NativeString__to_s_with_length(var1381, var1382);
8316 var1380 = var1383;
8317 varonce1379 = var1380;
8318 }
8319 var1384 = ((val* (*)(val*))(self->class->vft[COLOR_string__Object__class_name]))(self) /* class_name on <self:AInternMethPropdef>*/;
8320 if (varonce1385) {
8321 var1386 = varonce1385;
8322 } else {
8323 var1387 = ":";
8324 var1388 = 1;
8325 var1389 = string__NativeString__to_s_with_length(var1387, var1388);
8326 var1386 = var1389;
8327 varonce1385 = var1386;
8328 }
8329 if (varonce1390) {
8330 var1391 = varonce1390;
8331 } else {
8332 var1392 = " at ";
8333 var1393 = 4;
8334 var1394 = string__NativeString__to_s_with_length(var1392, var1393);
8335 var1391 = var1394;
8336 varonce1390 = var1391;
8337 }
8338 var1395 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__ANode__location]))(self) /* location on <self:AInternMethPropdef>*/;
8339 var1396 = ((val* (*)(val*))(var1395->class->vft[COLOR_string__Object__to_s]))(var1395) /* to_s on <var1395:Location>*/;
8340 if (varonce1397) {
8341 var1398 = varonce1397;
8342 } else {
8343 var1399 = "\\n\");";
8344 var1400 = 5;
8345 var1401 = string__NativeString__to_s_with_length(var1399, var1400);
8346 var1398 = var1401;
8347 varonce1397 = var1398;
8348 }
8349 var1402 = NEW_array__Array(&type_array__Arraykernel__Object);
8350 { /* var1402 = array_instance Array[Object] */
8351 var1403 = 7;
8352 var1404 = NEW_array__NativeArray(var1403, &type_array__NativeArraykernel__Object);
8353 ((struct instance_array__NativeArray*)var1404)->values[0] = (val*) var1380;
8354 ((struct instance_array__NativeArray*)var1404)->values[1] = (val*) var1384;
8355 ((struct instance_array__NativeArray*)var1404)->values[2] = (val*) var1386;
8356 ((struct instance_array__NativeArray*)var1404)->values[3] = (val*) var_mpropdef;
8357 ((struct instance_array__NativeArray*)var1404)->values[4] = (val*) var1391;
8358 ((struct instance_array__NativeArray*)var1404)->values[5] = (val*) var1396;
8359 ((struct instance_array__NativeArray*)var1404)->values[6] = (val*) var1398;
8360 ((void (*)(val*, val*, long))(var1402->class->vft[COLOR_array__Array__with_native]))(var1402, var1404, var1403) /* with_native on <var1402:Array[Object]>*/;
8361 CHECK_NEW_array__Array(var1402);
8362 }
8363 var1405 = ((val* (*)(val*))(var1402->class->vft[COLOR_string__Object__to_s]))(var1402) /* to_s on <var1402:Array[Object]>*/;
8364 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var1405) /* add on <var_v:AbstractCompilerVisitor>*/;
8365 if (varonce1406) {
8366 var1407 = varonce1406;
8367 } else {
8368 var1408 = "Not implemented ";
8369 var1409 = 16;
8370 var1410 = string__NativeString__to_s_with_length(var1408, var1409);
8371 var1407 = var1410;
8372 varonce1406 = var1407;
8373 }
8374 var1411 = NEW_array__Array(&type_array__Arraykernel__Object);
8375 { /* var1411 = array_instance Array[Object] */
8376 var1412 = 2;
8377 var1413 = NEW_array__NativeArray(var1412, &type_array__NativeArraykernel__Object);
8378 ((struct instance_array__NativeArray*)var1413)->values[0] = (val*) var1407;
8379 ((struct instance_array__NativeArray*)var1413)->values[1] = (val*) var_mpropdef;
8380 ((void (*)(val*, val*, long))(var1411->class->vft[COLOR_array__Array__with_native]))(var1411, var1413, var1412) /* with_native on <var1411:Array[Object]>*/;
8381 CHECK_NEW_array__Array(var1411);
8382 }
8383 var1414 = ((val* (*)(val*))(var1411->class->vft[COLOR_string__Object__to_s]))(var1411) /* to_s on <var1411:Array[Object]>*/;
8384 ((void (*)(val*, val*))(self->class->vft[COLOR_parser_nodes__ANode__debug]))(self, var1414) /* debug on <self:AInternMethPropdef>*/;
8385 RET_LABEL:;
8386 }
8387 /* method abstract_compiler#AInternMethPropdef#compile_to_c for (self: Object, AbstractCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */
8388 void VIRTUAL_abstract_compiler__AInternMethPropdef__compile_to_c(val* self, val* p0, val* p1, val* p2) {
8389 abstract_compiler__AInternMethPropdef__compile_to_c(self, p0, p1, p2);
8390 RET_LABEL:;
8391 }
8392 /* method abstract_compiler#AExternMethPropdef#compile_to_c for (self: AExternMethPropdef, AbstractCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */
8393 void abstract_compiler__AExternMethPropdef__compile_to_c(val* self, val* p0, val* p1, val* p2) {
8394 val* var_v /* var v: AbstractCompilerVisitor */;
8395 val* var_mpropdef /* var mpropdef: MMethodDef */;
8396 val* var_arguments /* var arguments: Array[RuntimeVariable] */;
8397 val* var /* : nullable TString */;
8398 val* var_nextern /* var nextern: nullable TString */;
8399 val* var1 /* : null */;
8400 short int var2 /* : Bool */;
8401 static val* varonce;
8402 val* var3 /* : String */;
8403 char* var4 /* : NativeString */;
8404 long var5 /* : Int */;
8405 val* var6 /* : String */;
8406 static val* varonce7;
8407 val* var8 /* : String */;
8408 char* var9 /* : NativeString */;
8409 long var10 /* : Int */;
8410 val* var11 /* : String */;
8411 val* var12 /* : Location */;
8412 val* var13 /* : String */;
8413 static val* varonce14;
8414 val* var15 /* : String */;
8415 char* var16 /* : NativeString */;
8416 long var17 /* : Int */;
8417 val* var18 /* : String */;
8418 val* var19 /* : Array[Object] */;
8419 long var20 /* : Int */;
8420 val* var21 /* : NativeArray[Object] */;
8421 val* var22 /* : String */;
8422 static val* varonce23;
8423 val* var24 /* : String */;
8424 char* var25 /* : NativeString */;
8425 long var26 /* : Int */;
8426 val* var27 /* : String */;
8427 val* var28 /* : String */;
8428 long var29 /* : Int */;
8429 val* var30 /* : String */;
8430 long var31 /* : Int */;
8431 long var32 /* : Int */;
8432 long var33 /* : Int */;
8433 long var35 /* : Int */;
8434 val* var36 /* : String */;
8435 val* var_externname /* var externname: nullable Object */;
8436 val* var37 /* : Location */;
8437 val* var38 /* : nullable SourceFile */;
8438 val* var39 /* : null */;
8439 short int var40 /* : Bool */;
8440 val* var41 /* : Location */;
8441 val* var42 /* : nullable SourceFile */;
8442 val* var43 /* : String */;
8443 val* var_file /* var file: String */;
8444 val* var44 /* : null */;
8445 val* var_res /* var res: nullable RuntimeVariable */;
8446 val* var45 /* : nullable MSignature */;
8447 val* var46 /* : nullable MType */;
8448 val* var_ret /* var ret: nullable MType */;
8449 val* var47 /* : null */;
8450 short int var48 /* : Bool */;
8451 val* var49 /* : nullable Object */;
8452 val* var50 /* : MType */;
8453 val* var51 /* : RuntimeVariable */;
8454 val* var52 /* : null */;
8455 short int var53 /* : Bool */;
8456 static val* varonce54;
8457 val* var55 /* : String */;
8458 char* var56 /* : NativeString */;
8459 long var57 /* : Int */;
8460 val* var58 /* : String */;
8461 static val* varonce59;
8462 val* var60 /* : String */;
8463 char* var61 /* : NativeString */;
8464 long var62 /* : Int */;
8465 val* var63 /* : String */;
8466 val* var64 /* : String */;
8467 static val* varonce65;
8468 val* var66 /* : String */;
8469 char* var67 /* : NativeString */;
8470 long var68 /* : Int */;
8471 val* var69 /* : String */;
8472 val* var70 /* : Array[Object] */;
8473 long var71 /* : Int */;
8474 val* var72 /* : NativeArray[Object] */;
8475 val* var73 /* : String */;
8476 static val* varonce74;
8477 val* var75 /* : String */;
8478 char* var76 /* : NativeString */;
8479 long var77 /* : Int */;
8480 val* var78 /* : String */;
8481 static val* varonce79;
8482 val* var80 /* : String */;
8483 char* var81 /* : NativeString */;
8484 long var82 /* : Int */;
8485 val* var83 /* : String */;
8486 static val* varonce84;
8487 val* var85 /* : String */;
8488 char* var86 /* : NativeString */;
8489 long var87 /* : Int */;
8490 val* var88 /* : String */;
8491 val* var89 /* : String */;
8492 static val* varonce90;
8493 val* var91 /* : String */;
8494 char* var92 /* : NativeString */;
8495 long var93 /* : Int */;
8496 val* var94 /* : String */;
8497 val* var95 /* : Array[Object] */;
8498 long var96 /* : Int */;
8499 val* var97 /* : NativeArray[Object] */;
8500 val* var98 /* : String */;
8501 var_v = p0;
8502 var_mpropdef = p1;
8503 var_arguments = p2;
8504 var = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__AExternPropdef__n_extern]))(self) /* n_extern on <self:AExternMethPropdef>*/;
8505 var_nextern = var;
8506 var1 = NULL;
8507 if (var_nextern == NULL) {
8508 var2 = 1; /* is null */
8509 } else {
8510 var2 = 0; /* arg is null but recv is not */
8511 }
8512 if (var2){
8513 if (varonce) {
8514 var3 = varonce;
8515 } else {
8516 var4 = "fprintf(stderr, \"NOT YET IMPLEMENTED nitni for ";
8517 var5 = 47;
8518 var6 = string__NativeString__to_s_with_length(var4, var5);
8519 var3 = var6;
8520 varonce = var3;
8521 }
8522 if (varonce7) {
8523 var8 = varonce7;
8524 } else {
8525 var9 = " at ";
8526 var10 = 4;
8527 var11 = string__NativeString__to_s_with_length(var9, var10);
8528 var8 = var11;
8529 varonce7 = var8;
8530 }
8531 var12 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__ANode__location]))(self) /* location on <self:AExternMethPropdef>*/;
8532 var13 = ((val* (*)(val*))(var12->class->vft[COLOR_string__Object__to_s]))(var12) /* to_s on <var12:Location>*/;
8533 if (varonce14) {
8534 var15 = varonce14;
8535 } else {
8536 var16 = "\\n\");";
8537 var17 = 5;
8538 var18 = string__NativeString__to_s_with_length(var16, var17);
8539 var15 = var18;
8540 varonce14 = var15;
8541 }
8542 var19 = NEW_array__Array(&type_array__Arraykernel__Object);
8543 { /* var19 = array_instance Array[Object] */
8544 var20 = 5;
8545 var21 = NEW_array__NativeArray(var20, &type_array__NativeArraykernel__Object);
8546 ((struct instance_array__NativeArray*)var21)->values[0] = (val*) var3;
8547 ((struct instance_array__NativeArray*)var21)->values[1] = (val*) var_mpropdef;
8548 ((struct instance_array__NativeArray*)var21)->values[2] = (val*) var8;
8549 ((struct instance_array__NativeArray*)var21)->values[3] = (val*) var13;
8550 ((struct instance_array__NativeArray*)var21)->values[4] = (val*) var15;
8551 ((void (*)(val*, val*, long))(var19->class->vft[COLOR_array__Array__with_native]))(var19, var21, var20) /* with_native on <var19:Array[Object]>*/;
8552 CHECK_NEW_array__Array(var19);
8553 }
8554 var22 = ((val* (*)(val*))(var19->class->vft[COLOR_string__Object__to_s]))(var19) /* to_s on <var19:Array[Object]>*/;
8555 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var22) /* add on <var_v:AbstractCompilerVisitor>*/;
8556 if (varonce23) {
8557 var24 = varonce23;
8558 } else {
8559 var25 = "exit(1);";
8560 var26 = 8;
8561 var27 = string__NativeString__to_s_with_length(var25, var26);
8562 var24 = var27;
8563 varonce23 = var24;
8564 }
8565 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var24) /* add on <var_v:AbstractCompilerVisitor>*/;
8566 goto RET_LABEL;
8567 } else {
8568 }
8569 var28 = ((val* (*)(val*))(var_nextern->class->vft[COLOR_parser_nodes__Token__text]))(var_nextern) /* text on <var_nextern:nullable TString(TString)>*/;
8570 var29 = 1;
8571 var30 = ((val* (*)(val*))(var_nextern->class->vft[COLOR_parser_nodes__Token__text]))(var_nextern) /* text on <var_nextern:nullable TString(TString)>*/;
8572 var31 = ((long (*)(val*))(var30->class->vft[COLOR_abstract_collection__Collection__length]))(var30) /* length on <var30:String>*/;
8573 var32 = 2;
8574 { /* Inline kernel#Int#- (var31,var32) */
8575 var35 = var31 - var32;
8576 var33 = var35;
8577 goto RET_LABEL34;
8578 RET_LABEL34:(void)0;
8579 }
8580 var36 = ((val* (*)(val*, long, long))(var28->class->vft[COLOR_string__AbstractString__substring]))(var28, var29, var33) /* substring on <var28:String>*/;
8581 var_externname = var36;
8582 var37 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__ANode__location]))(self) /* location on <self:AExternMethPropdef>*/;
8583 var38 = ((val* (*)(val*))(var37->class->vft[COLOR_location__Location__file]))(var37) /* file on <var37:Location>*/;
8584 var39 = NULL;
8585 if (var38 == NULL) {
8586 var40 = 0; /* is null */
8587 } else {
8588 var40 = 1; /* arg is null and recv is not */
8589 }
8590 if (var40){
8591 var41 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__ANode__location]))(self) /* location on <self:AExternMethPropdef>*/;
8592 var42 = ((val* (*)(val*))(var41->class->vft[COLOR_location__Location__file]))(var41) /* file on <var41:Location>*/;
8593 if (var42 == NULL) {
8594 fprintf(stderr, "Runtime error: %s", "Reciever is null");
8595 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1611);
8596 exit(1);
8597 } else {
8598 var43 = ((val* (*)(val*))(var42->class->vft[COLOR_location__SourceFile__filename]))(var42) /* filename on <var42:nullable SourceFile>*/;
8599 }
8600 var_file = var43;
8601 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add_extern]))(var_v, var_file) /* add_extern on <var_v:AbstractCompilerVisitor>*/;
8602 } else {
8603 }
8604 var44 = NULL;
8605 var_res = var44;
8606 var45 = ((val* (*)(val*))(var_mpropdef->class->vft[COLOR_model__MMethodDef__msignature]))(var_mpropdef) /* msignature on <var_mpropdef:MMethodDef>*/;
8607 if (var45 == NULL) {
8608 fprintf(stderr, "Runtime error: %s", "Reciever is null");
8609 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1615);
8610 exit(1);
8611 } else {
8612 var46 = ((val* (*)(val*))(var45->class->vft[COLOR_model__MSignature__return_mtype]))(var45) /* return_mtype on <var45:nullable MSignature>*/;
8613 }
8614 var_ret = var46;
8615 var47 = NULL;
8616 if (var_ret == NULL) {
8617 var48 = 0; /* is null */
8618 } else {
8619 var48 = 1; /* arg is null and recv is not */
8620 }
8621 if (var48){
8622 var49 = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__first]))(var_arguments) /* first on <var_arguments:Array[RuntimeVariable]>*/;
8623 var50 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__resolve_for]))(var_v, var_ret, var49) /* resolve_for on <var_v:AbstractCompilerVisitor>*/;
8624 var_ret = var50;
8625 var51 = ((val* (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_var]))(var_v, var_ret) /* new_var on <var_v:AbstractCompilerVisitor>*/;
8626 var_res = var51;
8627 } else {
8628 }
8629 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__adapt_signature]))(var_v, var_mpropdef, var_arguments) /* adapt_signature on <var_v:AbstractCompilerVisitor>*/;
8630 var52 = NULL;
8631 if (var_res == NULL) {
8632 var53 = 1; /* is null */
8633 } else {
8634 var53 = 0; /* arg is null but recv is not */
8635 }
8636 if (var53){
8637 if (varonce54) {
8638 var55 = varonce54;
8639 } else {
8640 var56 = "(";
8641 var57 = 1;
8642 var58 = string__NativeString__to_s_with_length(var56, var57);
8643 var55 = var58;
8644 varonce54 = var55;
8645 }
8646 if (varonce59) {
8647 var60 = varonce59;
8648 } else {
8649 var61 = ", ";
8650 var62 = 2;
8651 var63 = string__NativeString__to_s_with_length(var61, var62);
8652 var60 = var63;
8653 varonce59 = var60;
8654 }
8655 var64 = ((val* (*)(val*, val*))(var_arguments->class->vft[COLOR_string__Collection__join]))(var_arguments, var60) /* join on <var_arguments:Array[RuntimeVariable]>*/;
8656 if (varonce65) {
8657 var66 = varonce65;
8658 } else {
8659 var67 = ");";
8660 var68 = 2;
8661 var69 = string__NativeString__to_s_with_length(var67, var68);
8662 var66 = var69;
8663 varonce65 = var66;
8664 }
8665 var70 = NEW_array__Array(&type_array__Arraykernel__Object);
8666 { /* var70 = array_instance Array[Object] */
8667 var71 = 4;
8668 var72 = NEW_array__NativeArray(var71, &type_array__NativeArraykernel__Object);
8669 ((struct instance_array__NativeArray*)var72)->values[0] = (val*) var_externname;
8670 ((struct instance_array__NativeArray*)var72)->values[1] = (val*) var55;
8671 ((struct instance_array__NativeArray*)var72)->values[2] = (val*) var64;
8672 ((struct instance_array__NativeArray*)var72)->values[3] = (val*) var66;
8673 ((void (*)(val*, val*, long))(var70->class->vft[COLOR_array__Array__with_native]))(var70, var72, var71) /* with_native on <var70:Array[Object]>*/;
8674 CHECK_NEW_array__Array(var70);
8675 }
8676 var73 = ((val* (*)(val*))(var70->class->vft[COLOR_string__Object__to_s]))(var70) /* to_s on <var70:Array[Object]>*/;
8677 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var73) /* add on <var_v:AbstractCompilerVisitor>*/;
8678 } else {
8679 if (varonce74) {
8680 var75 = varonce74;
8681 } else {
8682 var76 = " = ";
8683 var77 = 3;
8684 var78 = string__NativeString__to_s_with_length(var76, var77);
8685 var75 = var78;
8686 varonce74 = var75;
8687 }
8688 if (varonce79) {
8689 var80 = varonce79;
8690 } else {
8691 var81 = "(";
8692 var82 = 1;
8693 var83 = string__NativeString__to_s_with_length(var81, var82);
8694 var80 = var83;
8695 varonce79 = var80;
8696 }
8697 if (varonce84) {
8698 var85 = varonce84;
8699 } else {
8700 var86 = ", ";
8701 var87 = 2;
8702 var88 = string__NativeString__to_s_with_length(var86, var87);
8703 var85 = var88;
8704 varonce84 = var85;
8705 }
8706 var89 = ((val* (*)(val*, val*))(var_arguments->class->vft[COLOR_string__Collection__join]))(var_arguments, var85) /* join on <var_arguments:Array[RuntimeVariable]>*/;
8707 if (varonce90) {
8708 var91 = varonce90;
8709 } else {
8710 var92 = ");";
8711 var93 = 2;
8712 var94 = string__NativeString__to_s_with_length(var92, var93);
8713 var91 = var94;
8714 varonce90 = var91;
8715 }
8716 var95 = NEW_array__Array(&type_array__Arraykernel__Object);
8717 { /* var95 = array_instance Array[Object] */
8718 var96 = 6;
8719 var97 = NEW_array__NativeArray(var96, &type_array__NativeArraykernel__Object);
8720 ((struct instance_array__NativeArray*)var97)->values[0] = (val*) var_res;
8721 ((struct instance_array__NativeArray*)var97)->values[1] = (val*) var75;
8722 ((struct instance_array__NativeArray*)var97)->values[2] = (val*) var_externname;
8723 ((struct instance_array__NativeArray*)var97)->values[3] = (val*) var80;
8724 ((struct instance_array__NativeArray*)var97)->values[4] = (val*) var89;
8725 ((struct instance_array__NativeArray*)var97)->values[5] = (val*) var91;
8726 ((void (*)(val*, val*, long))(var95->class->vft[COLOR_array__Array__with_native]))(var95, var97, var96) /* with_native on <var95:Array[Object]>*/;
8727 CHECK_NEW_array__Array(var95);
8728 }
8729 var98 = ((val* (*)(val*))(var95->class->vft[COLOR_string__Object__to_s]))(var95) /* to_s on <var95:Array[Object]>*/;
8730 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var98) /* add on <var_v:AbstractCompilerVisitor>*/;
8731 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var_res) /* ret on <var_v:AbstractCompilerVisitor>*/;
8732 }
8733 RET_LABEL:;
8734 }
8735 /* method abstract_compiler#AExternMethPropdef#compile_to_c for (self: Object, AbstractCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */
8736 void VIRTUAL_abstract_compiler__AExternMethPropdef__compile_to_c(val* self, val* p0, val* p1, val* p2) {
8737 abstract_compiler__AExternMethPropdef__compile_to_c(self, p0, p1, p2);
8738 RET_LABEL:;
8739 }
8740 /* method abstract_compiler#AExternInitPropdef#compile_to_c for (self: AExternInitPropdef, AbstractCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */
8741 void abstract_compiler__AExternInitPropdef__compile_to_c(val* self, val* p0, val* p1, val* p2) {
8742 val* var_v /* var v: AbstractCompilerVisitor */;
8743 val* var_mpropdef /* var mpropdef: MMethodDef */;
8744 val* var_arguments /* var arguments: Array[RuntimeVariable] */;
8745 val* var /* : nullable TString */;
8746 val* var_nextern /* var nextern: nullable TString */;
8747 val* var1 /* : null */;
8748 short int var2 /* : Bool */;
8749 static val* varonce;
8750 val* var3 /* : String */;
8751 char* var4 /* : NativeString */;
8752 long var5 /* : Int */;
8753 val* var6 /* : String */;
8754 static val* varonce7;
8755 val* var8 /* : String */;
8756 char* var9 /* : NativeString */;
8757 long var10 /* : Int */;
8758 val* var11 /* : String */;
8759 val* var12 /* : Location */;
8760 val* var13 /* : String */;
8761 static val* varonce14;
8762 val* var15 /* : String */;
8763 char* var16 /* : NativeString */;
8764 long var17 /* : Int */;
8765 val* var18 /* : String */;
8766 val* var19 /* : Array[Object] */;
8767 long var20 /* : Int */;
8768 val* var21 /* : NativeArray[Object] */;
8769 val* var22 /* : String */;
8770 static val* varonce23;
8771 val* var24 /* : String */;
8772 char* var25 /* : NativeString */;
8773 long var26 /* : Int */;
8774 val* var27 /* : String */;
8775 val* var28 /* : String */;
8776 long var29 /* : Int */;
8777 val* var30 /* : String */;
8778 long var31 /* : Int */;
8779 long var32 /* : Int */;
8780 long var33 /* : Int */;
8781 long var35 /* : Int */;
8782 val* var36 /* : String */;
8783 val* var_externname /* var externname: nullable Object */;
8784 val* var37 /* : Location */;
8785 val* var38 /* : nullable SourceFile */;
8786 val* var39 /* : null */;
8787 short int var40 /* : Bool */;
8788 val* var41 /* : Location */;
8789 val* var42 /* : nullable SourceFile */;
8790 val* var43 /* : String */;
8791 val* var_file /* var file: String */;
8792 val* var44 /* : nullable Object */;
8793 val* var45 /* : MType */;
8794 val* var_ret /* var ret: MType */;
8795 val* var46 /* : RuntimeVariable */;
8796 val* var_res /* var res: RuntimeVariable */;
8797 val* var47 /* : nullable Object */;
8798 static val* varonce48;
8799 val* var49 /* : String */;
8800 char* var50 /* : NativeString */;
8801 long var51 /* : Int */;
8802 val* var52 /* : String */;
8803 static val* varonce53;
8804 val* var54 /* : String */;
8805 char* var55 /* : NativeString */;
8806 long var56 /* : Int */;
8807 val* var57 /* : String */;
8808 static val* varonce58;
8809 val* var59 /* : String */;
8810 char* var60 /* : NativeString */;
8811 long var61 /* : Int */;
8812 val* var62 /* : String */;
8813 val* var63 /* : String */;
8814 static val* varonce64;
8815 val* var65 /* : String */;
8816 char* var66 /* : NativeString */;
8817 long var67 /* : Int */;
8818 val* var68 /* : String */;
8819 val* var69 /* : Array[Object] */;
8820 long var70 /* : Int */;
8821 val* var71 /* : NativeArray[Object] */;
8822 val* var72 /* : String */;
8823 var_v = p0;
8824 var_mpropdef = p1;
8825 var_arguments = p2;
8826 var = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__AExternPropdef__n_extern]))(self) /* n_extern on <self:AExternInitPropdef>*/;
8827 var_nextern = var;
8828 var1 = NULL;
8829 if (var_nextern == NULL) {
8830 var2 = 1; /* is null */
8831 } else {
8832 var2 = 0; /* arg is null but recv is not */
8833 }
8834 if (var2){
8835 if (varonce) {
8836 var3 = varonce;
8837 } else {
8838 var4 = "printf(\"NOT YET IMPLEMENTED nitni for ";
8839 var5 = 38;
8840 var6 = string__NativeString__to_s_with_length(var4, var5);
8841 var3 = var6;
8842 varonce = var3;
8843 }
8844 if (varonce7) {
8845 var8 = varonce7;
8846 } else {
8847 var9 = " at ";
8848 var10 = 4;
8849 var11 = string__NativeString__to_s_with_length(var9, var10);
8850 var8 = var11;
8851 varonce7 = var8;
8852 }
8853 var12 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__ANode__location]))(self) /* location on <self:AExternInitPropdef>*/;
8854 var13 = ((val* (*)(val*))(var12->class->vft[COLOR_string__Object__to_s]))(var12) /* to_s on <var12:Location>*/;
8855 if (varonce14) {
8856 var15 = varonce14;
8857 } else {
8858 var16 = "\\n\");";
8859 var17 = 5;
8860 var18 = string__NativeString__to_s_with_length(var16, var17);
8861 var15 = var18;
8862 varonce14 = var15;
8863 }
8864 var19 = NEW_array__Array(&type_array__Arraykernel__Object);
8865 { /* var19 = array_instance Array[Object] */
8866 var20 = 5;
8867 var21 = NEW_array__NativeArray(var20, &type_array__NativeArraykernel__Object);
8868 ((struct instance_array__NativeArray*)var21)->values[0] = (val*) var3;
8869 ((struct instance_array__NativeArray*)var21)->values[1] = (val*) var_mpropdef;
8870 ((struct instance_array__NativeArray*)var21)->values[2] = (val*) var8;
8871 ((struct instance_array__NativeArray*)var21)->values[3] = (val*) var13;
8872 ((struct instance_array__NativeArray*)var21)->values[4] = (val*) var15;
8873 ((void (*)(val*, val*, long))(var19->class->vft[COLOR_array__Array__with_native]))(var19, var21, var20) /* with_native on <var19:Array[Object]>*/;
8874 CHECK_NEW_array__Array(var19);
8875 }
8876 var22 = ((val* (*)(val*))(var19->class->vft[COLOR_string__Object__to_s]))(var19) /* to_s on <var19:Array[Object]>*/;
8877 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var22) /* add on <var_v:AbstractCompilerVisitor>*/;
8878 if (varonce23) {
8879 var24 = varonce23;
8880 } else {
8881 var25 = "exit(1);";
8882 var26 = 8;
8883 var27 = string__NativeString__to_s_with_length(var25, var26);
8884 var24 = var27;
8885 varonce23 = var24;
8886 }
8887 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var24) /* add on <var_v:AbstractCompilerVisitor>*/;
8888 goto RET_LABEL;
8889 } else {
8890 }
8891 var28 = ((val* (*)(val*))(var_nextern->class->vft[COLOR_parser_nodes__Token__text]))(var_nextern) /* text on <var_nextern:nullable TString(TString)>*/;
8892 var29 = 1;
8893 var30 = ((val* (*)(val*))(var_nextern->class->vft[COLOR_parser_nodes__Token__text]))(var_nextern) /* text on <var_nextern:nullable TString(TString)>*/;
8894 var31 = ((long (*)(val*))(var30->class->vft[COLOR_abstract_collection__Collection__length]))(var30) /* length on <var30:String>*/;
8895 var32 = 2;
8896 { /* Inline kernel#Int#- (var31,var32) */
8897 var35 = var31 - var32;
8898 var33 = var35;
8899 goto RET_LABEL34;
8900 RET_LABEL34:(void)0;
8901 }
8902 var36 = ((val* (*)(val*, long, long))(var28->class->vft[COLOR_string__AbstractString__substring]))(var28, var29, var33) /* substring on <var28:String>*/;
8903 var_externname = var36;
8904 var37 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__ANode__location]))(self) /* location on <self:AExternInitPropdef>*/;
8905 var38 = ((val* (*)(val*))(var37->class->vft[COLOR_location__Location__file]))(var37) /* file on <var37:Location>*/;
8906 var39 = NULL;
8907 if (var38 == NULL) {
8908 var40 = 0; /* is null */
8909 } else {
8910 var40 = 1; /* arg is null and recv is not */
8911 }
8912 if (var40){
8913 var41 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__ANode__location]))(self) /* location on <self:AExternInitPropdef>*/;
8914 var42 = ((val* (*)(val*))(var41->class->vft[COLOR_location__Location__file]))(var41) /* file on <var41:Location>*/;
8915 if (var42 == NULL) {
8916 fprintf(stderr, "Runtime error: %s", "Reciever is null");
8917 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1643);
8918 exit(1);
8919 } else {
8920 var43 = ((val* (*)(val*))(var42->class->vft[COLOR_location__SourceFile__filename]))(var42) /* filename on <var42:nullable SourceFile>*/;
8921 }
8922 var_file = var43;
8923 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add_extern]))(var_v, var_file) /* add_extern on <var_v:AbstractCompilerVisitor>*/;
8924 } else {
8925 }
8926 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__adapt_signature]))(var_v, var_mpropdef, var_arguments) /* adapt_signature on <var_v:AbstractCompilerVisitor>*/;
8927 var44 = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__first]))(var_arguments) /* first on <var_arguments:Array[RuntimeVariable]>*/;
8928 var45 = ((val* (*)(val*))(var44->class->vft[COLOR_abstract_compiler__RuntimeVariable__mtype]))(var44) /* mtype on <var44:nullable Object(RuntimeVariable)>*/;
8929 var_ret = var45;
8930 var46 = ((val* (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_var]))(var_v, var_ret) /* new_var on <var_v:AbstractCompilerVisitor>*/;
8931 var_res = var46;
8932 var47 = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Sequence__shift]))(var_arguments) /* shift on <var_arguments:Array[RuntimeVariable]>*/;
8933 var47;
8934 if (varonce48) {
8935 var49 = varonce48;
8936 } else {
8937 var50 = " = ";
8938 var51 = 3;
8939 var52 = string__NativeString__to_s_with_length(var50, var51);
8940 var49 = var52;
8941 varonce48 = var49;
8942 }
8943 if (varonce53) {
8944 var54 = varonce53;
8945 } else {
8946 var55 = "(";
8947 var56 = 1;
8948 var57 = string__NativeString__to_s_with_length(var55, var56);
8949 var54 = var57;
8950 varonce53 = var54;
8951 }
8952 if (varonce58) {
8953 var59 = varonce58;
8954 } else {
8955 var60 = ", ";
8956 var61 = 2;
8957 var62 = string__NativeString__to_s_with_length(var60, var61);
8958 var59 = var62;
8959 varonce58 = var59;
8960 }
8961 var63 = ((val* (*)(val*, val*))(var_arguments->class->vft[COLOR_string__Collection__join]))(var_arguments, var59) /* join on <var_arguments:Array[RuntimeVariable]>*/;
8962 if (varonce64) {
8963 var65 = varonce64;
8964 } else {
8965 var66 = ");";
8966 var67 = 2;
8967 var68 = string__NativeString__to_s_with_length(var66, var67);
8968 var65 = var68;
8969 varonce64 = var65;
8970 }
8971 var69 = NEW_array__Array(&type_array__Arraykernel__Object);
8972 { /* var69 = array_instance Array[Object] */
8973 var70 = 6;
8974 var71 = NEW_array__NativeArray(var70, &type_array__NativeArraykernel__Object);
8975 ((struct instance_array__NativeArray*)var71)->values[0] = (val*) var_res;
8976 ((struct instance_array__NativeArray*)var71)->values[1] = (val*) var49;
8977 ((struct instance_array__NativeArray*)var71)->values[2] = (val*) var_externname;
8978 ((struct instance_array__NativeArray*)var71)->values[3] = (val*) var54;
8979 ((struct instance_array__NativeArray*)var71)->values[4] = (val*) var63;
8980 ((struct instance_array__NativeArray*)var71)->values[5] = (val*) var65;
8981 ((void (*)(val*, val*, long))(var69->class->vft[COLOR_array__Array__with_native]))(var69, var71, var70) /* with_native on <var69:Array[Object]>*/;
8982 CHECK_NEW_array__Array(var69);
8983 }
8984 var72 = ((val* (*)(val*))(var69->class->vft[COLOR_string__Object__to_s]))(var69) /* to_s on <var69:Array[Object]>*/;
8985 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var72) /* add on <var_v:AbstractCompilerVisitor>*/;
8986 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__ret]))(var_v, var_res) /* ret on <var_v:AbstractCompilerVisitor>*/;
8987 RET_LABEL:;
8988 }
8989 /* method abstract_compiler#AExternInitPropdef#compile_to_c for (self: Object, AbstractCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */
8990 void VIRTUAL_abstract_compiler__AExternInitPropdef__compile_to_c(val* self, val* p0, val* p1, val* p2) {
8991 abstract_compiler__AExternInitPropdef__compile_to_c(self, p0, p1, p2);
8992 RET_LABEL:;
8993 }
8994 /* method abstract_compiler#AAttrPropdef#compile_to_c for (self: AAttrPropdef, AbstractCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */
8995 void abstract_compiler__AAttrPropdef__compile_to_c(val* self, val* p0, val* p1, val* p2) {
8996 val* var_v /* var v: AbstractCompilerVisitor */;
8997 val* var_mpropdef /* var mpropdef: MMethodDef */;
8998 val* var_arguments /* var arguments: Array[RuntimeVariable] */;
8999 long var /* : Int */;
9000 long var1 /* : Int */;
9001 short int var2 /* : Bool */;
9002 short int var4 /* : Bool */;
9003 val* var5 /* : nullable MPropDef */;
9004 val* var6 /* : MProperty */;
9005 val* var7 /* : nullable Object */;
9006 val* var8 /* : RuntimeVariable */;
9007 val* var_res /* var res: RuntimeVariable */;
9008 val* var9 /* : nullable Frame */;
9009 val* var10 /* : nullable RuntimeVariable */;
9010 val* var11 /* : nullable MPropDef */;
9011 val* var12 /* : MProperty */;
9012 val* var13 /* : nullable Object */;
9013 long var14 /* : Int */;
9014 val* var15 /* : nullable Object */;
9015 var_v = p0;
9016 var_mpropdef = p1;
9017 var_arguments = p2;
9018 var = ((long (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__length]))(var_arguments) /* length on <var_arguments:Array[RuntimeVariable]>*/;
9019 var1 = 1;
9020 { /* Inline kernel#Int#== (var,var1) */
9021 var4 = var == var1;
9022 var2 = var4;
9023 goto RET_LABEL3;
9024 RET_LABEL3:(void)0;
9025 }
9026 if (var2){
9027 var5 = ((val* (*)(val*))(self->class->vft[COLOR_modelize_property__APropdef__mpropdef]))(self) /* mpropdef on <self:AAttrPropdef>*/;
9028 if (var5 == NULL) {
9029 fprintf(stderr, "Runtime error: %s", "Reciever is null");
9030 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1661);
9031 exit(1);
9032 } else {
9033 var6 = ((val* (*)(val*))(var5->class->vft[COLOR_model__MPropDef__mproperty]))(var5) /* mproperty on <var5:nullable MPropDef(nullable MAttributeDef)>*/;
9034 }
9035 var7 = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__first]))(var_arguments) /* first on <var_arguments:Array[RuntimeVariable]>*/;
9036 var8 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__read_attribute]))(var_v, var6, var7) /* read_attribute on <var_v:AbstractCompilerVisitor>*/;
9037 var_res = var8;
9038 var9 = ((val* (*)(val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__frame]))(var_v) /* frame on <var_v:AbstractCompilerVisitor>*/;
9039 if (var9 == NULL) {
9040 fprintf(stderr, "Runtime error: %s", "Reciever is null");
9041 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1662);
9042 exit(1);
9043 } else {
9044 var10 = ((val* (*)(val*))(var9->class->vft[COLOR_abstract_compiler__Frame__returnvar]))(var9) /* returnvar on <var9:nullable Frame>*/;
9045 }
9046 if (var10 == NULL) {
9047 fprintf(stderr, "Runtime error: %s", "Cast failed");
9048 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1662);
9049 exit(1);
9050 }
9051 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__assign]))(var_v, var10, var_res) /* assign on <var_v:AbstractCompilerVisitor>*/;
9052 } else {
9053 var11 = ((val* (*)(val*))(self->class->vft[COLOR_modelize_property__APropdef__mpropdef]))(self) /* mpropdef on <self:AAttrPropdef>*/;
9054 if (var11 == NULL) {
9055 fprintf(stderr, "Runtime error: %s", "Reciever is null");
9056 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1664);
9057 exit(1);
9058 } else {
9059 var12 = ((val* (*)(val*))(var11->class->vft[COLOR_model__MPropDef__mproperty]))(var11) /* mproperty on <var11:nullable MPropDef(nullable MAttributeDef)>*/;
9060 }
9061 var13 = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__first]))(var_arguments) /* first on <var_arguments:Array[RuntimeVariable]>*/;
9062 var14 = 1;
9063 var15 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var14) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
9064 ((void (*)(val*, val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__write_attribute]))(var_v, var12, var13, var15) /* write_attribute on <var_v:AbstractCompilerVisitor>*/;
9065 }
9066 RET_LABEL:;
9067 }
9068 /* method abstract_compiler#AAttrPropdef#compile_to_c for (self: Object, AbstractCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */
9069 void VIRTUAL_abstract_compiler__AAttrPropdef__compile_to_c(val* self, val* p0, val* p1, val* p2) {
9070 abstract_compiler__AAttrPropdef__compile_to_c(self, p0, p1, p2);
9071 RET_LABEL:;
9072 }
9073 /* method abstract_compiler#AAttrPropdef#init_expr for (self: AAttrPropdef, AbstractCompilerVisitor, RuntimeVariable) */
9074 void abstract_compiler__AAttrPropdef__init_expr(val* self, val* p0, val* p1) {
9075 val* var_v /* var v: AbstractCompilerVisitor */;
9076 val* var_recv /* var recv: RuntimeVariable */;
9077 val* var /* : nullable AExpr */;
9078 val* var_nexpr /* var nexpr: nullable AExpr */;
9079 val* var1 /* : null */;
9080 short int var2 /* : Bool */;
9081 val* var3 /* : nullable ANode */;
9082 val* var_oldnode /* var oldnode: nullable ANode */;
9083 val* var4 /* : nullable Frame */;
9084 val* var_old_frame /* var old_frame: nullable Frame */;
9085 val* var5 /* : Frame */;
9086 val* var6 /* : nullable MPropDef */;
9087 val* var7 /* : MType */;
9088 short int var8 /* : Bool */;
9089 int cltype;
9090 int idtype;
9091 const char* var_class_name;
9092 val* var9 /* : Array[RuntimeVariable] */;
9093 long var10 /* : Int */;
9094 val* var_ /* var : Array[RuntimeVariable] */;
9095 val* var_frame /* var frame: Frame */;
9096 val* var11 /* : nullable MPropDef */;
9097 val* var12 /* : nullable MType */;
9098 val* var13 /* : RuntimeVariable */;
9099 val* var_value /* var value: RuntimeVariable */;
9100 val* var14 /* : nullable MPropDef */;
9101 val* var15 /* : MProperty */;
9102 var_v = p0;
9103 var_recv = p1;
9104 var = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__AAttrPropdef__n_expr]))(self) /* n_expr on <self:AAttrPropdef>*/;
9105 var_nexpr = var;
9106 var1 = NULL;
9107 if (var_nexpr == NULL) {
9108 var2 = 0; /* is null */
9109 } else {
9110 var2 = 1; /* arg is null and recv is not */
9111 }
9112 if (var2){
9113 var3 = ((val* (*)(val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__current_node]))(var_v) /* current_node on <var_v:AbstractCompilerVisitor>*/;
9114 var_oldnode = var3;
9115 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__current_node_61d]))(var_v, self) /* current_node= on <var_v:AbstractCompilerVisitor>*/;
9116 var4 = ((val* (*)(val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__frame]))(var_v) /* frame on <var_v:AbstractCompilerVisitor>*/;
9117 var_old_frame = var4;
9118 var5 = NEW_abstract_compiler__Frame(&type_abstract_compiler__Frame);
9119 var6 = ((val* (*)(val*))(self->class->vft[COLOR_modelize_property__APropdef__mpropdef]))(self) /* mpropdef on <self:AAttrPropdef>*/;
9120 if (var6 == NULL) {
9121 fprintf(stderr, "Runtime error: %s", "Cast failed");
9122 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1675);
9123 exit(1);
9124 }
9125 var7 = ((val* (*)(val*))(var_recv->class->vft[COLOR_abstract_compiler__RuntimeVariable__mtype]))(var_recv) /* mtype on <var_recv:RuntimeVariable>*/;
9126 /* <var7:MType> isa MClassType */
9127 cltype = type_model__MClassType.color;
9128 idtype = type_model__MClassType.id;
9129 if(cltype >= var7->type->table_size) {
9130 var8 = 0;
9131 } else {
9132 var8 = var7->type->type_table[cltype] == idtype;
9133 }
9134 if (!var8) {
9135 var_class_name = var7 == NULL ? "null" : var7->type->name;
9136 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
9137 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1675);
9138 exit(1);
9139 }
9140 var9 = NEW_array__Array(&type_array__Arrayabstract_compiler__RuntimeVariable);
9141 var10 = 1;
9142 ((void (*)(val*, long))(var9->class->vft[COLOR_array__Array__with_capacity]))(var9, var10) /* with_capacity on <var9:Array[RuntimeVariable]>*/;
9143 CHECK_NEW_array__Array(var9);
9144 var_ = var9;
9145 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__Sequence__push]))(var_, var_recv) /* push on <var_:Array[RuntimeVariable]>*/;
9146 ((void (*)(val*, val*, val*, val*, val*))(var5->class->vft[COLOR_abstract_compiler__Frame__init]))(var5, var_v, var6, var7, var_) /* init on <var5:Frame>*/;
9147 CHECK_NEW_abstract_compiler__Frame(var5);
9148 var_frame = var5;
9149 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__frame_61d]))(var_v, var_frame) /* frame= on <var_v:AbstractCompilerVisitor>*/;
9150 var11 = ((val* (*)(val*))(self->class->vft[COLOR_modelize_property__APropdef__mpropdef]))(self) /* mpropdef on <self:AAttrPropdef>*/;
9151 if (var11 == NULL) {
9152 fprintf(stderr, "Runtime error: %s", "Reciever is null");
9153 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1677);
9154 exit(1);
9155 } else {
9156 var12 = ((val* (*)(val*))(var11->class->vft[COLOR_model__MAttributeDef__static_mtype]))(var11) /* static_mtype on <var11:nullable MPropDef(nullable MAttributeDef)>*/;
9157 }
9158 var13 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__expr]))(var_v, var_nexpr, var12) /* expr on <var_v:AbstractCompilerVisitor>*/;
9159 var_value = var13;
9160 var14 = ((val* (*)(val*))(self->class->vft[COLOR_modelize_property__APropdef__mpropdef]))(self) /* mpropdef on <self:AAttrPropdef>*/;
9161 if (var14 == NULL) {
9162 fprintf(stderr, "Runtime error: %s", "Reciever is null");
9163 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1678);
9164 exit(1);
9165 } else {
9166 var15 = ((val* (*)(val*))(var14->class->vft[COLOR_model__MPropDef__mproperty]))(var14) /* mproperty on <var14:nullable MPropDef(nullable MAttributeDef)>*/;
9167 }
9168 ((void (*)(val*, val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__write_attribute]))(var_v, var15, var_recv, var_value) /* write_attribute on <var_v:AbstractCompilerVisitor>*/;
9169 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__frame_61d]))(var_v, var_old_frame) /* frame= on <var_v:AbstractCompilerVisitor>*/;
9170 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__current_node_61d]))(var_v, var_oldnode) /* current_node= on <var_v:AbstractCompilerVisitor>*/;
9171 } else {
9172 }
9173 RET_LABEL:;
9174 }
9175 /* method abstract_compiler#AAttrPropdef#init_expr for (self: Object, AbstractCompilerVisitor, RuntimeVariable) */
9176 void VIRTUAL_abstract_compiler__AAttrPropdef__init_expr(val* self, val* p0, val* p1) {
9177 abstract_compiler__AAttrPropdef__init_expr(self, p0, p1);
9178 RET_LABEL:;
9179 }
9180 /* method abstract_compiler#AAttrPropdef#check_expr for (self: AAttrPropdef, AbstractCompilerVisitor, RuntimeVariable) */
9181 void abstract_compiler__AAttrPropdef__check_expr(val* self, val* p0, val* p1) {
9182 val* var_v /* var v: AbstractCompilerVisitor */;
9183 val* var_recv /* var recv: RuntimeVariable */;
9184 val* var /* : nullable AExpr */;
9185 val* var_nexpr /* var nexpr: nullable AExpr */;
9186 val* var1 /* : null */;
9187 short int var2 /* : Bool */;
9188 val* var3 /* : nullable ANode */;
9189 val* var_oldnode /* var oldnode: nullable ANode */;
9190 val* var4 /* : nullable Frame */;
9191 val* var_old_frame /* var old_frame: nullable Frame */;
9192 val* var5 /* : Frame */;
9193 val* var6 /* : nullable MPropDef */;
9194 val* var7 /* : MType */;
9195 short int var8 /* : Bool */;
9196 int cltype;
9197 int idtype;
9198 const char* var_class_name;
9199 val* var9 /* : Array[RuntimeVariable] */;
9200 long var10 /* : Int */;
9201 val* var_ /* var : Array[RuntimeVariable] */;
9202 val* var_frame /* var frame: Frame */;
9203 val* var11 /* : nullable MPropDef */;
9204 val* var12 /* : MProperty */;
9205 val* var13 /* : RuntimeVariable */;
9206 var_v = p0;
9207 var_recv = p1;
9208 var = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__AAttrPropdef__n_expr]))(self) /* n_expr on <self:AAttrPropdef>*/;
9209 var_nexpr = var;
9210 var1 = NULL;
9211 if (var_nexpr == NULL) {
9212 var2 = 0; /* is null */
9213 } else {
9214 var2 = 1; /* arg is null and recv is not */
9215 }
9216 if (var2){
9217 goto RET_LABEL;
9218 } else {
9219 }
9220 var3 = ((val* (*)(val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__current_node]))(var_v) /* current_node on <var_v:AbstractCompilerVisitor>*/;
9221 var_oldnode = var3;
9222 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__current_node_61d]))(var_v, self) /* current_node= on <var_v:AbstractCompilerVisitor>*/;
9223 var4 = ((val* (*)(val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__frame]))(var_v) /* frame on <var_v:AbstractCompilerVisitor>*/;
9224 var_old_frame = var4;
9225 var5 = NEW_abstract_compiler__Frame(&type_abstract_compiler__Frame);
9226 var6 = ((val* (*)(val*))(self->class->vft[COLOR_modelize_property__APropdef__mpropdef]))(self) /* mpropdef on <self:AAttrPropdef>*/;
9227 if (var6 == NULL) {
9228 fprintf(stderr, "Runtime error: %s", "Cast failed");
9229 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1692);
9230 exit(1);
9231 }
9232 var7 = ((val* (*)(val*))(var_recv->class->vft[COLOR_abstract_compiler__RuntimeVariable__mtype]))(var_recv) /* mtype on <var_recv:RuntimeVariable>*/;
9233 /* <var7:MType> isa MClassType */
9234 cltype = type_model__MClassType.color;
9235 idtype = type_model__MClassType.id;
9236 if(cltype >= var7->type->table_size) {
9237 var8 = 0;
9238 } else {
9239 var8 = var7->type->type_table[cltype] == idtype;
9240 }
9241 if (!var8) {
9242 var_class_name = var7 == NULL ? "null" : var7->type->name;
9243 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
9244 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1692);
9245 exit(1);
9246 }
9247 var9 = NEW_array__Array(&type_array__Arrayabstract_compiler__RuntimeVariable);
9248 var10 = 1;
9249 ((void (*)(val*, long))(var9->class->vft[COLOR_array__Array__with_capacity]))(var9, var10) /* with_capacity on <var9:Array[RuntimeVariable]>*/;
9250 CHECK_NEW_array__Array(var9);
9251 var_ = var9;
9252 ((void (*)(val*, val*))(var_->class->vft[COLOR_abstract_collection__Sequence__push]))(var_, var_recv) /* push on <var_:Array[RuntimeVariable]>*/;
9253 ((void (*)(val*, val*, val*, val*, val*))(var5->class->vft[COLOR_abstract_compiler__Frame__init]))(var5, var_v, var6, var7, var_) /* init on <var5:Frame>*/;
9254 CHECK_NEW_abstract_compiler__Frame(var5);
9255 var_frame = var5;
9256 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__frame_61d]))(var_v, var_frame) /* frame= on <var_v:AbstractCompilerVisitor>*/;
9257 var11 = ((val* (*)(val*))(self->class->vft[COLOR_modelize_property__APropdef__mpropdef]))(self) /* mpropdef on <self:AAttrPropdef>*/;
9258 if (var11 == NULL) {
9259 fprintf(stderr, "Runtime error: %s", "Reciever is null");
9260 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1695);
9261 exit(1);
9262 } else {
9263 var12 = ((val* (*)(val*))(var11->class->vft[COLOR_model__MPropDef__mproperty]))(var11) /* mproperty on <var11:nullable MPropDef(nullable MAttributeDef)>*/;
9264 }
9265 var13 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__read_attribute]))(var_v, var12, var_recv) /* read_attribute on <var_v:AbstractCompilerVisitor>*/;
9266 var13;
9267 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__frame_61d]))(var_v, var_old_frame) /* frame= on <var_v:AbstractCompilerVisitor>*/;
9268 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__current_node_61d]))(var_v, var_oldnode) /* current_node= on <var_v:AbstractCompilerVisitor>*/;
9269 RET_LABEL:;
9270 }
9271 /* method abstract_compiler#AAttrPropdef#check_expr for (self: Object, AbstractCompilerVisitor, RuntimeVariable) */
9272 void VIRTUAL_abstract_compiler__AAttrPropdef__check_expr(val* self, val* p0, val* p1) {
9273 abstract_compiler__AAttrPropdef__check_expr(self, p0, p1);
9274 RET_LABEL:;
9275 }
9276 /* method abstract_compiler#AClassdef#compile_to_c for (self: AClassdef, AbstractCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */
9277 void abstract_compiler__AClassdef__compile_to_c(val* self, val* p0, val* p1, val* p2) {
9278 val* var_v /* var v: AbstractCompilerVisitor */;
9279 val* var_mpropdef /* var mpropdef: MMethodDef */;
9280 val* var_arguments /* var arguments: Array[RuntimeVariable] */;
9281 val* var /* : nullable MMethodDef */;
9282 short int var1 /* : Bool */;
9283 val* var2 /* : nullable Collection[MMethod] */;
9284 val* var_super_inits /* var super_inits: nullable Collection[MMethod] */;
9285 val* var3 /* : null */;
9286 short int var4 /* : Bool */;
9287 long var5 /* : Int */;
9288 long var6 /* : Int */;
9289 short int var7 /* : Bool */;
9290 short int var9 /* : Bool */;
9291 val* var10 /* : Iterator[nullable Object] */;
9292 short int var11 /* : Bool */;
9293 val* var12 /* : nullable Object */;
9294 val* var_su /* var su: MMethod */;
9295 val* var13 /* : nullable RuntimeVariable */;
9296 val* var14 /* : nullable Object */;
9297 val* var_recv /* var recv: RuntimeVariable */;
9298 long var15 /* : Int */;
9299 long var_i /* var i: Int */;
9300 val* var16 /* : ANodes[APropdef] */;
9301 val* var17 /* : Iterator[nullable Object] */;
9302 short int var18 /* : Bool */;
9303 val* var19 /* : nullable Object */;
9304 val* var_npropdef /* var npropdef: APropdef */;
9305 short int var20 /* : Bool */;
9306 short int var21 /* : Bool */;
9307 int cltype;
9308 int idtype;
9309 short int var_ /* var : Bool */;
9310 val* var22 /* : nullable AExpr */;
9311 val* var23 /* : null */;
9312 short int var24 /* : Bool */;
9313 val* var25 /* : nullable MPropDef */;
9314 val* var26 /* : MProperty */;
9315 val* var27 /* : nullable Object */;
9316 long var28 /* : Int */;
9317 long var29 /* : Int */;
9318 long var31 /* : Int */;
9319 var_v = p0;
9320 var_mpropdef = p1;
9321 var_arguments = p2;
9322 var = ((val* (*)(val*))(self->class->vft[COLOR_modelize_property__AClassdef__mfree_init]))(self) /* mfree_init on <self:AClassdef>*/;
9323 var1 = ((short int (*)(val*, val*))(var_mpropdef->class->vft[COLOR_kernel__Object___61d_61d]))(var_mpropdef, var) /* == on <var_mpropdef:MMethodDef>*/;
9324 if (var1){
9325 var2 = ((val* (*)(val*))(self->class->vft[COLOR_modelize_property__AClassdef__super_inits]))(self) /* super_inits on <self:AClassdef>*/;
9326 var_super_inits = var2;
9327 var3 = NULL;
9328 if (var_super_inits == NULL) {
9329 var4 = 0; /* is null */
9330 } else {
9331 var4 = 1; /* arg is null and recv is not */
9332 }
9333 if (var4){
9334 var5 = ((long (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__length]))(var_arguments) /* length on <var_arguments:Array[RuntimeVariable]>*/;
9335 var6 = 1;
9336 { /* Inline kernel#Int#== (var5,var6) */
9337 var9 = var5 == var6;
9338 var7 = var9;
9339 goto RET_LABEL8;
9340 RET_LABEL8:(void)0;
9341 }
9342 if (!var7) {
9343 fprintf(stderr, "Runtime error: %s", "Assert failed");
9344 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1707);
9345 exit(1);
9346 }
9347 var10 = ((val* (*)(val*))(var_super_inits->class->vft[COLOR_abstract_collection__Collection__iterator]))(var_super_inits) /* iterator on <var_super_inits:nullable Collection[MMethod](Collection[MMethod])>*/;
9348 for(;;) {
9349 var11 = ((short int (*)(val*))(var10->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var10) /* is_ok on <var10:Iterator[nullable Object]>*/;
9350 if(!var11) break;
9351 var12 = ((val* (*)(val*))(var10->class->vft[COLOR_abstract_collection__Iterator__item]))(var10) /* item on <var10:Iterator[nullable Object]>*/;
9352 var_su = var12;
9353 var13 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__send]))(var_v, var_su, var_arguments) /* send on <var_v:AbstractCompilerVisitor>*/;
9354 var13;
9355 CONTINUE_label: (void)0;
9356 ((void (*)(val*))(var10->class->vft[COLOR_abstract_collection__Iterator__next]))(var10) /* next on <var10:Iterator[nullable Object]>*/;
9357 }
9358 BREAK_label: (void)0;
9359 goto RET_LABEL;
9360 } else {
9361 }
9362 var14 = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__first]))(var_arguments) /* first on <var_arguments:Array[RuntimeVariable]>*/;
9363 var_recv = var14;
9364 var15 = 1;
9365 var_i = var15;
9366 var16 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__AClassdef__n_propdefs]))(self) /* n_propdefs on <self:AClassdef>*/;
9367 var17 = ((val* (*)(val*))(var16->class->vft[COLOR_abstract_collection__Collection__iterator]))(var16) /* iterator on <var16:ANodes[APropdef]>*/;
9368 for(;;) {
9369 var18 = ((short int (*)(val*))(var17->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var17) /* is_ok on <var17:Iterator[nullable Object]>*/;
9370 if(!var18) break;
9371 var19 = ((val* (*)(val*))(var17->class->vft[COLOR_abstract_collection__Iterator__item]))(var17) /* item on <var17:Iterator[nullable Object]>*/;
9372 var_npropdef = var19;
9373 /* <var_npropdef:APropdef> isa AAttrPropdef */
9374 cltype = type_parser_nodes__AAttrPropdef.color;
9375 idtype = type_parser_nodes__AAttrPropdef.id;
9376 if(cltype >= var_npropdef->type->table_size) {
9377 var21 = 0;
9378 } else {
9379 var21 = var_npropdef->type->type_table[cltype] == idtype;
9380 }
9381 var_ = var21;
9382 if (var21){
9383 var22 = ((val* (*)(val*))(var_npropdef->class->vft[COLOR_parser_nodes__AAttrPropdef__n_expr]))(var_npropdef) /* n_expr on <var_npropdef:APropdef(AAttrPropdef)>*/;
9384 var23 = NULL;
9385 if (var22 == NULL) {
9386 var24 = 1; /* is null */
9387 } else {
9388 var24 = 0; /* arg is null but recv is not */
9389 }
9390 var20 = var24;
9391 } else {
9392 var20 = var_;
9393 }
9394 if (var20){
9395 var25 = ((val* (*)(val*))(var_npropdef->class->vft[COLOR_modelize_property__APropdef__mpropdef]))(var_npropdef) /* mpropdef on <var_npropdef:APropdef(AAttrPropdef)>*/;
9396 if (var25 == NULL) {
9397 fprintf(stderr, "Runtime error: %s", "Reciever is null");
9398 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1718);
9399 exit(1);
9400 } else {
9401 var26 = ((val* (*)(val*))(var25->class->vft[COLOR_model__MPropDef__mproperty]))(var25) /* mproperty on <var25:nullable MPropDef(nullable MAttributeDef)>*/;
9402 }
9403 var27 = ((val* (*)(val*, long))(var_arguments->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_arguments, var_i) /* [] on <var_arguments:Array[RuntimeVariable]>*/;
9404 ((void (*)(val*, val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__write_attribute]))(var_v, var26, var_recv, var27) /* write_attribute on <var_v:AbstractCompilerVisitor>*/;
9405 var28 = 1;
9406 { /* Inline kernel#Int#+ (var_i,var28) */
9407 var31 = var_i + var28;
9408 var29 = var31;
9409 goto RET_LABEL30;
9410 RET_LABEL30:(void)0;
9411 }
9412 var_i = var29;
9413 } else {
9414 }
9415 CONTINUE_label32: (void)0;
9416 ((void (*)(val*))(var17->class->vft[COLOR_abstract_collection__Iterator__next]))(var17) /* next on <var17:Iterator[nullable Object]>*/;
9417 }
9418 BREAK_label32: (void)0;
9419 } else {
9420 fprintf(stderr, "Runtime error: %s", "Aborted");
9421 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1723);
9422 exit(1);
9423 }
9424 RET_LABEL:;
9425 }
9426 /* method abstract_compiler#AClassdef#compile_to_c for (self: Object, AbstractCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */
9427 void VIRTUAL_abstract_compiler__AClassdef__compile_to_c(val* self, val* p0, val* p1, val* p2) {
9428 abstract_compiler__AClassdef__compile_to_c(self, p0, p1, p2);
9429 RET_LABEL:;
9430 }
9431 /* method abstract_compiler#ADeferredMethPropdef#compile_to_c for (self: ADeferredMethPropdef, AbstractCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */
9432 void abstract_compiler__ADeferredMethPropdef__compile_to_c(val* self, val* p0, val* p1, val* p2) {
9433 val* var_v /* var v: AbstractCompilerVisitor */;
9434 val* var_mpropdef /* var mpropdef: MMethodDef */;
9435 val* var_arguments /* var arguments: Array[RuntimeVariable] */;
9436 val* var /* : nullable Object */;
9437 val* var1 /* : String */;
9438 val* var_cn /* var cn: String */;
9439 static val* varonce;
9440 val* var2 /* : String */;
9441 char* var3 /* : NativeString */;
9442 long var4 /* : Int */;
9443 val* var5 /* : String */;
9444 val* var6 /* : MProperty */;
9445 val* var7 /* : String */;
9446 val* var8 /* : String */;
9447 static val* varonce9;
9448 val* var10 /* : String */;
9449 char* var11 /* : NativeString */;
9450 long var12 /* : Int */;
9451 val* var13 /* : String */;
9452 static val* varonce14;
9453 val* var15 /* : String */;
9454 char* var16 /* : NativeString */;
9455 long var17 /* : Int */;
9456 val* var18 /* : String */;
9457 val* var19 /* : Array[Object] */;
9458 long var20 /* : Int */;
9459 val* var21 /* : NativeArray[Object] */;
9460 val* var22 /* : String */;
9461 var_v = p0;
9462 var_mpropdef = p1;
9463 var_arguments = p2;
9464 var = ((val* (*)(val*))(var_arguments->class->vft[COLOR_abstract_collection__Collection__first]))(var_arguments) /* first on <var_arguments:Array[RuntimeVariable]>*/;
9465 var1 = ((val* (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__class_name_string]))(var_v, var) /* class_name_string on <var_v:AbstractCompilerVisitor>*/;
9466 var_cn = var1;
9467 if (varonce) {
9468 var2 = varonce;
9469 } else {
9470 var3 = "fprintf(stderr, \"Runtime error: Abstract method `%s` called on `%s`\", \"";
9471 var4 = 71;
9472 var5 = string__NativeString__to_s_with_length(var3, var4);
9473 var2 = var5;
9474 varonce = var2;
9475 }
9476 var6 = ((val* (*)(val*))(var_mpropdef->class->vft[COLOR_model__MPropDef__mproperty]))(var_mpropdef) /* mproperty on <var_mpropdef:MMethodDef>*/;
9477 var7 = ((val* (*)(val*))(var6->class->vft[COLOR_model__MProperty__name]))(var6) /* name on <var6:MProperty(MMethod)>*/;
9478 var8 = ((val* (*)(val*))(var7->class->vft[COLOR_string__AbstractString__escape_to_c]))(var7) /* escape_to_c on <var7:String>*/;
9479 if (varonce9) {
9480 var10 = varonce9;
9481 } else {
9482 var11 = "\", ";
9483 var12 = 3;
9484 var13 = string__NativeString__to_s_with_length(var11, var12);
9485 var10 = var13;
9486 varonce9 = var10;
9487 }
9488 if (varonce14) {
9489 var15 = varonce14;
9490 } else {
9491 var16 = ");";
9492 var17 = 2;
9493 var18 = string__NativeString__to_s_with_length(var16, var17);
9494 var15 = var18;
9495 varonce14 = var15;
9496 }
9497 var19 = NEW_array__Array(&type_array__Arraykernel__Object);
9498 { /* var19 = array_instance Array[Object] */
9499 var20 = 5;
9500 var21 = NEW_array__NativeArray(var20, &type_array__NativeArraykernel__Object);
9501 ((struct instance_array__NativeArray*)var21)->values[0] = (val*) var2;
9502 ((struct instance_array__NativeArray*)var21)->values[1] = (val*) var8;
9503 ((struct instance_array__NativeArray*)var21)->values[2] = (val*) var10;
9504 ((struct instance_array__NativeArray*)var21)->values[3] = (val*) var_cn;
9505 ((struct instance_array__NativeArray*)var21)->values[4] = (val*) var15;
9506 ((void (*)(val*, val*, long))(var19->class->vft[COLOR_array__Array__with_native]))(var19, var21, var20) /* with_native on <var19:Array[Object]>*/;
9507 CHECK_NEW_array__Array(var19);
9508 }
9509 var22 = ((val* (*)(val*))(var19->class->vft[COLOR_string__Object__to_s]))(var19) /* to_s on <var19:Array[Object]>*/;
9510 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var22) /* add on <var_v:AbstractCompilerVisitor>*/;
9511 ((void (*)(val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add_raw_abort]))(var_v) /* add_raw_abort on <var_v:AbstractCompilerVisitor>*/;
9512 RET_LABEL:;
9513 }
9514 /* method abstract_compiler#ADeferredMethPropdef#compile_to_c for (self: Object, AbstractCompilerVisitor, MMethodDef, Array[RuntimeVariable]) */
9515 void VIRTUAL_abstract_compiler__ADeferredMethPropdef__compile_to_c(val* self, val* p0, val* p1, val* p2) {
9516 abstract_compiler__ADeferredMethPropdef__compile_to_c(self, p0, p1, p2);
9517 RET_LABEL:;
9518 }
9519 /* method abstract_compiler#ADeferredMethPropdef#can_inline for (self: ADeferredMethPropdef): Bool */
9520 short int abstract_compiler__ADeferredMethPropdef__can_inline(val* self) {
9521 short int var /* : Bool */;
9522 short int var1 /* : Bool */;
9523 var1 = 1;
9524 var = var1;
9525 goto RET_LABEL;
9526 RET_LABEL:;
9527 return var;
9528 }
9529 /* method abstract_compiler#ADeferredMethPropdef#can_inline for (self: Object): Bool */
9530 short int VIRTUAL_abstract_compiler__ADeferredMethPropdef__can_inline(val* self) {
9531 short int var /* : Bool */;
9532 short int var1 /* : Bool */;
9533 var1 = abstract_compiler__ADeferredMethPropdef__can_inline(self);
9534 var = var1;
9535 RET_LABEL:;
9536 return var;
9537 }
9538 /* method abstract_compiler#AExpr#expr for (self: AExpr, AbstractCompilerVisitor): nullable RuntimeVariable */
9539 val* abstract_compiler__AExpr__expr(val* self, val* p0) {
9540 val* var /* : nullable RuntimeVariable */;
9541 val* var_v /* var v: AbstractCompilerVisitor */;
9542 static val* varonce;
9543 val* var1 /* : String */;
9544 char* var2 /* : NativeString */;
9545 long var3 /* : Int */;
9546 val* var4 /* : String */;
9547 val* var5 /* : String */;
9548 static val* varonce6;
9549 val* var7 /* : String */;
9550 char* var8 /* : NativeString */;
9551 long var9 /* : Int */;
9552 val* var10 /* : String */;
9553 val* var11 /* : Location */;
9554 val* var12 /* : String */;
9555 static val* varonce13;
9556 val* var14 /* : String */;
9557 char* var15 /* : NativeString */;
9558 long var16 /* : Int */;
9559 val* var17 /* : String */;
9560 val* var18 /* : Array[Object] */;
9561 long var19 /* : Int */;
9562 val* var20 /* : NativeArray[Object] */;
9563 val* var21 /* : String */;
9564 val* var22 /* : nullable MType */;
9565 val* var_mtype /* var mtype: nullable MType */;
9566 val* var23 /* : null */;
9567 short int var24 /* : Bool */;
9568 val* var25 /* : null */;
9569 val* var26 /* : RuntimeVariable */;
9570 val* var_res /* var res: RuntimeVariable */;
9571 static val* varonce27;
9572 val* var28 /* : String */;
9573 char* var29 /* : NativeString */;
9574 long var30 /* : Int */;
9575 val* var31 /* : String */;
9576 static val* varonce32;
9577 val* var33 /* : String */;
9578 char* var34 /* : NativeString */;
9579 long var35 /* : Int */;
9580 val* var36 /* : String */;
9581 val* var37 /* : String */;
9582 static val* varonce38;
9583 val* var39 /* : String */;
9584 char* var40 /* : NativeString */;
9585 long var41 /* : Int */;
9586 val* var42 /* : String */;
9587 val* var43 /* : Array[Object] */;
9588 long var44 /* : Int */;
9589 val* var45 /* : NativeArray[Object] */;
9590 val* var46 /* : String */;
9591 var_v = p0;
9592 if (varonce) {
9593 var1 = varonce;
9594 } else {
9595 var2 = "printf(\"NOT YET IMPLEMENTED ";
9596 var3 = 28;
9597 var4 = string__NativeString__to_s_with_length(var2, var3);
9598 var1 = var4;
9599 varonce = var1;
9600 }
9601 var5 = ((val* (*)(val*))(self->class->vft[COLOR_string__Object__class_name]))(self) /* class_name on <self:AExpr>*/;
9602 if (varonce6) {
9603 var7 = varonce6;
9604 } else {
9605 var8 = ":";
9606 var9 = 1;
9607 var10 = string__NativeString__to_s_with_length(var8, var9);
9608 var7 = var10;
9609 varonce6 = var7;
9610 }
9611 var11 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__ANode__location]))(self) /* location on <self:AExpr>*/;
9612 var12 = ((val* (*)(val*))(var11->class->vft[COLOR_string__Object__to_s]))(var11) /* to_s on <var11:Location>*/;
9613 if (varonce13) {
9614 var14 = varonce13;
9615 } else {
9616 var15 = "\\n\");";
9617 var16 = 5;
9618 var17 = string__NativeString__to_s_with_length(var15, var16);
9619 var14 = var17;
9620 varonce13 = var14;
9621 }
9622 var18 = NEW_array__Array(&type_array__Arraykernel__Object);
9623 { /* var18 = array_instance Array[Object] */
9624 var19 = 5;
9625 var20 = NEW_array__NativeArray(var19, &type_array__NativeArraykernel__Object);
9626 ((struct instance_array__NativeArray*)var20)->values[0] = (val*) var1;
9627 ((struct instance_array__NativeArray*)var20)->values[1] = (val*) var5;
9628 ((struct instance_array__NativeArray*)var20)->values[2] = (val*) var7;
9629 ((struct instance_array__NativeArray*)var20)->values[3] = (val*) var12;
9630 ((struct instance_array__NativeArray*)var20)->values[4] = (val*) var14;
9631 ((void (*)(val*, val*, long))(var18->class->vft[COLOR_array__Array__with_native]))(var18, var20, var19) /* with_native on <var18:Array[Object]>*/;
9632 CHECK_NEW_array__Array(var18);
9633 }
9634 var21 = ((val* (*)(val*))(var18->class->vft[COLOR_string__Object__to_s]))(var18) /* to_s on <var18:Array[Object]>*/;
9635 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var21) /* add on <var_v:AbstractCompilerVisitor>*/;
9636 var22 = ((val* (*)(val*))(self->class->vft[COLOR_typing__AExpr__mtype]))(self) /* mtype on <self:AExpr>*/;
9637 var_mtype = var22;
9638 var23 = NULL;
9639 if (var_mtype == NULL) {
9640 var24 = 1; /* is null */
9641 } else {
9642 var24 = 0; /* arg is null but recv is not */
9643 }
9644 if (var24){
9645 var25 = NULL;
9646 var = var25;
9647 goto RET_LABEL;
9648 } else {
9649 var26 = ((val* (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__new_var]))(var_v, var_mtype) /* new_var on <var_v:AbstractCompilerVisitor>*/;
9650 var_res = var26;
9651 if (varonce27) {
9652 var28 = varonce27;
9653 } else {
9654 var29 = "/* ";
9655 var30 = 3;
9656 var31 = string__NativeString__to_s_with_length(var29, var30);
9657 var28 = var31;
9658 varonce27 = var28;
9659 }
9660 if (varonce32) {
9661 var33 = varonce32;
9662 } else {
9663 var34 = " = NOT YET ";
9664 var35 = 11;
9665 var36 = string__NativeString__to_s_with_length(var34, var35);
9666 var33 = var36;
9667 varonce32 = var33;
9668 }
9669 var37 = ((val* (*)(val*))(self->class->vft[COLOR_string__Object__class_name]))(self) /* class_name on <self:AExpr>*/;
9670 if (varonce38) {
9671 var39 = varonce38;
9672 } else {
9673 var40 = " */";
9674 var41 = 3;
9675 var42 = string__NativeString__to_s_with_length(var40, var41);
9676 var39 = var42;
9677 varonce38 = var39;
9678 }
9679 var43 = NEW_array__Array(&type_array__Arraykernel__Object);
9680 { /* var43 = array_instance Array[Object] */
9681 var44 = 5;
9682 var45 = NEW_array__NativeArray(var44, &type_array__NativeArraykernel__Object);
9683 ((struct instance_array__NativeArray*)var45)->values[0] = (val*) var28;
9684 ((struct instance_array__NativeArray*)var45)->values[1] = (val*) var_res;
9685 ((struct instance_array__NativeArray*)var45)->values[2] = (val*) var33;
9686 ((struct instance_array__NativeArray*)var45)->values[3] = (val*) var37;
9687 ((struct instance_array__NativeArray*)var45)->values[4] = (val*) var39;
9688 ((void (*)(val*, val*, long))(var43->class->vft[COLOR_array__Array__with_native]))(var43, var45, var44) /* with_native on <var43:Array[Object]>*/;
9689 CHECK_NEW_array__Array(var43);
9690 }
9691 var46 = ((val* (*)(val*))(var43->class->vft[COLOR_string__Object__to_s]))(var43) /* to_s on <var43:Array[Object]>*/;
9692 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var46) /* add on <var_v:AbstractCompilerVisitor>*/;
9693 var = var_res;
9694 goto RET_LABEL;
9695 }
9696 RET_LABEL:;
9697 return var;
9698 }
9699 /* method abstract_compiler#AExpr#expr for (self: Object, AbstractCompilerVisitor): nullable RuntimeVariable */
9700 val* VIRTUAL_abstract_compiler__AExpr__expr(val* self, val* p0) {
9701 val* var /* : nullable RuntimeVariable */;
9702 val* var1 /* : nullable RuntimeVariable */;
9703 var1 = abstract_compiler__AExpr__expr(self, p0);
9704 var = var1;
9705 RET_LABEL:;
9706 return var;
9707 }
9708 /* method abstract_compiler#AExpr#stmt for (self: AExpr, AbstractCompilerVisitor) */
9709 void abstract_compiler__AExpr__stmt(val* self, val* p0) {
9710 val* var_v /* var v: AbstractCompilerVisitor */;
9711 val* var /* : nullable RuntimeVariable */;
9712 val* var_res /* var res: nullable RuntimeVariable */;
9713 val* var1 /* : null */;
9714 short int var2 /* : Bool */;
9715 static val* varonce;
9716 val* var3 /* : String */;
9717 char* var4 /* : NativeString */;
9718 long var5 /* : Int */;
9719 val* var6 /* : String */;
9720 val* var7 /* : Array[Object] */;
9721 long var8 /* : Int */;
9722 val* var9 /* : NativeArray[Object] */;
9723 val* var10 /* : String */;
9724 var_v = p0;
9725 var = ((val* (*)(val*, val*))(self->class->vft[COLOR_abstract_compiler__AExpr__expr]))(self, var_v) /* expr on <self:AExpr>*/;
9726 var_res = var;
9727 var1 = NULL;
9728 if (var_res == NULL) {
9729 var2 = 0; /* is null */
9730 } else {
9731 var2 = 1; /* arg is null and recv is not */
9732 }
9733 if (var2){
9734 if (varonce) {
9735 var3 = varonce;
9736 } else {
9737 var4 = ";";
9738 var5 = 1;
9739 var6 = string__NativeString__to_s_with_length(var4, var5);
9740 var3 = var6;
9741 varonce = var3;
9742 }
9743 var7 = NEW_array__Array(&type_array__Arraykernel__Object);
9744 { /* var7 = array_instance Array[Object] */
9745 var8 = 2;
9746 var9 = NEW_array__NativeArray(var8, &type_array__NativeArraykernel__Object);
9747 ((struct instance_array__NativeArray*)var9)->values[0] = (val*) var_res;
9748 ((struct instance_array__NativeArray*)var9)->values[1] = (val*) var3;
9749 ((void (*)(val*, val*, long))(var7->class->vft[COLOR_array__Array__with_native]))(var7, var9, var8) /* with_native on <var7:Array[Object]>*/;
9750 CHECK_NEW_array__Array(var7);
9751 }
9752 var10 = ((val* (*)(val*))(var7->class->vft[COLOR_string__Object__to_s]))(var7) /* to_s on <var7:Array[Object]>*/;
9753 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__add]))(var_v, var10) /* add on <var_v:AbstractCompilerVisitor>*/;
9754 } else {
9755 }
9756 RET_LABEL:;
9757 }
9758 /* method abstract_compiler#AExpr#stmt for (self: Object, AbstractCompilerVisitor) */
9759 void VIRTUAL_abstract_compiler__AExpr__stmt(val* self, val* p0) {
9760 abstract_compiler__AExpr__stmt(self, p0);
9761 RET_LABEL:;
9762 }
9763 /* method abstract_compiler#ABlockExpr#stmt for (self: ABlockExpr, AbstractCompilerVisitor) */
9764 void abstract_compiler__ABlockExpr__stmt(val* self, val* p0) {
9765 val* var_v /* var v: AbstractCompilerVisitor */;
9766 val* var /* : ANodes[AExpr] */;
9767 val* var1 /* : Iterator[nullable Object] */;
9768 short int var2 /* : Bool */;
9769 val* var3 /* : nullable Object */;
9770 val* var_e /* var e: AExpr */;
9771 var_v = p0;
9772 var = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__ABlockExpr__n_expr]))(self) /* n_expr on <self:ABlockExpr>*/;
9773 var1 = ((val* (*)(val*))(var->class->vft[COLOR_abstract_collection__Collection__iterator]))(var) /* iterator on <var:ANodes[AExpr]>*/;
9774 for(;;) {
9775 var2 = ((short int (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var1) /* is_ok on <var1:Iterator[nullable Object]>*/;
9776 if(!var2) break;
9777 var3 = ((val* (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__item]))(var1) /* item on <var1:Iterator[nullable Object]>*/;
9778 var_e = var3;
9779 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__stmt]))(var_v, var_e) /* stmt on <var_v:AbstractCompilerVisitor>*/;
9780 CONTINUE_label: (void)0;
9781 ((void (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__next]))(var1) /* next on <var1:Iterator[nullable Object]>*/;
9782 }
9783 BREAK_label: (void)0;
9784 RET_LABEL:;
9785 }
9786 /* method abstract_compiler#ABlockExpr#stmt for (self: Object, AbstractCompilerVisitor) */
9787 void VIRTUAL_abstract_compiler__ABlockExpr__stmt(val* self, val* p0) {
9788 abstract_compiler__ABlockExpr__stmt(self, p0);
9789 RET_LABEL:;
9790 }
9791 /* method abstract_compiler#ABlockExpr#expr for (self: ABlockExpr, AbstractCompilerVisitor): nullable RuntimeVariable */
9792 val* abstract_compiler__ABlockExpr__expr(val* self, val* p0) {
9793 val* var /* : nullable RuntimeVariable */;
9794 val* var_v /* var v: AbstractCompilerVisitor */;
9795 val* var1 /* : ANodes[AExpr] */;
9796 val* var2 /* : nullable Object */;
9797 val* var_last /* var last: AExpr */;
9798 val* var3 /* : ANodes[AExpr] */;
9799 val* var4 /* : Iterator[nullable Object] */;
9800 short int var5 /* : Bool */;
9801 val* var6 /* : nullable Object */;
9802 val* var_e /* var e: AExpr */;
9803 short int var7 /* : Bool */;
9804 val* var8 /* : null */;
9805 val* var9 /* : RuntimeVariable */;
9806 var_v = p0;
9807 var1 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__ABlockExpr__n_expr]))(self) /* n_expr on <self:ABlockExpr>*/;
9808 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_abstract_collection__SequenceRead__last]))(var1) /* last on <var1:ANodes[AExpr]>*/;
9809 var_last = var2;
9810 var3 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__ABlockExpr__n_expr]))(self) /* n_expr on <self:ABlockExpr>*/;
9811 var4 = ((val* (*)(val*))(var3->class->vft[COLOR_abstract_collection__Collection__iterator]))(var3) /* iterator on <var3:ANodes[AExpr]>*/;
9812 for(;;) {
9813 var5 = ((short int (*)(val*))(var4->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var4) /* is_ok on <var4:Iterator[nullable Object]>*/;
9814 if(!var5) break;
9815 var6 = ((val* (*)(val*))(var4->class->vft[COLOR_abstract_collection__Iterator__item]))(var4) /* item on <var4:Iterator[nullable Object]>*/;
9816 var_e = var6;
9817 var7 = ((short int (*)(val*, val*))(var_e->class->vft[COLOR_kernel__Object___61d_61d]))(var_e, var_last) /* == on <var_e:AExpr>*/;
9818 if (var7){
9819 goto BREAK_label;
9820 } else {
9821 }
9822 ((void (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__stmt]))(var_v, var_e) /* stmt on <var_v:AbstractCompilerVisitor>*/;
9823 CONTINUE_label: (void)0;
9824 ((void (*)(val*))(var4->class->vft[COLOR_abstract_collection__Iterator__next]))(var4) /* next on <var4:Iterator[nullable Object]>*/;
9825 }
9826 BREAK_label: (void)0;
9827 var8 = NULL;
9828 var9 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__expr]))(var_v, var_last, var8) /* expr on <var_v:AbstractCompilerVisitor>*/;
9829 var = var9;
9830 goto RET_LABEL;
9831 RET_LABEL:;
9832 return var;
9833 }
9834 /* method abstract_compiler#ABlockExpr#expr for (self: Object, AbstractCompilerVisitor): nullable RuntimeVariable */
9835 val* VIRTUAL_abstract_compiler__ABlockExpr__expr(val* self, val* p0) {
9836 val* var /* : nullable RuntimeVariable */;
9837 val* var1 /* : nullable RuntimeVariable */;
9838 var1 = abstract_compiler__ABlockExpr__expr(self, p0);
9839 var = var1;
9840 RET_LABEL:;
9841 return var;
9842 }
9843 /* method abstract_compiler#AVardeclExpr#stmt for (self: AVardeclExpr, AbstractCompilerVisitor) */
9844 void abstract_compiler__AVardeclExpr__stmt(val* self, val* p0) {
9845 val* var_v /* var v: AbstractCompilerVisitor */;
9846 val* var /* : nullable Variable */;
9847 val* var_variable /* var variable: Variable */;
9848 val* var1 /* : nullable AExpr */;
9849 val* var_ne /* var ne: nullable AExpr */;
9850 val* var2 /* : null */;
9851 short int var3 /* : Bool */;
9852 val* var4 /* : nullable MType */;
9853 val* var5 /* : RuntimeVariable */;
9854 val* var_i /* var i: RuntimeVariable */;
9855 val* var6 /* : RuntimeVariable */;
9856 var_v = p0;
9857 var = ((val* (*)(val*))(self->class->vft[COLOR_scope__AVardeclExpr__variable]))(self) /* variable on <self:AVardeclExpr>*/;
9858 if (var == NULL) {
9859 fprintf(stderr, "Runtime error: %s", "Cast failed");
9860 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1781);
9861 exit(1);
9862 }
9863 var_variable = var;
9864 var1 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__AVardeclExpr__n_expr]))(self) /* n_expr on <self:AVardeclExpr>*/;
9865 var_ne = var1;
9866 var2 = NULL;
9867 if (var_ne == NULL) {
9868 var3 = 0; /* is null */
9869 } else {
9870 var3 = 1; /* arg is null and recv is not */
9871 }
9872 if (var3){
9873 var4 = ((val* (*)(val*))(var_variable->class->vft[COLOR_typing__Variable__declared_type]))(var_variable) /* declared_type on <var_variable:Variable>*/;
9874 var5 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__expr]))(var_v, var_ne, var4) /* expr on <var_v:AbstractCompilerVisitor>*/;
9875 var_i = var5;
9876 var6 = ((val* (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__variable]))(var_v, var_variable) /* variable on <var_v:AbstractCompilerVisitor>*/;
9877 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__assign]))(var_v, var6, var_i) /* assign on <var_v:AbstractCompilerVisitor>*/;
9878 } else {
9879 }
9880 RET_LABEL:;
9881 }
9882 /* method abstract_compiler#AVardeclExpr#stmt for (self: Object, AbstractCompilerVisitor) */
9883 void VIRTUAL_abstract_compiler__AVardeclExpr__stmt(val* self, val* p0) {
9884 abstract_compiler__AVardeclExpr__stmt(self, p0);
9885 RET_LABEL:;
9886 }
9887 /* method abstract_compiler#AVarExpr#expr for (self: AVarExpr, AbstractCompilerVisitor): nullable RuntimeVariable */
9888 val* abstract_compiler__AVarExpr__expr(val* self, val* p0) {
9889 val* var /* : nullable RuntimeVariable */;
9890 val* var_v /* var v: AbstractCompilerVisitor */;
9891 val* var1 /* : nullable Variable */;
9892 val* var2 /* : RuntimeVariable */;
9893 val* var_res /* var res: RuntimeVariable */;
9894 val* var3 /* : nullable MType */;
9895 val* var_mtype /* var mtype: MType */;
9896 val* var4 /* : RuntimeVariable */;
9897 var_v = p0;
9898 var1 = ((val* (*)(val*))(self->class->vft[COLOR_scope__AVarFormExpr__variable]))(self) /* variable on <self:AVarExpr>*/;
9899 if (var1 == NULL) {
9900 fprintf(stderr, "Runtime error: %s", "Cast failed");
9901 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1793);
9902 exit(1);
9903 }
9904 var2 = ((val* (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__variable]))(var_v, var1) /* variable on <var_v:AbstractCompilerVisitor>*/;
9905 var_res = var2;
9906 var3 = ((val* (*)(val*))(self->class->vft[COLOR_typing__AExpr__mtype]))(self) /* mtype on <self:AVarExpr>*/;
9907 if (var3 == NULL) {
9908 fprintf(stderr, "Runtime error: %s", "Cast failed");
9909 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1794);
9910 exit(1);
9911 }
9912 var_mtype = var3;
9913 var4 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__autoadapt]))(var_v, var_res, var_mtype) /* autoadapt on <var_v:AbstractCompilerVisitor>*/;
9914 var = var4;
9915 goto RET_LABEL;
9916 RET_LABEL:;
9917 return var;
9918 }
9919 /* method abstract_compiler#AVarExpr#expr for (self: Object, AbstractCompilerVisitor): nullable RuntimeVariable */
9920 val* VIRTUAL_abstract_compiler__AVarExpr__expr(val* self, val* p0) {
9921 val* var /* : nullable RuntimeVariable */;
9922 val* var1 /* : nullable RuntimeVariable */;
9923 var1 = abstract_compiler__AVarExpr__expr(self, p0);
9924 var = var1;
9925 RET_LABEL:;
9926 return var;
9927 }
9928 /* method abstract_compiler#AVarAssignExpr#stmt for (self: AVarAssignExpr, AbstractCompilerVisitor) */
9929 void abstract_compiler__AVarAssignExpr__stmt(val* self, val* p0) {
9930 val* var_v /* var v: AbstractCompilerVisitor */;
9931 val* var /* : nullable Variable */;
9932 val* var_variable /* var variable: Variable */;
9933 val* var1 /* : AExpr */;
9934 val* var2 /* : nullable MType */;
9935 val* var3 /* : RuntimeVariable */;
9936 val* var_i /* var i: RuntimeVariable */;
9937 val* var4 /* : RuntimeVariable */;
9938 var_v = p0;
9939 var = ((val* (*)(val*))(self->class->vft[COLOR_scope__AVarFormExpr__variable]))(self) /* variable on <self:AVarAssignExpr>*/;
9940 if (var == NULL) {
9941 fprintf(stderr, "Runtime error: %s", "Cast failed");
9942 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1802);
9943 exit(1);
9944 }
9945 var_variable = var;
9946 var1 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__AAssignFormExpr__n_value]))(self) /* n_value on <self:AVarAssignExpr>*/;
9947 var2 = ((val* (*)(val*))(var_variable->class->vft[COLOR_typing__Variable__declared_type]))(var_variable) /* declared_type on <var_variable:Variable>*/;
9948 var3 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__expr]))(var_v, var1, var2) /* expr on <var_v:AbstractCompilerVisitor>*/;
9949 var_i = var3;
9950 var4 = ((val* (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__variable]))(var_v, var_variable) /* variable on <var_v:AbstractCompilerVisitor>*/;
9951 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__assign]))(var_v, var4, var_i) /* assign on <var_v:AbstractCompilerVisitor>*/;
9952 RET_LABEL:;
9953 }
9954 /* method abstract_compiler#AVarAssignExpr#stmt for (self: Object, AbstractCompilerVisitor) */
9955 void VIRTUAL_abstract_compiler__AVarAssignExpr__stmt(val* self, val* p0) {
9956 abstract_compiler__AVarAssignExpr__stmt(self, p0);
9957 RET_LABEL:;
9958 }
9959 /* method abstract_compiler#AVarAssignExpr#expr for (self: AVarAssignExpr, AbstractCompilerVisitor): nullable RuntimeVariable */
9960 val* abstract_compiler__AVarAssignExpr__expr(val* self, val* p0) {
9961 val* var /* : nullable RuntimeVariable */;
9962 val* var_v /* var v: AbstractCompilerVisitor */;
9963 val* var1 /* : nullable Variable */;
9964 val* var_variable /* var variable: Variable */;
9965 val* var2 /* : AExpr */;
9966 val* var3 /* : nullable MType */;
9967 val* var4 /* : RuntimeVariable */;
9968 val* var_i /* var i: RuntimeVariable */;
9969 val* var5 /* : RuntimeVariable */;
9970 var_v = p0;
9971 var1 = ((val* (*)(val*))(self->class->vft[COLOR_scope__AVarFormExpr__variable]))(self) /* variable on <self:AVarAssignExpr>*/;
9972 if (var1 == NULL) {
9973 fprintf(stderr, "Runtime error: %s", "Cast failed");
9974 fprintf(stderr, " (%s:%d)\n", "src/abstract_compiler.nit", 1808);
9975 exit(1);
9976 }
9977 var_variable = var1;
9978 var2 = ((val* (*)(val*))(self->class->vft[COLOR_parser_nodes__AAssignFormExpr__n_value]))(self) /* n_value on <self:AVarAssignExpr>*/;
9979 var3 = ((val* (*)(val*))(var_variable->class->vft[COLOR_typing__Variable__declared_type]))(var_variable) /* declared_type on <var_variable:Variable>*/;
9980 var4 = ((val* (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__expr]))(var_v, var2, var3) /* expr on <var_v:AbstractCompilerVisitor>*/;
9981 var_i = var4;
9982 var5 = ((val* (*)(val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__variable]))(var_v, var_variable) /* variable on <var_v:AbstractCompilerVisitor>*/;
9983 ((void (*)(val*, val*, val*))(var_v->class->vft[COLOR_abstract_compiler__AbstractCompilerVisitor__assign]))(var_v, var5, var_i) /* assign on <var_v:AbstractCompilerVisitor>*/;
9984 var = var_i;
9985 goto RET_LABEL;
9986 RET_LABEL:;
9987 return var;
9988 }
9989 /* method abstract_compiler#AVarAssignExpr#expr for (self: Object, AbstractCompilerVisitor): nullable RuntimeVariable */
9990 val* VIRTUAL_abstract_compiler__AVarAssignExpr__expr(val* self, val* p0) {
9991 val* var /* : nullable RuntimeVariable */;
9992 val* var1 /* : nullable RuntimeVariable */;
9993 var1 = abstract_compiler__AVarAssignExpr__expr(self, p0);
9994 var = var1;
9995 RET_LABEL:;
9996 return var;
9997 }