c_src/array.sep.1.c

   1 #include "array.sep.0.h"
   2 /* method array#AbstractArrayRead#length for (self: AbstractArrayRead[nullable Object]): Int */
   3 long array__AbstractArrayRead__length(val* self) {
   4 long var /* : Int */;
   5 long var1 /* : Int */;
   6 var1 = self->attrs[COLOR_array__AbstractArrayRead___length].l; /* _length on <self:AbstractArrayRead[nullable Object]> */
   7 var = var1;
   8 RET_LABEL:;
   9 return var;
  10 }
  11 /* method array#AbstractArrayRead#length for (self: Object): Int */
  12 long VIRTUAL_array__AbstractArrayRead__length(val* self) {
  13 long var /* : Int */;
  14 long var1 /* : Int */;
  15 var1 = array__AbstractArrayRead__length(self);
  16 var = var1;
  17 RET_LABEL:;
  18 return var;
  19 }
  20 /* method array#AbstractArrayRead#is_empty for (self: AbstractArrayRead[nullable Object]): Bool */
  21 short int array__AbstractArrayRead__is_empty(val* self) {
  22 short int var /* : Bool */;
  23 long var1 /* : Int */;
  24 long var2 /* : Int */;
  25 short int var3 /* : Bool */;
  26 short int var5 /* : Bool */;
  27 var1 = self->attrs[COLOR_array__AbstractArrayRead___length].l; /* _length on <self:AbstractArrayRead[nullable Object]> */
  28 var2 = 0;
  29 { /* Inline kernel#Int#== (var1,var2) */
  30 var5 = var1 == var2;
  31 var3 = var5;
  32 goto RET_LABEL4;
  33 RET_LABEL4:(void)0;
  34 }
  35 var = var3;
  36 goto RET_LABEL;
  37 RET_LABEL:;
  38 return var;
  39 }
  40 /* method array#AbstractArrayRead#is_empty for (self: Object): Bool */
  41 short int VIRTUAL_array__AbstractArrayRead__is_empty(val* self) {
  42 short int var /* : Bool */;
  43 short int var1 /* : Bool */;
  44 var1 = array__AbstractArrayRead__is_empty(self);
  45 var = var1;
  46 RET_LABEL:;
  47 return var;
  48 }
  49 /* method array#AbstractArrayRead#has for (self: AbstractArrayRead[nullable Object], nullable Object): Bool */
  50 short int array__AbstractArrayRead__has(val* self, val* p0) {
  51 short int var /* : Bool */;
  52 short int var1 /* : Bool */;
  53 int cltype;
  54 int idtype;
  55 const struct type* type_struct;
  56 short int is_nullable;
  57 const char* var_class_name;
  58 val* var_item /* var item: nullable Object */;
  59 long var2 /* : Int */;
  60 long var_i /* var i: Int */;
  61 long var3 /* : Int */;
  62 long var_l /* var l: Int */;
  63 short int var4 /* : Bool */;
  64 short int var6 /* : Bool */;
  65 int cltype7;
  66 int idtype8;
  67 const char* var_class_name9;
  68 short int var10 /* : Bool */;
  69 val* var11 /* : nullable Object */;
  70 short int var12 /* : Bool */;
  71 short int var13 /* : Bool */;
  72 long var14 /* : Int */;
  73 long var15 /* : Int */;
  74 long var17 /* : Int */;
  75 short int var18 /* : Bool */;
  76 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa Collection#0 */
  77 /* <p0:nullable Object> isa Collection#0 */
  78 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collection_FT0];
  79 cltype = type_struct->color;
  80 idtype = type_struct->id;
  81 is_nullable = type_struct->is_nullable;
  82 if(p0 == NULL) {
  83 var1 = is_nullable;
  84 } else {
  85 if(cltype >= p0->type->table_size) {
  86 var1 = 0;
  87 } else {
  88 var1 = p0->type->type_table[cltype] == idtype;
  89 }
  90 }
  91 if (!var1) {
  92 var_class_name = p0 == NULL ? "null" : p0->type->name;
  93 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection#0", var_class_name);
  94 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 28);
  95 show_backtrace(1);
  96 }
  97 var_item = p0;
  98 var2 = 0;
  99 var_i = var2;
 100 var3 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:AbstractArrayRead[nullable Object]>*/;
 101 var_l = var3;
 102 for(;;) {
 103 { /* Inline kernel#Int#< (var_i,var_l) */
 104 /* Covariant cast for argument 0 (i) <var_l:Int> isa OTHER */
 105 /* <var_l:Int> isa OTHER */
 106 var6 = 1; /* easy <var_l:Int> isa OTHER*/
 107 if (!var6) {
 108 var_class_name9 = type_kernel__Int.name;
 109 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name9);
 110 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 261);
 111 show_backtrace(1);
 112 }
 113 var10 = var_i < var_l;
 114 var4 = var10;
 115 goto RET_LABEL5;
 116 RET_LABEL5:(void)0;
 117 }
 118 if (!var4) break;
 119 var11 = ((val* (*)(val*, long))(self->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(self, var_i) /* [] on <self:AbstractArrayRead[nullable Object]>*/;
 120 if (var11 == NULL) {
 121 var12 = (var_item == NULL);
 122 } else {
 123 var12 = ((short int (*)(val*, val*))(var11->class->vft[COLOR_kernel__Object___61d_61d]))(var11, var_item) /* == on <var11:nullable Object>*/;
 124 }
 125 if (var12){
 126 var13 = 1;
 127 var = var13;
 128 goto RET_LABEL;
 129 } else {
 130 }
 131 var14 = 1;
 132 { /* Inline kernel#Int#+ (var_i,var14) */
 133 var17 = var_i + var14;
 134 var15 = var17;
 135 goto RET_LABEL16;
 136 RET_LABEL16:(void)0;
 137 }
 138 var_i = var15;
 139 CONTINUE_label: (void)0;
 140 }
 141 BREAK_label: (void)0;
 142 var18 = 0;
 143 var = var18;
 144 goto RET_LABEL;
 145 RET_LABEL:;
 146 return var;
 147 }
 148 /* method array#AbstractArrayRead#has for (self: Object, nullable Object): Bool */
 149 short int VIRTUAL_array__AbstractArrayRead__has(val* self, val* p0) {
 150 short int var /* : Bool */;
 151 short int var1 /* : Bool */;
 152 var1 = array__AbstractArrayRead__has(self, p0);
 153 var = var1;
 154 RET_LABEL:;
 155 return var;
 156 }
 157 /* method array#AbstractArrayRead#has_only for (self: AbstractArrayRead[nullable Object], nullable Object): Bool */
 158 short int array__AbstractArrayRead__has_only(val* self, val* p0) {
 159 short int var /* : Bool */;
 160 short int var1 /* : Bool */;
 161 int cltype;
 162 int idtype;
 163 const struct type* type_struct;
 164 short int is_nullable;
 165 const char* var_class_name;
 166 val* var_item /* var item: nullable Object */;
 167 long var2 /* : Int */;
 168 long var_i /* var i: Int */;
 169 long var3 /* : Int */;
 170 long var_l /* var l: Int */;
 171 short int var4 /* : Bool */;
 172 short int var6 /* : Bool */;
 173 int cltype7;
 174 int idtype8;
 175 const char* var_class_name9;
 176 short int var10 /* : Bool */;
 177 val* var11 /* : nullable Object */;
 178 short int var12 /* : Bool */;
 179 short int var13 /* : Bool */;
 180 long var14 /* : Int */;
 181 long var15 /* : Int */;
 182 long var17 /* : Int */;
 183 short int var18 /* : Bool */;
 184 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa Collection#0 */
 185 /* <p0:nullable Object> isa Collection#0 */
 186 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collection_FT0];
 187 cltype = type_struct->color;
 188 idtype = type_struct->id;
 189 is_nullable = type_struct->is_nullable;
 190 if(p0 == NULL) {
 191 var1 = is_nullable;
 192 } else {
 193 if(cltype >= p0->type->table_size) {
 194 var1 = 0;
 195 } else {
 196 var1 = p0->type->type_table[cltype] == idtype;
 197 }
 198 }
 199 if (!var1) {
 200 var_class_name = p0 == NULL ? "null" : p0->type->name;
 201 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection#0", var_class_name);
 202 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 39);
 203 show_backtrace(1);
 204 }
 205 var_item = p0;
 206 var2 = 0;
 207 var_i = var2;
 208 var3 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:AbstractArrayRead[nullable Object]>*/;
 209 var_l = var3;
 210 for(;;) {
 211 { /* Inline kernel#Int#< (var_i,var_l) */
 212 /* Covariant cast for argument 0 (i) <var_l:Int> isa OTHER */
 213 /* <var_l:Int> isa OTHER */
 214 var6 = 1; /* easy <var_l:Int> isa OTHER*/
 215 if (!var6) {
 216 var_class_name9 = type_kernel__Int.name;
 217 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name9);
 218 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 261);
 219 show_backtrace(1);
 220 }
 221 var10 = var_i < var_l;
 222 var4 = var10;
 223 goto RET_LABEL5;
 224 RET_LABEL5:(void)0;
 225 }
 226 if (!var4) break;
 227 var11 = ((val* (*)(val*, long))(self->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(self, var_i) /* [] on <self:AbstractArrayRead[nullable Object]>*/;
 228 if (var11 == NULL) {
 229 var12 = (var_item != NULL);
 230 } else {
 231 var12 = ((short int (*)(val*, val*))(var11->class->vft[COLOR_kernel__Object___33d_61d]))(var11, var_item) /* != on <var11:nullable Object>*/;
 232 }
 233 if (var12){
 234 var13 = 0;
 235 var = var13;
 236 goto RET_LABEL;
 237 } else {
 238 }
 239 var14 = 1;
 240 { /* Inline kernel#Int#+ (var_i,var14) */
 241 var17 = var_i + var14;
 242 var15 = var17;
 243 goto RET_LABEL16;
 244 RET_LABEL16:(void)0;
 245 }
 246 var_i = var15;
 247 CONTINUE_label: (void)0;
 248 }
 249 BREAK_label: (void)0;
 250 var18 = 1;
 251 var = var18;
 252 goto RET_LABEL;
 253 RET_LABEL:;
 254 return var;
 255 }
 256 /* method array#AbstractArrayRead#has_only for (self: Object, nullable Object): Bool */
 257 short int VIRTUAL_array__AbstractArrayRead__has_only(val* self, val* p0) {
 258 short int var /* : Bool */;
 259 short int var1 /* : Bool */;
 260 var1 = array__AbstractArrayRead__has_only(self, p0);
 261 var = var1;
 262 RET_LABEL:;
 263 return var;
 264 }
 265 /* method array#AbstractArrayRead#count for (self: AbstractArrayRead[nullable Object], nullable Object): Int */
 266 long array__AbstractArrayRead__count(val* self, val* p0) {
 267 long var /* : Int */;
 268 short int var1 /* : Bool */;
 269 int cltype;
 270 int idtype;
 271 const struct type* type_struct;
 272 short int is_nullable;
 273 const char* var_class_name;
 274 val* var_item /* var item: nullable Object */;
 275 long var2 /* : Int */;
 276 long var_res /* var res: Int */;
 277 long var3 /* : Int */;
 278 long var_i /* var i: Int */;
 279 long var4 /* : Int */;
 280 long var_l /* var l: Int */;
 281 short int var5 /* : Bool */;
 282 short int var7 /* : Bool */;
 283 int cltype8;
 284 int idtype9;
 285 const char* var_class_name10;
 286 short int var11 /* : Bool */;
 287 val* var12 /* : nullable Object */;
 288 short int var13 /* : Bool */;
 289 long var14 /* : Int */;
 290 long var15 /* : Int */;
 291 long var17 /* : Int */;
 292 long var18 /* : Int */;
 293 long var19 /* : Int */;
 294 long var21 /* : Int */;
 295 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa Collection#0 */
 296 /* <p0:nullable Object> isa Collection#0 */
 297 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collection_FT0];
 298 cltype = type_struct->color;
 299 idtype = type_struct->id;
 300 is_nullable = type_struct->is_nullable;
 301 if(p0 == NULL) {
 302 var1 = is_nullable;
 303 } else {
 304 if(cltype >= p0->type->table_size) {
 305 var1 = 0;
 306 } else {
 307 var1 = p0->type->type_table[cltype] == idtype;
 308 }
 309 }
 310 if (!var1) {
 311 var_class_name = p0 == NULL ? "null" : p0->type->name;
 312 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection#0", var_class_name);
 313 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 50);
 314 show_backtrace(1);
 315 }
 316 var_item = p0;
 317 var2 = 0;
 318 var_res = var2;
 319 var3 = 0;
 320 var_i = var3;
 321 var4 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:AbstractArrayRead[nullable Object]>*/;
 322 var_l = var4;
 323 for(;;) {
 324 { /* Inline kernel#Int#< (var_i,var_l) */
 325 /* Covariant cast for argument 0 (i) <var_l:Int> isa OTHER */
 326 /* <var_l:Int> isa OTHER */
 327 var7 = 1; /* easy <var_l:Int> isa OTHER*/
 328 if (!var7) {
 329 var_class_name10 = type_kernel__Int.name;
 330 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name10);
 331 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 261);
 332 show_backtrace(1);
 333 }
 334 var11 = var_i < var_l;
 335 var5 = var11;
 336 goto RET_LABEL6;
 337 RET_LABEL6:(void)0;
 338 }
 339 if (!var5) break;
 340 var12 = ((val* (*)(val*, long))(self->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(self, var_i) /* [] on <self:AbstractArrayRead[nullable Object]>*/;
 341 if (var12 == NULL) {
 342 var13 = (var_item == NULL);
 343 } else {
 344 var13 = ((short int (*)(val*, val*))(var12->class->vft[COLOR_kernel__Object___61d_61d]))(var12, var_item) /* == on <var12:nullable Object>*/;
 345 }
 346 if (var13){
 347 var14 = 1;
 348 { /* Inline kernel#Int#+ (var_res,var14) */
 349 var17 = var_res + var14;
 350 var15 = var17;
 351 goto RET_LABEL16;
 352 RET_LABEL16:(void)0;
 353 }
 354 var_res = var15;
 355 } else {
 356 }
 357 var18 = 1;
 358 { /* Inline kernel#Int#+ (var_i,var18) */
 359 var21 = var_i + var18;
 360 var19 = var21;
 361 goto RET_LABEL20;
 362 RET_LABEL20:(void)0;
 363 }
 364 var_i = var19;
 365 CONTINUE_label: (void)0;
 366 }
 367 BREAK_label: (void)0;
 368 var = var_res;
 369 goto RET_LABEL;
 370 RET_LABEL:;
 371 return var;
 372 }
 373 /* method array#AbstractArrayRead#count for (self: Object, nullable Object): Int */
 374 long VIRTUAL_array__AbstractArrayRead__count(val* self, val* p0) {
 375 long var /* : Int */;
 376 long var1 /* : Int */;
 377 var1 = array__AbstractArrayRead__count(self, p0);
 378 var = var1;
 379 RET_LABEL:;
 380 return var;
 381 }
 382 /* method array#AbstractArrayRead#index_of for (self: AbstractArrayRead[nullable Object], nullable Object): Int */
 383 long array__AbstractArrayRead__index_of(val* self, val* p0) {
 384 long var /* : Int */;
 385 short int var1 /* : Bool */;
 386 int cltype;
 387 int idtype;
 388 const struct type* type_struct;
 389 short int is_nullable;
 390 const char* var_class_name;
 391 val* var_item /* var item: nullable Object */;
 392 long var2 /* : Int */;
 393 long var3 /* : Int */;
 394 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa SequenceRead#0 */
 395 /* <p0:nullable Object> isa SequenceRead#0 */
 396 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__SequenceRead_FT0];
 397 cltype = type_struct->color;
 398 idtype = type_struct->id;
 399 is_nullable = type_struct->is_nullable;
 400 if(p0 == NULL) {
 401 var1 = is_nullable;
 402 } else {
 403 if(cltype >= p0->type->table_size) {
 404 var1 = 0;
 405 } else {
 406 var1 = p0->type->type_table[cltype] == idtype;
 407 }
 408 }
 409 if (!var1) {
 410 var_class_name = p0 == NULL ? "null" : p0->type->name;
 411 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "SequenceRead#0", var_class_name);
 412 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 62);
 413 show_backtrace(1);
 414 }
 415 var_item = p0;
 416 var2 = 0;
 417 var3 = ((long (*)(val*, val*, long))(self->class->vft[COLOR_array__AbstractArrayRead__index_of_from]))(self, var_item, var2) /* index_of_from on <self:AbstractArrayRead[nullable Object]>*/;
 418 var = var3;
 419 goto RET_LABEL;
 420 RET_LABEL:;
 421 return var;
 422 }
 423 /* method array#AbstractArrayRead#index_of for (self: Object, nullable Object): Int */
 424 long VIRTUAL_array__AbstractArrayRead__index_of(val* self, val* p0) {
 425 long var /* : Int */;
 426 long var1 /* : Int */;
 427 var1 = array__AbstractArrayRead__index_of(self, p0);
 428 var = var1;
 429 RET_LABEL:;
 430 return var;
 431 }
 432 /* method array#AbstractArrayRead#last_index_of for (self: AbstractArrayRead[nullable Object], nullable Object): Int */
 433 long array__AbstractArrayRead__last_index_of(val* self, val* p0) {
 434 long var /* : Int */;
 435 short int var1 /* : Bool */;
 436 int cltype;
 437 int idtype;
 438 const struct type* type_struct;
 439 short int is_nullable;
 440 const char* var_class_name;
 441 val* var_item /* var item: nullable Object */;
 442 long var2 /* : Int */;
 443 long var3 /* : Int */;
 444 long var4 /* : Int */;
 445 long var6 /* : Int */;
 446 long var7 /* : Int */;
 447 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa AbstractArrayRead#0 */
 448 /* <p0:nullable Object> isa AbstractArrayRead#0 */
 449 type_struct = self->type->resolution_table->types[COLOR_array__AbstractArrayRead_FT0];
 450 cltype = type_struct->color;
 451 idtype = type_struct->id;
 452 is_nullable = type_struct->is_nullable;
 453 if(p0 == NULL) {
 454 var1 = is_nullable;
 455 } else {
 456 if(cltype >= p0->type->table_size) {
 457 var1 = 0;
 458 } else {
 459 var1 = p0->type->type_table[cltype] == idtype;
 460 }
 461 }
 462 if (!var1) {
 463 var_class_name = p0 == NULL ? "null" : p0->type->name;
 464 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "AbstractArrayRead#0", var_class_name);
 465 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 64);
 466 show_backtrace(1);
 467 }
 468 var_item = p0;
 469 var2 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:AbstractArrayRead[nullable Object]>*/;
 470 var3 = 1;
 471 { /* Inline kernel#Int#- (var2,var3) */
 472 var6 = var2 - var3;
 473 var4 = var6;
 474 goto RET_LABEL5;
 475 RET_LABEL5:(void)0;
 476 }
 477 var7 = ((long (*)(val*, val*, long))(self->class->vft[COLOR_array__AbstractArrayRead__last_index_of_from]))(self, var_item, var4) /* last_index_of_from on <self:AbstractArrayRead[nullable Object]>*/;
 478 var = var7;
 479 goto RET_LABEL;
 480 RET_LABEL:;
 481 return var;
 482 }
 483 /* method array#AbstractArrayRead#last_index_of for (self: Object, nullable Object): Int */
 484 long VIRTUAL_array__AbstractArrayRead__last_index_of(val* self, val* p0) {
 485 long var /* : Int */;
 486 long var1 /* : Int */;
 487 var1 = array__AbstractArrayRead__last_index_of(self, p0);
 488 var = var1;
 489 RET_LABEL:;
 490 return var;
 491 }
 492 /* method array#AbstractArrayRead#index_of_from for (self: AbstractArrayRead[nullable Object], nullable Object, Int): Int */
 493 long array__AbstractArrayRead__index_of_from(val* self, val* p0, long p1) {
 494 long var /* : Int */;
 495 short int var1 /* : Bool */;
 496 int cltype;
 497 int idtype;
 498 const struct type* type_struct;
 499 short int is_nullable;
 500 const char* var_class_name;
 501 val* var_item /* var item: nullable Object */;
 502 long var_pos /* var pos: Int */;
 503 long var_i /* var i: Int */;
 504 long var2 /* : Int */;
 505 long var_len /* var len: Int */;
 506 short int var3 /* : Bool */;
 507 short int var5 /* : Bool */;
 508 int cltype6;
 509 int idtype7;
 510 const char* var_class_name8;
 511 short int var9 /* : Bool */;
 512 val* var10 /* : nullable Object */;
 513 short int var11 /* : Bool */;
 514 long var12 /* : Int */;
 515 long var13 /* : Int */;
 516 long var15 /* : Int */;
 517 long var16 /* : Int */;
 518 long var17 /* : Int */;
 519 long var19 /* : Int */;
 520 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa AbstractArrayRead#0 */
 521 /* <p0:nullable Object> isa AbstractArrayRead#0 */
 522 type_struct = self->type->resolution_table->types[COLOR_array__AbstractArrayRead_FT0];
 523 cltype = type_struct->color;
 524 idtype = type_struct->id;
 525 is_nullable = type_struct->is_nullable;
 526 if(p0 == NULL) {
 527 var1 = is_nullable;
 528 } else {
 529 if(cltype >= p0->type->table_size) {
 530 var1 = 0;
 531 } else {
 532 var1 = p0->type->type_table[cltype] == idtype;
 533 }
 534 }
 535 if (!var1) {
 536 var_class_name = p0 == NULL ? "null" : p0->type->name;
 537 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "AbstractArrayRead#0", var_class_name);
 538 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 68);
 539 show_backtrace(1);
 540 }
 541 var_item = p0;
 542 var_pos = p1;
 543 var_i = var_pos;
 544 var2 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:AbstractArrayRead[nullable Object]>*/;
 545 var_len = var2;
 546 for(;;) {
 547 { /* Inline kernel#Int#< (var_i,var_len) */
 548 /* Covariant cast for argument 0 (i) <var_len:Int> isa OTHER */
 549 /* <var_len:Int> isa OTHER */
 550 var5 = 1; /* easy <var_len:Int> isa OTHER*/
 551 if (!var5) {
 552 var_class_name8 = type_kernel__Int.name;
 553 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name8);
 554 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 261);
 555 show_backtrace(1);
 556 }
 557 var9 = var_i < var_len;
 558 var3 = var9;
 559 goto RET_LABEL4;
 560 RET_LABEL4:(void)0;
 561 }
 562 if (!var3) break;
 563 var10 = ((val* (*)(val*, long))(self->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(self, var_i) /* [] on <self:AbstractArrayRead[nullable Object]>*/;
 564 if (var10 == NULL) {
 565 var11 = (var_item == NULL);
 566 } else {
 567 var11 = ((short int (*)(val*, val*))(var10->class->vft[COLOR_kernel__Object___61d_61d]))(var10, var_item) /* == on <var10:nullable Object>*/;
 568 }
 569 if (var11){
 570 var = var_i;
 571 goto RET_LABEL;
 572 } else {
 573 }
 574 var12 = 1;
 575 { /* Inline kernel#Int#+ (var_i,var12) */
 576 var15 = var_i + var12;
 577 var13 = var15;
 578 goto RET_LABEL14;
 579 RET_LABEL14:(void)0;
 580 }
 581 var_i = var13;
 582 CONTINUE_label: (void)0;
 583 }
 584 BREAK_label: (void)0;
 585 var16 = 1;
 586 { /* Inline kernel#Int#unary - (var16) */
 587 var19 = -var16;
 588 var17 = var19;
 589 goto RET_LABEL18;
 590 RET_LABEL18:(void)0;
 591 }
 592 var = var17;
 593 goto RET_LABEL;
 594 RET_LABEL:;
 595 return var;
 596 }
 597 /* method array#AbstractArrayRead#index_of_from for (self: Object, nullable Object, Int): Int */
 598 long VIRTUAL_array__AbstractArrayRead__index_of_from(val* self, val* p0, long p1) {
 599 long var /* : Int */;
 600 long var1 /* : Int */;
 601 var1 = array__AbstractArrayRead__index_of_from(self, p0, p1);
 602 var = var1;
 603 RET_LABEL:;
 604 return var;
 605 }
 606 /* method array#AbstractArrayRead#last_index_of_from for (self: AbstractArrayRead[nullable Object], nullable Object, Int): Int */
 607 long array__AbstractArrayRead__last_index_of_from(val* self, val* p0, long p1) {
 608 long var /* : Int */;
 609 short int var1 /* : Bool */;
 610 int cltype;
 611 int idtype;
 612 const struct type* type_struct;
 613 short int is_nullable;
 614 const char* var_class_name;
 615 val* var_item /* var item: nullable Object */;
 616 long var_pos /* var pos: Int */;
 617 long var_i /* var i: Int */;
 618 long var2 /* : Int */;
 619 short int var3 /* : Bool */;
 620 short int var5 /* : Bool */;
 621 int cltype6;
 622 int idtype7;
 623 const char* var_class_name8;
 624 short int var9 /* : Bool */;
 625 val* var10 /* : nullable Object */;
 626 short int var11 /* : Bool */;
 627 long var12 /* : Int */;
 628 long var13 /* : Int */;
 629 long var15 /* : Int */;
 630 long var16 /* : Int */;
 631 long var17 /* : Int */;
 632 long var19 /* : Int */;
 633 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa AbstractArrayRead#0 */
 634 /* <p0:nullable Object> isa AbstractArrayRead#0 */
 635 type_struct = self->type->resolution_table->types[COLOR_array__AbstractArrayRead_FT0];
 636 cltype = type_struct->color;
 637 idtype = type_struct->id;
 638 is_nullable = type_struct->is_nullable;
 639 if(p0 == NULL) {
 640 var1 = is_nullable;
 641 } else {
 642 if(cltype >= p0->type->table_size) {
 643 var1 = 0;
 644 } else {
 645 var1 = p0->type->type_table[cltype] == idtype;
 646 }
 647 }
 648 if (!var1) {
 649 var_class_name = p0 == NULL ? "null" : p0->type->name;
 650 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "AbstractArrayRead#0", var_class_name);
 651 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 83);
 652 show_backtrace(1);
 653 }
 654 var_item = p0;
 655 var_pos = p1;
 656 var_i = var_pos;
 657 for(;;) {
 658 var2 = 0;
 659 { /* Inline kernel#Int#>= (var_i,var2) */
 660 /* Covariant cast for argument 0 (i) <var2:Int> isa OTHER */
 661 /* <var2:Int> isa OTHER */
 662 var5 = 1; /* easy <var2:Int> isa OTHER*/
 663 if (!var5) {
 664 var_class_name8 = type_kernel__Int.name;
 665 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name8);
 666 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 262);
 667 show_backtrace(1);
 668 }
 669 var9 = var_i >= var2;
 670 var3 = var9;
 671 goto RET_LABEL4;
 672 RET_LABEL4:(void)0;
 673 }
 674 if (!var3) break;
 675 var10 = ((val* (*)(val*, long))(self->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(self, var_i) /* [] on <self:AbstractArrayRead[nullable Object]>*/;
 676 if (var10 == NULL) {
 677 var11 = (var_item == NULL);
 678 } else {
 679 var11 = ((short int (*)(val*, val*))(var10->class->vft[COLOR_kernel__Object___61d_61d]))(var10, var_item) /* == on <var10:nullable Object>*/;
 680 }
 681 if (var11){
 682 var = var_i;
 683 goto RET_LABEL;
 684 } else {
 685 var12 = 1;
 686 { /* Inline kernel#Int#- (var_i,var12) */
 687 var15 = var_i - var12;
 688 var13 = var15;
 689 goto RET_LABEL14;
 690 RET_LABEL14:(void)0;
 691 }
 692 var_i = var13;
 693 }
 694 CONTINUE_label: (void)0;
 695 }
 696 BREAK_label: (void)0;
 697 var16 = 1;
 698 { /* Inline kernel#Int#unary - (var16) */
 699 var19 = -var16;
 700 var17 = var19;
 701 goto RET_LABEL18;
 702 RET_LABEL18:(void)0;
 703 }
 704 var = var17;
 705 goto RET_LABEL;
 706 RET_LABEL:;
 707 return var;
 708 }
 709 /* method array#AbstractArrayRead#last_index_of_from for (self: Object, nullable Object, Int): Int */
 710 long VIRTUAL_array__AbstractArrayRead__last_index_of_from(val* self, val* p0, long p1) {
 711 long var /* : Int */;
 712 long var1 /* : Int */;
 713 var1 = array__AbstractArrayRead__last_index_of_from(self, p0, p1);
 714 var = var1;
 715 RET_LABEL:;
 716 return var;
 717 }
 718 /* method array#AbstractArrayRead#reversed for (self: AbstractArrayRead[nullable Object]): Array[nullable Object] */
 719 val* array__AbstractArrayRead__reversed(val* self) {
 720 val* var /* : Array[nullable Object] */;
 721 long var1 /* : Int */;
 722 long var_cmp /* var cmp: Int */;
 723 val* var2 /* : Array[nullable Object] */;
 724 val* var_result /* var result: Array[nullable Object] */;
 725 long var3 /* : Int */;
 726 short int var4 /* : Bool */;
 727 short int var6 /* : Bool */;
 728 int cltype;
 729 int idtype;
 730 const char* var_class_name;
 731 short int var7 /* : Bool */;
 732 long var8 /* : Int */;
 733 long var9 /* : Int */;
 734 long var11 /* : Int */;
 735 val* var12 /* : nullable Object */;
 736 var1 = self->attrs[COLOR_array__AbstractArrayRead___length].l; /* _length on <self:AbstractArrayRead[nullable Object]> */
 737 var_cmp = var1;
 738 var2 = NEW_array__Array(self->type->resolution_table->types[COLOR_array__Arrayarray__AbstractArrayRead_FT0]);
 739 ((void (*)(val*, long))(var2->class->vft[COLOR_array__Array__with_capacity]))(var2, var_cmp) /* with_capacity on <var2:Array[nullable Object]>*/;
 740 var_result = var2;
 741 for(;;) {
 742 var3 = 0;
 743 { /* Inline kernel#Int#> (var_cmp,var3) */
 744 /* Covariant cast for argument 0 (i) <var3:Int> isa OTHER */
 745 /* <var3:Int> isa OTHER */
 746 var6 = 1; /* easy <var3:Int> isa OTHER*/
 747 if (!var6) {
 748 var_class_name = type_kernel__Int.name;
 749 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
 750 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 263);
 751 show_backtrace(1);
 752 }
 753 var7 = var_cmp > var3;
 754 var4 = var7;
 755 goto RET_LABEL5;
 756 RET_LABEL5:(void)0;
 757 }
 758 if (!var4) break;
 759 var8 = 1;
 760 { /* Inline kernel#Int#- (var_cmp,var8) */
 761 var11 = var_cmp - var8;
 762 var9 = var11;
 763 goto RET_LABEL10;
 764 RET_LABEL10:(void)0;
 765 }
 766 var_cmp = var9;
 767 var12 = ((val* (*)(val*, long))(self->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(self, var_cmp) /* [] on <self:AbstractArrayRead[nullable Object]>*/;
 768 ((void (*)(val*, val*))(var_result->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_result, var12) /* add on <var_result:Array[nullable Object]>*/;
 769 CONTINUE_label: (void)0;
 770 }
 771 BREAK_label: (void)0;
 772 var = var_result;
 773 goto RET_LABEL;
 774 RET_LABEL:;
 775 return var;
 776 }
 777 /* method array#AbstractArrayRead#reversed for (self: Object): Array[nullable Object] */
 778 val* VIRTUAL_array__AbstractArrayRead__reversed(val* self) {
 779 val* var /* : Array[nullable Object] */;
 780 val* var1 /* : Array[nullable Object] */;
 781 var1 = array__AbstractArrayRead__reversed(self);
 782 var = var1;
 783 RET_LABEL:;
 784 return var;
 785 }
 786 /* method array#AbstractArrayRead#copy_to for (self: AbstractArrayRead[nullable Object], Int, Int, AbstractArray[nullable Object], Int) */
 787 void array__AbstractArrayRead__copy_to(val* self, long p0, long p1, val* p2, long p3) {
 788 short int var /* : Bool */;
 789 int cltype;
 790 int idtype;
 791 const struct type* type_struct;
 792 const char* var_class_name;
 793 long var_start /* var start: Int */;
 794 long var_len /* var len: Int */;
 795 val* var_dest /* var dest: AbstractArray[nullable Object] */;
 796 long var_new_start /* var new_start: Int */;
 797 long var_i /* var i: Int */;
 798 long var1 /* : Int */;
 799 short int var2 /* : Bool */;
 800 short int var4 /* : Bool */;
 801 int cltype5;
 802 int idtype6;
 803 const char* var_class_name7;
 804 short int var8 /* : Bool */;
 805 long var9 /* : Int */;
 806 long var10 /* : Int */;
 807 long var12 /* : Int */;
 808 long var13 /* : Int */;
 809 long var15 /* : Int */;
 810 long var16 /* : Int */;
 811 long var18 /* : Int */;
 812 val* var19 /* : nullable Object */;
 813 /* Covariant cast for argument 2 (dest) <p2:AbstractArray[nullable Object]> isa AbstractArray[AbstractArrayRead#0] */
 814 /* <p2:AbstractArray[nullable Object]> isa AbstractArray[AbstractArrayRead#0] */
 815 type_struct = self->type->resolution_table->types[COLOR_array__AbstractArrayarray__AbstractArrayRead_FT0];
 816 cltype = type_struct->color;
 817 idtype = type_struct->id;
 818 if(cltype >= p2->type->table_size) {
 819 var = 0;
 820 } else {
 821 var = p2->type->type_table[cltype] == idtype;
 822 }
 823 if (!var) {
 824 var_class_name = p2 == NULL ? "null" : p2->type->name;
 825 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "AbstractArray[AbstractArrayRead#0]", var_class_name);
 826 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 112);
 827 show_backtrace(1);
 828 }
 829 var_start = p0;
 830 var_len = p1;
 831 var_dest = p2;
 832 var_new_start = p3;
 833 var_i = var_len;
 834 for(;;) {
 835 var1 = 0;
 836 { /* Inline kernel#Int#> (var_i,var1) */
 837 /* Covariant cast for argument 0 (i) <var1:Int> isa OTHER */
 838 /* <var1:Int> isa OTHER */
 839 var4 = 1; /* easy <var1:Int> isa OTHER*/
 840 if (!var4) {
 841 var_class_name7 = type_kernel__Int.name;
 842 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name7);
 843 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 263);
 844 show_backtrace(1);
 845 }
 846 var8 = var_i > var1;
 847 var2 = var8;
 848 goto RET_LABEL3;
 849 RET_LABEL3:(void)0;
 850 }
 851 if (!var2) break;
 852 var9 = 1;
 853 { /* Inline kernel#Int#- (var_i,var9) */
 854 var12 = var_i - var9;
 855 var10 = var12;
 856 goto RET_LABEL11;
 857 RET_LABEL11:(void)0;
 858 }
 859 var_i = var10;
 860 { /* Inline kernel#Int#+ (var_new_start,var_i) */
 861 var15 = var_new_start + var_i;
 862 var13 = var15;
 863 goto RET_LABEL14;
 864 RET_LABEL14:(void)0;
 865 }
 866 { /* Inline kernel#Int#+ (var_start,var_i) */
 867 var18 = var_start + var_i;
 868 var16 = var18;
 869 goto RET_LABEL17;
 870 RET_LABEL17:(void)0;
 871 }
 872 var19 = ((val* (*)(val*, long))(self->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(self, var16) /* [] on <self:AbstractArrayRead[nullable Object]>*/;
 873 ((void (*)(val*, long, val*))(var_dest->class->vft[COLOR_abstract_collection__Sequence___91d_93d_61d]))(var_dest, var13, var19) /* []= on <var_dest:AbstractArray[nullable Object]>*/;
 874 CONTINUE_label: (void)0;
 875 }
 876 BREAK_label: (void)0;
 877 RET_LABEL:;
 878 }
 879 /* method array#AbstractArrayRead#copy_to for (self: Object, Int, Int, AbstractArray[nullable Object], Int) */
 880 void VIRTUAL_array__AbstractArrayRead__copy_to(val* self, long p0, long p1, val* p2, long p3) {
 881 array__AbstractArrayRead__copy_to(self, p0, p1, p2, p3);
 882 RET_LABEL:;
 883 }
 884 /* method array#AbstractArrayRead#output for (self: AbstractArrayRead[nullable Object]) */
 885 void array__AbstractArrayRead__output(val* self) {
 886 long var /* : Int */;
 887 long var_i /* var i: Int */;
 888 long var1 /* : Int */;
 889 long var_l /* var l: Int */;
 890 short int var2 /* : Bool */;
 891 short int var4 /* : Bool */;
 892 int cltype;
 893 int idtype;
 894 const char* var_class_name;
 895 short int var5 /* : Bool */;
 896 val* var6 /* : nullable Object */;
 897 val* var_e /* var e: nullable Object */;
 898 val* var7 /* : null */;
 899 short int var8 /* : Bool */;
 900 long var9 /* : Int */;
 901 long var10 /* : Int */;
 902 long var12 /* : Int */;
 903 var = 0;
 904 var_i = var;
 905 var1 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:AbstractArrayRead[nullable Object]>*/;
 906 var_l = var1;
 907 for(;;) {
 908 { /* Inline kernel#Int#< (var_i,var_l) */
 909 /* Covariant cast for argument 0 (i) <var_l:Int> isa OTHER */
 910 /* <var_l:Int> isa OTHER */
 911 var4 = 1; /* easy <var_l:Int> isa OTHER*/
 912 if (!var4) {
 913 var_class_name = type_kernel__Int.name;
 914 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
 915 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 261);
 916 show_backtrace(1);
 917 }
 918 var5 = var_i < var_l;
 919 var2 = var5;
 920 goto RET_LABEL3;
 921 RET_LABEL3:(void)0;
 922 }
 923 if (!var2) break;
 924 var6 = ((val* (*)(val*, long))(self->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(self, var_i) /* [] on <self:AbstractArrayRead[nullable Object]>*/;
 925 var_e = var6;
 926 var7 = NULL;
 927 if (var_e == NULL) {
 928 var8 = 0; /* is null */
 929 } else {
 930 var8 = 1; /* arg is null and recv is not */
 931 }
 932 if (var8){
 933 if (var_e == NULL) {
 934 fprintf(stderr, "Runtime error: %s", "Reciever is null");
 935 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 134);
 936 show_backtrace(1);
 937 } else {
 938 ((void (*)(val*))(var_e->class->vft[COLOR_kernel__Object__output]))(var_e) /* output on <var_e:nullable Object>*/;
 939 }
 940 } else {
 941 }
 942 var9 = 1;
 943 { /* Inline kernel#Int#+ (var_i,var9) */
 944 var12 = var_i + var9;
 945 var10 = var12;
 946 goto RET_LABEL11;
 947 RET_LABEL11:(void)0;
 948 }
 949 var_i = var10;
 950 CONTINUE_label: (void)0;
 951 }
 952 BREAK_label: (void)0;
 953 RET_LABEL:;
 954 }
 955 /* method array#AbstractArrayRead#output for (self: Object) */
 956 void VIRTUAL_array__AbstractArrayRead__output(val* self) {
 957 array__AbstractArrayRead__output(self);
 958 RET_LABEL:;
 959 }
 960 /* method array#AbstractArrayRead#iterator for (self: AbstractArrayRead[nullable Object]): ArrayIterator[nullable Object] */
 961 val* array__AbstractArrayRead__iterator(val* self) {
 962 val* var /* : ArrayIterator[nullable Object] */;
 963 val* var1 /* : ArrayIterator[nullable Object] */;
 964 var1 = NEW_array__ArrayIterator(self->type->resolution_table->types[COLOR_array__ArrayIteratorarray__AbstractArrayRead_FT0]);
 965 ((void (*)(val*, val*))(var1->class->vft[COLOR_array__ArrayIterator__init]))(var1, self) /* init on <var1:ArrayIterator[nullable Object]>*/;
 966 var = var1;
 967 goto RET_LABEL;
 968 RET_LABEL:;
 969 return var;
 970 }
 971 /* method array#AbstractArrayRead#iterator for (self: Object): Iterator[nullable Object] */
 972 val* VIRTUAL_array__AbstractArrayRead__iterator(val* self) {
 973 val* var /* : Iterator[nullable Object] */;
 974 val* var1 /* : ArrayIterator[nullable Object] */;
 975 var1 = array__AbstractArrayRead__iterator(self);
 976 var = var1;
 977 RET_LABEL:;
 978 return var;
 979 }
 980 /* method array#AbstractArrayRead#init for (self: AbstractArrayRead[nullable Object]) */
 981 void array__AbstractArrayRead__init(val* self) {
 982 RET_LABEL:;
 983 }
 984 /* method array#AbstractArrayRead#init for (self: Object) */
 985 void VIRTUAL_array__AbstractArrayRead__init(val* self) {
 986 array__AbstractArrayRead__init(self);
 987 RET_LABEL:;
 988 }
 989 /* method array#AbstractArray#enlarge for (self: AbstractArray[nullable Object], Int) */
 990 void array__AbstractArray__enlarge(val* self, long p0) {
 991 const char* var_class_name;
 992 var_class_name = self == NULL ? "null" : self->type->name;
 993 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "enlarge", var_class_name);
 994 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 147);
 995 show_backtrace(1);
 996 RET_LABEL:;
 997 }
 998 /* method array#AbstractArray#enlarge for (self: Object, Int) */
 999 void VIRTUAL_array__AbstractArray__enlarge(val* self, long p0) {
1000 array__AbstractArray__enlarge(self, p0);
1001 RET_LABEL:;
1002 }
1003 /* method array#AbstractArray#push for (self: AbstractArray[nullable Object], nullable Object) */
1004 void array__AbstractArray__push(val* self, val* p0) {
1005 short int var /* : Bool */;
1006 int cltype;
1007 int idtype;
1008 const struct type* type_struct;
1009 short int is_nullable;
1010 const char* var_class_name;
1011 val* var_item /* var item: nullable Object */;
1012 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa Sequence#0 */
1013 /* <p0:nullable Object> isa Sequence#0 */
1014 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Sequence_FT0];
1015 cltype = type_struct->color;
1016 idtype = type_struct->id;
1017 is_nullable = type_struct->is_nullable;
1018 if(p0 == NULL) {
1019 var = is_nullable;
1020 } else {
1021 if(cltype >= p0->type->table_size) {
1022 var = 0;
1023 } else {
1024 var = p0->type->type_table[cltype] == idtype;
1025 }
1026 }
1027 if (!var) {
1028 var_class_name = p0 == NULL ? "null" : p0->type->name;
1029 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Sequence#0", var_class_name);
1030 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 152);
1031 show_backtrace(1);
1032 }
1033 var_item = p0;
1034 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(self, var_item) /* add on <self:AbstractArray[nullable Object]>*/;
1035 RET_LABEL:;
1036 }
1037 /* method array#AbstractArray#push for (self: Object, nullable Object) */
1038 void VIRTUAL_array__AbstractArray__push(val* self, val* p0) {
1039 array__AbstractArray__push(self, p0);
1040 RET_LABEL:;
1041 }
1042 /* method array#AbstractArray#pop for (self: AbstractArray[nullable Object]): nullable Object */
1043 val* array__AbstractArray__pop(val* self) {
1044 val* var /* : nullable Object */;
1045 short int var1 /* : Bool */;
1046 short int var2 /* : Bool */;
1047 val* var3 /* : nullable Object */;
1048 val* var_r /* var r: nullable Object */;
1049 val* var_ /* var : AbstractArray[nullable Object] */;
1050 long var4 /* : Int */;
1051 long var5 /* : Int */;
1052 long var6 /* : Int */;
1053 long var8 /* : Int */;
1054 var1 = ((short int (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__is_empty]))(self) /* is_empty on <self:AbstractArray[nullable Object]>*/;
1055 var2 = !var1;
1056 if (!var2) {
1057 fprintf(stderr, "Runtime error: %s", "Assert \'not_empty\' failed");
1058 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 156);
1059 show_backtrace(1);
1060 }
1061 var3 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__SequenceRead__last]))(self) /* last on <self:AbstractArray[nullable Object]>*/;
1062 var_r = var3;
1063 var_ = self;
1064 var4 = var_->attrs[COLOR_array__AbstractArrayRead___length].l; /* _length on <var_:AbstractArray[nullable Object]> */
1065 var5 = 1;
1066 { /* Inline kernel#Int#- (var4,var5) */
1067 var8 = var4 - var5;
1068 var6 = var8;
1069 goto RET_LABEL7;
1070 RET_LABEL7:(void)0;
1071 }
1072 var_->attrs[COLOR_array__AbstractArrayRead___length].l = var6; /* _length on <var_:AbstractArray[nullable Object]> */
1073 var = var_r;
1074 goto RET_LABEL;
1075 RET_LABEL:;
1076 return var;
1077 }
1078 /* method array#AbstractArray#pop for (self: Object): nullable Object */
1079 val* VIRTUAL_array__AbstractArray__pop(val* self) {
1080 val* var /* : nullable Object */;
1081 val* var1 /* : nullable Object */;
1082 var1 = array__AbstractArray__pop(self);
1083 var = var1;
1084 RET_LABEL:;
1085 return var;
1086 }
1087 /* method array#AbstractArray#shift for (self: AbstractArray[nullable Object]): nullable Object */
1088 val* array__AbstractArray__shift(val* self) {
1089 val* var /* : nullable Object */;
1090 short int var1 /* : Bool */;
1091 short int var2 /* : Bool */;
1092 val* var3 /* : nullable Object */;
1093 val* var_r /* var r: nullable Object */;
1094 long var4 /* : Int */;
1095 long var_i /* var i: Int */;
1096 long var5 /* : Int */;
1097 long var_l /* var l: Int */;
1098 short int var6 /* : Bool */;
1099 short int var8 /* : Bool */;
1100 int cltype;
1101 int idtype;
1102 const char* var_class_name;
1103 short int var9 /* : Bool */;
1104 long var10 /* : Int */;
1105 long var11 /* : Int */;
1106 long var13 /* : Int */;
1107 val* var14 /* : nullable Object */;
1108 long var15 /* : Int */;
1109 long var16 /* : Int */;
1110 long var18 /* : Int */;
1111 long var19 /* : Int */;
1112 long var20 /* : Int */;
1113 long var22 /* : Int */;
1114 var1 = ((short int (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__is_empty]))(self) /* is_empty on <self:AbstractArray[nullable Object]>*/;
1115 var2 = !var1;
1116 if (!var2) {
1117 fprintf(stderr, "Runtime error: %s", "Assert \'not_empty\' failed");
1118 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 164);
1119 show_backtrace(1);
1120 }
1121 var3 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__first]))(self) /* first on <self:AbstractArray[nullable Object]>*/;
1122 var_r = var3;
1123 var4 = 1;
1124 var_i = var4;
1125 var5 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:AbstractArray[nullable Object]>*/;
1126 var_l = var5;
1127 for(;;) {
1128 { /* Inline kernel#Int#< (var_i,var_l) */
1129 /* Covariant cast for argument 0 (i) <var_l:Int> isa OTHER */
1130 /* <var_l:Int> isa OTHER */
1131 var8 = 1; /* easy <var_l:Int> isa OTHER*/
1132 if (!var8) {
1133 var_class_name = type_kernel__Int.name;
1134 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
1135 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 261);
1136 show_backtrace(1);
1137 }
1138 var9 = var_i < var_l;
1139 var6 = var9;
1140 goto RET_LABEL7;
1141 RET_LABEL7:(void)0;
1142 }
1143 if (!var6) break;
1144 var10 = 1;
1145 { /* Inline kernel#Int#- (var_i,var10) */
1146 var13 = var_i - var10;
1147 var11 = var13;
1148 goto RET_LABEL12;
1149 RET_LABEL12:(void)0;
1150 }
1151 var14 = ((val* (*)(val*, long))(self->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(self, var_i) /* [] on <self:AbstractArray[nullable Object]>*/;
1152 ((void (*)(val*, long, val*))(self->class->vft[COLOR_abstract_collection__Sequence___91d_93d_61d]))(self, var11, var14) /* []= on <self:AbstractArray[nullable Object]>*/;
1153 var15 = 1;
1154 { /* Inline kernel#Int#+ (var_i,var15) */
1155 var18 = var_i + var15;
1156 var16 = var18;
1157 goto RET_LABEL17;
1158 RET_LABEL17:(void)0;
1159 }
1160 var_i = var16;
1161 CONTINUE_label: (void)0;
1162 }
1163 BREAK_label: (void)0;
1164 var19 = 1;
1165 { /* Inline kernel#Int#- (var_l,var19) */
1166 var22 = var_l - var19;
1167 var20 = var22;
1168 goto RET_LABEL21;
1169 RET_LABEL21:(void)0;
1170 }
1171 self->attrs[COLOR_array__AbstractArrayRead___length].l = var20; /* _length on <self:AbstractArray[nullable Object]> */
1172 var = var_r;
1173 goto RET_LABEL;
1174 RET_LABEL:;
1175 return var;
1176 }
1177 /* method array#AbstractArray#shift for (self: Object): nullable Object */
1178 val* VIRTUAL_array__AbstractArray__shift(val* self) {
1179 val* var /* : nullable Object */;
1180 val* var1 /* : nullable Object */;
1181 var1 = array__AbstractArray__shift(self);
1182 var = var1;
1183 RET_LABEL:;
1184 return var;
1185 }
1186 /* method array#AbstractArray#unshift for (self: AbstractArray[nullable Object], nullable Object) */
1187 void array__AbstractArray__unshift(val* self, val* p0) {
1188 short int var /* : Bool */;
1189 int cltype;
1190 int idtype;
1191 const struct type* type_struct;
1192 short int is_nullable;
1193 const char* var_class_name;
1194 val* var_item /* var item: nullable Object */;
1195 long var1 /* : Int */;
1196 long var2 /* : Int */;
1197 long var3 /* : Int */;
1198 long var5 /* : Int */;
1199 long var_i /* var i: Int */;
1200 long var6 /* : Int */;
1201 short int var7 /* : Bool */;
1202 short int var9 /* : Bool */;
1203 int cltype10;
1204 int idtype11;
1205 const char* var_class_name12;
1206 short int var13 /* : Bool */;
1207 long var14 /* : Int */;
1208 long var15 /* : Int */;
1209 long var17 /* : Int */;
1210 val* var18 /* : nullable Object */;
1211 long var19 /* : Int */;
1212 long var20 /* : Int */;
1213 long var22 /* : Int */;
1214 long var23 /* : Int */;
1215 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa Sequence#0 */
1216 /* <p0:nullable Object> isa Sequence#0 */
1217 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Sequence_FT0];
1218 cltype = type_struct->color;
1219 idtype = type_struct->id;
1220 is_nullable = type_struct->is_nullable;
1221 if(p0 == NULL) {
1222 var = is_nullable;
1223 } else {
1224 if(cltype >= p0->type->table_size) {
1225 var = 0;
1226 } else {
1227 var = p0->type->type_table[cltype] == idtype;
1228 }
1229 }
1230 if (!var) {
1231 var_class_name = p0 == NULL ? "null" : p0->type->name;
1232 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Sequence#0", var_class_name);
1233 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 176);
1234 show_backtrace(1);
1235 }
1236 var_item = p0;
1237 var1 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:AbstractArray[nullable Object]>*/;
1238 var2 = 1;
1239 { /* Inline kernel#Int#- (var1,var2) */
1240 var5 = var1 - var2;
1241 var3 = var5;
1242 goto RET_LABEL4;
1243 RET_LABEL4:(void)0;
1244 }
1245 var_i = var3;
1246 for(;;) {
1247 var6 = 0;
1248 { /* Inline kernel#Int#> (var_i,var6) */
1249 /* Covariant cast for argument 0 (i) <var6:Int> isa OTHER */
1250 /* <var6:Int> isa OTHER */
1251 var9 = 1; /* easy <var6:Int> isa OTHER*/
1252 if (!var9) {
1253 var_class_name12 = type_kernel__Int.name;
1254 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name12);
1255 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 263);
1256 show_backtrace(1);
1257 }
1258 var13 = var_i > var6;
1259 var7 = var13;
1260 goto RET_LABEL8;
1261 RET_LABEL8:(void)0;
1262 }
1263 if (!var7) break;
1264 var14 = 1;
1265 { /* Inline kernel#Int#+ (var_i,var14) */
1266 var17 = var_i + var14;
1267 var15 = var17;
1268 goto RET_LABEL16;
1269 RET_LABEL16:(void)0;
1270 }
1271 var18 = ((val* (*)(val*, long))(self->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(self, var_i) /* [] on <self:AbstractArray[nullable Object]>*/;
1272 ((void (*)(val*, long, val*))(self->class->vft[COLOR_abstract_collection__Sequence___91d_93d_61d]))(self, var15, var18) /* []= on <self:AbstractArray[nullable Object]>*/;
1273 var19 = 1;
1274 { /* Inline kernel#Int#- (var_i,var19) */
1275 var22 = var_i - var19;
1276 var20 = var22;
1277 goto RET_LABEL21;
1278 RET_LABEL21:(void)0;
1279 }
1280 var_i = var20;
1281 CONTINUE_label: (void)0;
1282 }
1283 BREAK_label: (void)0;
1284 var23 = 0;
1285 ((void (*)(val*, long, val*))(self->class->vft[COLOR_abstract_collection__Sequence___91d_93d_61d]))(self, var23, var_item) /* []= on <self:AbstractArray[nullable Object]>*/;
1286 RET_LABEL:;
1287 }
1288 /* method array#AbstractArray#unshift for (self: Object, nullable Object) */
1289 void VIRTUAL_array__AbstractArray__unshift(val* self, val* p0) {
1290 array__AbstractArray__unshift(self, p0);
1291 RET_LABEL:;
1292 }
1293 /* method array#AbstractArray#insert for (self: AbstractArray[nullable Object], nullable Object, Int) */
1294 void array__AbstractArray__insert(val* self, val* p0, long p1) {
1295 short int var /* : Bool */;
1296 int cltype;
1297 int idtype;
1298 const struct type* type_struct;
1299 short int is_nullable;
1300 const char* var_class_name;
1301 val* var_item /* var item: nullable Object */;
1302 long var_pos /* var pos: Int */;
1303 long var1 /* : Int */;
1304 long var2 /* : Int */;
1305 long var3 /* : Int */;
1306 long var5 /* : Int */;
1307 long var6 /* : Int */;
1308 long var7 /* : Int */;
1309 long var9 /* : Int */;
1310 long var10 /* : Int */;
1311 long var11 /* : Int */;
1312 long var13 /* : Int */;
1313 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa AbstractArray#0 */
1314 /* <p0:nullable Object> isa AbstractArray#0 */
1315 type_struct = self->type->resolution_table->types[COLOR_array__AbstractArray_FT0];
1316 cltype = type_struct->color;
1317 idtype = type_struct->id;
1318 is_nullable = type_struct->is_nullable;
1319 if(p0 == NULL) {
1320 var = is_nullable;
1321 } else {
1322 if(cltype >= p0->type->table_size) {
1323 var = 0;
1324 } else {
1325 var = p0->type->type_table[cltype] == idtype;
1326 }
1327 }
1328 if (!var) {
1329 var_class_name = p0 == NULL ? "null" : p0->type->name;
1330 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "AbstractArray#0", var_class_name);
1331 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 186);
1332 show_backtrace(1);
1333 }
1334 var_item = p0;
1335 var_pos = p1;
1336 var1 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:AbstractArray[nullable Object]>*/;
1337 var2 = 1;
1338 { /* Inline kernel#Int#+ (var1,var2) */
1339 var5 = var1 + var2;
1340 var3 = var5;
1341 goto RET_LABEL4;
1342 RET_LABEL4:(void)0;
1343 }
1344 ((void (*)(val*, long))(self->class->vft[COLOR_array__AbstractArray__enlarge]))(self, var3) /* enlarge on <self:AbstractArray[nullable Object]>*/;
1345 var6 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:AbstractArray[nullable Object]>*/;
1346 { /* Inline kernel#Int#- (var6,var_pos) */
1347 var9 = var6 - var_pos;
1348 var7 = var9;
1349 goto RET_LABEL8;
1350 RET_LABEL8:(void)0;
1351 }
1352 var10 = 1;
1353 { /* Inline kernel#Int#+ (var_pos,var10) */
1354 var13 = var_pos + var10;
1355 var11 = var13;
1356 goto RET_LABEL12;
1357 RET_LABEL12:(void)0;
1358 }
1359 ((void (*)(val*, long, long, val*, long))(self->class->vft[COLOR_array__AbstractArrayRead__copy_to]))(self, var_pos, var7, self, var11) /* copy_to on <self:AbstractArray[nullable Object]>*/;
1360 ((void (*)(val*, long, val*))(self->class->vft[COLOR_abstract_collection__Sequence___91d_93d_61d]))(self, var_pos, var_item) /* []= on <self:AbstractArray[nullable Object]>*/;
1361 RET_LABEL:;
1362 }
1363 /* method array#AbstractArray#insert for (self: Object, nullable Object, Int) */
1364 void VIRTUAL_array__AbstractArray__insert(val* self, val* p0, long p1) {
1365 array__AbstractArray__insert(self, p0, p1);
1366 RET_LABEL:;
1367 }
1368 /* method array#AbstractArray#add for (self: AbstractArray[nullable Object], nullable Object) */
1369 void array__AbstractArray__add(val* self, val* p0) {
1370 short int var /* : Bool */;
1371 int cltype;
1372 int idtype;
1373 const struct type* type_struct;
1374 short int is_nullable;
1375 const char* var_class_name;
1376 val* var_item /* var item: nullable Object */;
1377 long var1 /* : Int */;
1378 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa SimpleCollection#0 */
1379 /* <p0:nullable Object> isa SimpleCollection#0 */
1380 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__SimpleCollection_FT0];
1381 cltype = type_struct->color;
1382 idtype = type_struct->id;
1383 is_nullable = type_struct->is_nullable;
1384 if(p0 == NULL) {
1385 var = is_nullable;
1386 } else {
1387 if(cltype >= p0->type->table_size) {
1388 var = 0;
1389 } else {
1390 var = p0->type->type_table[cltype] == idtype;
1391 }
1392 }
1393 if (!var) {
1394 var_class_name = p0 == NULL ? "null" : p0->type->name;
1395 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "SimpleCollection#0", var_class_name);
1396 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 198);
1397 show_backtrace(1);
1398 }
1399 var_item = p0;
1400 var1 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:AbstractArray[nullable Object]>*/;
1401 ((void (*)(val*, long, val*))(self->class->vft[COLOR_abstract_collection__Sequence___91d_93d_61d]))(self, var1, var_item) /* []= on <self:AbstractArray[nullable Object]>*/;
1402 RET_LABEL:;
1403 }
1404 /* method array#AbstractArray#add for (self: Object, nullable Object) */
1405 void VIRTUAL_array__AbstractArray__add(val* self, val* p0) {
1406 array__AbstractArray__add(self, p0);
1407 RET_LABEL:;
1408 }
1409 /* method array#AbstractArray#clear for (self: AbstractArray[nullable Object]) */
1410 void array__AbstractArray__clear(val* self) {
1411 long var /* : Int */;
1412 var = 0;
1413 self->attrs[COLOR_array__AbstractArrayRead___length].l = var; /* _length on <self:AbstractArray[nullable Object]> */
1414 RET_LABEL:;
1415 }
1416 /* method array#AbstractArray#clear for (self: Object) */
1417 void VIRTUAL_array__AbstractArray__clear(val* self) {
1418 array__AbstractArray__clear(self);
1419 RET_LABEL:;
1420 }
1421 /* method array#AbstractArray#remove for (self: AbstractArray[nullable Object], nullable Object) */
1422 void array__AbstractArray__remove(val* self, val* p0) {
1423 short int var /* : Bool */;
1424 int cltype;
1425 int idtype;
1426 const struct type* type_struct;
1427 short int is_nullable;
1428 const char* var_class_name;
1429 val* var_item /* var item: nullable Object */;
1430 long var1 /* : Int */;
1431 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa RemovableCollection#0 */
1432 /* <p0:nullable Object> isa RemovableCollection#0 */
1433 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__RemovableCollection_FT0];
1434 cltype = type_struct->color;
1435 idtype = type_struct->id;
1436 is_nullable = type_struct->is_nullable;
1437 if(p0 == NULL) {
1438 var = is_nullable;
1439 } else {
1440 if(cltype >= p0->type->table_size) {
1441 var = 0;
1442 } else {
1443 var = p0->type->type_table[cltype] == idtype;
1444 }
1445 }
1446 if (!var) {
1447 var_class_name = p0 == NULL ? "null" : p0->type->name;
1448 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "RemovableCollection#0", var_class_name);
1449 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 202);
1450 show_backtrace(1);
1451 }
1452 var_item = p0;
1453 var1 = ((long (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__SequenceRead__index_of]))(self, var_item) /* index_of on <self:AbstractArray[nullable Object]>*/;
1454 ((void (*)(val*, long))(self->class->vft[COLOR_abstract_collection__Sequence__remove_at]))(self, var1) /* remove_at on <self:AbstractArray[nullable Object]>*/;
1455 RET_LABEL:;
1456 }
1457 /* method array#AbstractArray#remove for (self: Object, nullable Object) */
1458 void VIRTUAL_array__AbstractArray__remove(val* self, val* p0) {
1459 array__AbstractArray__remove(self, p0);
1460 RET_LABEL:;
1461 }
1462 /* method array#AbstractArray#remove_all for (self: AbstractArray[nullable Object], nullable Object) */
1463 void array__AbstractArray__remove_all(val* self, val* p0) {
1464 short int var /* : Bool */;
1465 int cltype;
1466 int idtype;
1467 const struct type* type_struct;
1468 short int is_nullable;
1469 const char* var_class_name;
1470 val* var_item /* var item: nullable Object */;
1471 long var1 /* : Int */;
1472 long var_i /* var i: Int */;
1473 long var2 /* : Int */;
1474 short int var3 /* : Bool */;
1475 short int var5 /* : Bool */;
1476 int cltype6;
1477 int idtype7;
1478 const char* var_class_name8;
1479 short int var9 /* : Bool */;
1480 long var10 /* : Int */;
1481 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa RemovableCollection#0 */
1482 /* <p0:nullable Object> isa RemovableCollection#0 */
1483 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__RemovableCollection_FT0];
1484 cltype = type_struct->color;
1485 idtype = type_struct->id;
1486 is_nullable = type_struct->is_nullable;
1487 if(p0 == NULL) {
1488 var = is_nullable;
1489 } else {
1490 if(cltype >= p0->type->table_size) {
1491 var = 0;
1492 } else {
1493 var = p0->type->type_table[cltype] == idtype;
1494 }
1495 }
1496 if (!var) {
1497 var_class_name = p0 == NULL ? "null" : p0->type->name;
1498 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "RemovableCollection#0", var_class_name);
1499 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 204);
1500 show_backtrace(1);
1501 }
1502 var_item = p0;
1503 var1 = ((long (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__SequenceRead__index_of]))(self, var_item) /* index_of on <self:AbstractArray[nullable Object]>*/;
1504 var_i = var1;
1505 for(;;) {
1506 var2 = 0;
1507 { /* Inline kernel#Int#>= (var_i,var2) */
1508 /* Covariant cast for argument 0 (i) <var2:Int> isa OTHER */
1509 /* <var2:Int> isa OTHER */
1510 var5 = 1; /* easy <var2:Int> isa OTHER*/
1511 if (!var5) {
1512 var_class_name8 = type_kernel__Int.name;
1513 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name8);
1514 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 262);
1515 show_backtrace(1);
1516 }
1517 var9 = var_i >= var2;
1518 var3 = var9;
1519 goto RET_LABEL4;
1520 RET_LABEL4:(void)0;
1521 }
1522 if (!var3) break;
1523 ((void (*)(val*, long))(self->class->vft[COLOR_abstract_collection__Sequence__remove_at]))(self, var_i) /* remove_at on <self:AbstractArray[nullable Object]>*/;
1524 var10 = ((long (*)(val*, val*, long))(self->class->vft[COLOR_array__AbstractArrayRead__index_of_from]))(self, var_item, var_i) /* index_of_from on <self:AbstractArray[nullable Object]>*/;
1525 var_i = var10;
1526 CONTINUE_label: (void)0;
1527 }
1528 BREAK_label: (void)0;
1529 RET_LABEL:;
1530 }
1531 /* method array#AbstractArray#remove_all for (self: Object, nullable Object) */
1532 void VIRTUAL_array__AbstractArray__remove_all(val* self, val* p0) {
1533 array__AbstractArray__remove_all(self, p0);
1534 RET_LABEL:;
1535 }
1536 /* method array#AbstractArray#remove_at for (self: AbstractArray[nullable Object], Int) */
1537 void array__AbstractArray__remove_at(val* self, long p0) {
1538 long var_i /* var i: Int */;
1539 long var /* : Int */;
1540 long var_l /* var l: Int */;
1541 short int var1 /* : Bool */;
1542 long var2 /* : Int */;
1543 short int var3 /* : Bool */;
1544 short int var5 /* : Bool */;
1545 int cltype;
1546 int idtype;
1547 const char* var_class_name;
1548 short int var6 /* : Bool */;
1549 short int var_ /* var : Bool */;
1550 short int var7 /* : Bool */;
1551 short int var9 /* : Bool */;
1552 int cltype10;
1553 int idtype11;
1554 const char* var_class_name12;
1555 short int var13 /* : Bool */;
1556 long var14 /* : Int */;
1557 long var15 /* : Int */;
1558 long var17 /* : Int */;
1559 long var_j /* var j: Int */;
1560 short int var18 /* : Bool */;
1561 short int var20 /* : Bool */;
1562 int cltype21;
1563 int idtype22;
1564 const char* var_class_name23;
1565 short int var24 /* : Bool */;
1566 long var25 /* : Int */;
1567 long var26 /* : Int */;
1568 long var28 /* : Int */;
1569 val* var29 /* : nullable Object */;
1570 long var30 /* : Int */;
1571 long var31 /* : Int */;
1572 long var33 /* : Int */;
1573 long var34 /* : Int */;
1574 long var35 /* : Int */;
1575 long var37 /* : Int */;
1576 var_i = p0;
1577 var = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:AbstractArray[nullable Object]>*/;
1578 var_l = var;
1579 var2 = 0;
1580 { /* Inline kernel#Int#>= (var_i,var2) */
1581 /* Covariant cast for argument 0 (i) <var2:Int> isa OTHER */
1582 /* <var2:Int> isa OTHER */
1583 var5 = 1; /* easy <var2:Int> isa OTHER*/
1584 if (!var5) {
1585 var_class_name = type_kernel__Int.name;
1586 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
1587 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 262);
1588 show_backtrace(1);
1589 }
1590 var6 = var_i >= var2;
1591 var3 = var6;
1592 goto RET_LABEL4;
1593 RET_LABEL4:(void)0;
1594 }
1595 var_ = var3;
1596 if (var3){
1597 { /* Inline kernel#Int#< (var_i,var_l) */
1598 /* Covariant cast for argument 0 (i) <var_l:Int> isa OTHER */
1599 /* <var_l:Int> isa OTHER */
1600 var9 = 1; /* easy <var_l:Int> isa OTHER*/
1601 if (!var9) {
1602 var_class_name12 = type_kernel__Int.name;
1603 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name12);
1604 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 261);
1605 show_backtrace(1);
1606 }
1607 var13 = var_i < var_l;
1608 var7 = var13;
1609 goto RET_LABEL8;
1610 RET_LABEL8:(void)0;
1611 }
1612 var1 = var7;
1613 } else {
1614 var1 = var_;
1615 }
1616 if (var1){
1617 var14 = 1;
1618 { /* Inline kernel#Int#+ (var_i,var14) */
1619 var17 = var_i + var14;
1620 var15 = var17;
1621 goto RET_LABEL16;
1622 RET_LABEL16:(void)0;
1623 }
1624 var_j = var15;
1625 for(;;) {
1626 { /* Inline kernel#Int#< (var_j,var_l) */
1627 /* Covariant cast for argument 0 (i) <var_l:Int> isa OTHER */
1628 /* <var_l:Int> isa OTHER */
1629 var20 = 1; /* easy <var_l:Int> isa OTHER*/
1630 if (!var20) {
1631 var_class_name23 = type_kernel__Int.name;
1632 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name23);
1633 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 261);
1634 show_backtrace(1);
1635 }
1636 var24 = var_j < var_l;
1637 var18 = var24;
1638 goto RET_LABEL19;
1639 RET_LABEL19:(void)0;
1640 }
1641 if (!var18) break;
1642 var25 = 1;
1643 { /* Inline kernel#Int#- (var_j,var25) */
1644 var28 = var_j - var25;
1645 var26 = var28;
1646 goto RET_LABEL27;
1647 RET_LABEL27:(void)0;
1648 }
1649 var29 = ((val* (*)(val*, long))(self->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(self, var_j) /* [] on <self:AbstractArray[nullable Object]>*/;
1650 ((void (*)(val*, long, val*))(self->class->vft[COLOR_abstract_collection__Sequence___91d_93d_61d]))(self, var26, var29) /* []= on <self:AbstractArray[nullable Object]>*/;
1651 var30 = 1;
1652 { /* Inline kernel#Int#+ (var_j,var30) */
1653 var33 = var_j + var30;
1654 var31 = var33;
1655 goto RET_LABEL32;
1656 RET_LABEL32:(void)0;
1657 }
1658 var_j = var31;
1659 CONTINUE_label: (void)0;
1660 }
1661 BREAK_label: (void)0;
1662 var34 = 1;
1663 { /* Inline kernel#Int#- (var_l,var34) */
1664 var37 = var_l - var34;
1665 var35 = var37;
1666 goto RET_LABEL36;
1667 RET_LABEL36:(void)0;
1668 }
1669 self->attrs[COLOR_array__AbstractArrayRead___length].l = var35; /* _length on <self:AbstractArray[nullable Object]> */
1670 } else {
1671 }
1672 RET_LABEL:;
1673 }
1674 /* method array#AbstractArray#remove_at for (self: Object, Int) */
1675 void VIRTUAL_array__AbstractArray__remove_at(val* self, long p0) {
1676 array__AbstractArray__remove_at(self, p0);
1677 RET_LABEL:;
1678 }
1679 /* method array#AbstractArray#swap_at for (self: AbstractArray[nullable Object], Int, Int) */
1680 void array__AbstractArray__swap_at(val* self, long p0, long p1) {
1681 long var_a /* var a: Int */;
1682 long var_b /* var b: Int */;
1683 val* var /* : nullable Object */;
1684 val* var_e /* var e: nullable Object */;
1685 val* var1 /* : nullable Object */;
1686 var_a = p0;
1687 var_b = p1;
1688 var = ((val* (*)(val*, long))(self->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(self, var_a) /* [] on <self:AbstractArray[nullable Object]>*/;
1689 var_e = var;
1690 var1 = ((val* (*)(val*, long))(self->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(self, var_b) /* [] on <self:AbstractArray[nullable Object]>*/;
1691 ((void (*)(val*, long, val*))(self->class->vft[COLOR_abstract_collection__Sequence___91d_93d_61d]))(self, var_a, var1) /* []= on <self:AbstractArray[nullable Object]>*/;
1692 ((void (*)(val*, long, val*))(self->class->vft[COLOR_abstract_collection__Sequence___91d_93d_61d]))(self, var_b, var_e) /* []= on <self:AbstractArray[nullable Object]>*/;
1693 RET_LABEL:;
1694 }
1695 /* method array#AbstractArray#swap_at for (self: Object, Int, Int) */
1696 void VIRTUAL_array__AbstractArray__swap_at(val* self, long p0, long p1) {
1697 array__AbstractArray__swap_at(self, p0, p1);
1698 RET_LABEL:;
1699 }
1700 /* method array#AbstractArray#init for (self: AbstractArray[nullable Object]) */
1701 void array__AbstractArray__init(val* self) {
1702 ((void (*)(val*))(self->class->vft[COLOR_array__AbstractArrayRead__init]))(self) /* init on <self:AbstractArray[nullable Object]>*/;
1703 RET_LABEL:;
1704 }
1705 /* method array#AbstractArray#init for (self: Object) */
1706 void VIRTUAL_array__AbstractArray__init(val* self) {
1707 array__AbstractArray__init(self);
1708 RET_LABEL:;
1709 }
1710 /* method array#Array#[] for (self: Array[nullable Object], Int): nullable Object */
1711 val* array__Array___91d_93d(val* self, long p0) {
1712 val* var /* : nullable Object */;
1713 long var_index /* var index: Int */;
1714 short int var1 /* : Bool */;
1715 long var2 /* : Int */;
1716 short int var3 /* : Bool */;
1717 short int var5 /* : Bool */;
1718 int cltype;
1719 int idtype;
1720 const char* var_class_name;
1721 short int var6 /* : Bool */;
1722 short int var_ /* var : Bool */;
1723 long var7 /* : Int */;
1724 short int var8 /* : Bool */;
1725 short int var10 /* : Bool */;
1726 int cltype11;
1727 int idtype12;
1728 const char* var_class_name13;
1729 short int var14 /* : Bool */;
1730 val* var15 /* : nullable NativeArray[nullable Object] */;
1731 val* var16 /* : nullable Object */;
1732 var_index = p0;
1733 var2 = 0;
1734 { /* Inline kernel#Int#>= (var_index,var2) */
1735 /* Covariant cast for argument 0 (i) <var2:Int> isa OTHER */
1736 /* <var2:Int> isa OTHER */
1737 var5 = 1; /* easy <var2:Int> isa OTHER*/
1738 if (!var5) {
1739 var_class_name = type_kernel__Int.name;
1740 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
1741 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 262);
1742 show_backtrace(1);
1743 }
1744 var6 = var_index >= var2;
1745 var3 = var6;
1746 goto RET_LABEL4;
1747 RET_LABEL4:(void)0;
1748 }
1749 var_ = var3;
1750 if (var3){
1751 var7 = self->attrs[COLOR_array__AbstractArrayRead___length].l; /* _length on <self:Array[nullable Object]> */
1752 { /* Inline kernel#Int#< (var_index,var7) */
1753 /* Covariant cast for argument 0 (i) <var7:Int> isa OTHER */
1754 /* <var7:Int> isa OTHER */
1755 var10 = 1; /* easy <var7:Int> isa OTHER*/
1756 if (!var10) {
1757 var_class_name13 = type_kernel__Int.name;
1758 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name13);
1759 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 261);
1760 show_backtrace(1);
1761 }
1762 var14 = var_index < var7;
1763 var8 = var14;
1764 goto RET_LABEL9;
1765 RET_LABEL9:(void)0;
1766 }
1767 var1 = var8;
1768 } else {
1769 var1 = var_;
1770 }
1771 if (!var1) {
1772 fprintf(stderr, "Runtime error: %s", "Assert \'index\' failed");
1773 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 255);
1774 show_backtrace(1);
1775 }
1776 var15 = self->attrs[COLOR_array__Array___items].val; /* _items on <self:Array[nullable Object]> */
1777 if (var15 == NULL) {
1778 fprintf(stderr, "Runtime error: %s", "Reciever is null");
1779 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 256);
1780 show_backtrace(1);
1781 } else {
1782 var16 = ((val* (*)(val*, long))(var15->class->vft[COLOR_array__NativeArray___91d_93d]))(var15, var_index) /* [] on <var15:nullable NativeArray[nullable Object]>*/;
1783 }
1784 var = var16;
1785 goto RET_LABEL;
1786 RET_LABEL:;
1787 return var;
1788 }
1789 /* method array#Array#[] for (self: Object, Int): nullable Object */
1790 val* VIRTUAL_array__Array___91d_93d(val* self, long p0) {
1791 val* var /* : nullable Object */;
1792 val* var1 /* : nullable Object */;
1793 var1 = array__Array___91d_93d(self, p0);
1794 var = var1;
1795 RET_LABEL:;
1796 return var;
1797 }
1798 /* method array#Array#[]= for (self: Array[nullable Object], Int, nullable Object) */
1799 void array__Array___91d_93d_61d(val* self, long p0, val* p1) {
1800 short int var /* : Bool */;
1801 int cltype;
1802 int idtype;
1803 const struct type* type_struct;
1804 short int is_nullable;
1805 const char* var_class_name;
1806 long var_index /* var index: Int */;
1807 val* var_item /* var item: nullable Object */;
1808 short int var1 /* : Bool */;
1809 long var2 /* : Int */;
1810 short int var3 /* : Bool */;
1811 short int var5 /* : Bool */;
1812 int cltype6;
1813 int idtype7;
1814 const char* var_class_name8;
1815 short int var9 /* : Bool */;
1816 short int var_ /* var : Bool */;
1817 long var10 /* : Int */;
1818 long var11 /* : Int */;
1819 long var12 /* : Int */;
1820 long var14 /* : Int */;
1821 short int var15 /* : Bool */;
1822 short int var17 /* : Bool */;
1823 int cltype18;
1824 int idtype19;
1825 const char* var_class_name20;
1826 short int var21 /* : Bool */;
1827 long var22 /* : Int */;
1828 short int var23 /* : Bool */;
1829 short int var25 /* : Bool */;
1830 int cltype26;
1831 int idtype27;
1832 const char* var_class_name28;
1833 short int var29 /* : Bool */;
1834 long var30 /* : Int */;
1835 long var31 /* : Int */;
1836 long var33 /* : Int */;
1837 long var34 /* : Int */;
1838 short int var35 /* : Bool */;
1839 short int var37 /* : Bool */;
1840 int cltype38;
1841 int idtype39;
1842 const char* var_class_name40;
1843 short int var41 /* : Bool */;
1844 long var42 /* : Int */;
1845 long var43 /* : Int */;
1846 long var45 /* : Int */;
1847 val* var46 /* : nullable NativeArray[nullable Object] */;
1848 /* Covariant cast for argument 1 (item) <p1:nullable Object> isa Sequence#0 */
1849 /* <p1:nullable Object> isa Sequence#0 */
1850 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Sequence_FT0];
1851 cltype = type_struct->color;
1852 idtype = type_struct->id;
1853 is_nullable = type_struct->is_nullable;
1854 if(p1 == NULL) {
1855 var = is_nullable;
1856 } else {
1857 if(cltype >= p1->type->table_size) {
1858 var = 0;
1859 } else {
1860 var = p1->type->type_table[cltype] == idtype;
1861 }
1862 }
1863 if (!var) {
1864 var_class_name = p1 == NULL ? "null" : p1->type->name;
1865 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Sequence#0", var_class_name);
1866 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 259);
1867 show_backtrace(1);
1868 }
1869 var_index = p0;
1870 var_item = p1;
1871 var2 = 0;
1872 { /* Inline kernel#Int#>= (var_index,var2) */
1873 /* Covariant cast for argument 0 (i) <var2:Int> isa OTHER */
1874 /* <var2:Int> isa OTHER */
1875 var5 = 1; /* easy <var2:Int> isa OTHER*/
1876 if (!var5) {
1877 var_class_name8 = type_kernel__Int.name;
1878 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name8);
1879 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 262);
1880 show_backtrace(1);
1881 }
1882 var9 = var_index >= var2;
1883 var3 = var9;
1884 goto RET_LABEL4;
1885 RET_LABEL4:(void)0;
1886 }
1887 var_ = var3;
1888 if (var3){
1889 var10 = self->attrs[COLOR_array__AbstractArrayRead___length].l; /* _length on <self:Array[nullable Object]> */
1890 var11 = 1;
1891 { /* Inline kernel#Int#+ (var10,var11) */
1892 var14 = var10 + var11;
1893 var12 = var14;
1894 goto RET_LABEL13;
1895 RET_LABEL13:(void)0;
1896 }
1897 { /* Inline kernel#Int#< (var_index,var12) */
1898 /* Covariant cast for argument 0 (i) <var12:Int> isa OTHER */
1899 /* <var12:Int> isa OTHER */
1900 var17 = 1; /* easy <var12:Int> isa OTHER*/
1901 if (!var17) {
1902 var_class_name20 = type_kernel__Int.name;
1903 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name20);
1904 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 261);
1905 show_backtrace(1);
1906 }
1907 var21 = var_index < var12;
1908 var15 = var21;
1909 goto RET_LABEL16;
1910 RET_LABEL16:(void)0;
1911 }
1912 var1 = var15;
1913 } else {
1914 var1 = var_;
1915 }
1916 if (!var1) {
1917 fprintf(stderr, "Runtime error: %s", "Assert \'index\' failed");
1918 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 261);
1919 show_backtrace(1);
1920 }
1921 var22 = self->attrs[COLOR_array__Array___capacity].l; /* _capacity on <self:Array[nullable Object]> */
1922 { /* Inline kernel#Int#<= (var22,var_index) */
1923 /* Covariant cast for argument 0 (i) <var_index:Int> isa OTHER */
1924 /* <var_index:Int> isa OTHER */
1925 var25 = 1; /* easy <var_index:Int> isa OTHER*/
1926 if (!var25) {
1927 var_class_name28 = type_kernel__Int.name;
1928 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name28);
1929 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 260);
1930 show_backtrace(1);
1931 }
1932 var29 = var22 <= var_index;
1933 var23 = var29;
1934 goto RET_LABEL24;
1935 RET_LABEL24:(void)0;
1936 }
1937 if (var23){
1938 var30 = 1;
1939 { /* Inline kernel#Int#+ (var_index,var30) */
1940 var33 = var_index + var30;
1941 var31 = var33;
1942 goto RET_LABEL32;
1943 RET_LABEL32:(void)0;
1944 }
1945 ((void (*)(val*, long))(self->class->vft[COLOR_array__AbstractArray__enlarge]))(self, var31) /* enlarge on <self:Array[nullable Object]>*/;
1946 } else {
1947 }
1948 var34 = self->attrs[COLOR_array__AbstractArrayRead___length].l; /* _length on <self:Array[nullable Object]> */
1949 { /* Inline kernel#Int#<= (var34,var_index) */
1950 /* Covariant cast for argument 0 (i) <var_index:Int> isa OTHER */
1951 /* <var_index:Int> isa OTHER */
1952 var37 = 1; /* easy <var_index:Int> isa OTHER*/
1953 if (!var37) {
1954 var_class_name40 = type_kernel__Int.name;
1955 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name40);
1956 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 260);
1957 show_backtrace(1);
1958 }
1959 var41 = var34 <= var_index;
1960 var35 = var41;
1961 goto RET_LABEL36;
1962 RET_LABEL36:(void)0;
1963 }
1964 if (var35){
1965 var42 = 1;
1966 { /* Inline kernel#Int#+ (var_index,var42) */
1967 var45 = var_index + var42;
1968 var43 = var45;
1969 goto RET_LABEL44;
1970 RET_LABEL44:(void)0;
1971 }
1972 self->attrs[COLOR_array__AbstractArrayRead___length].l = var43; /* _length on <self:Array[nullable Object]> */
1973 } else {
1974 }
1975 var46 = self->attrs[COLOR_array__Array___items].val; /* _items on <self:Array[nullable Object]> */
1976 if (var46 == NULL) {
1977 fprintf(stderr, "Runtime error: %s", "Reciever is null");
1978 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 268);
1979 show_backtrace(1);
1980 } else {
1981 ((void (*)(val*, long, val*))(var46->class->vft[COLOR_array__NativeArray___91d_93d_61d]))(var46, var_index, var_item) /* []= on <var46:nullable NativeArray[nullable Object]>*/;
1982 }
1983 RET_LABEL:;
1984 }
1985 /* method array#Array#[]= for (self: Object, Int, nullable Object) */
1986 void VIRTUAL_array__Array___91d_93d_61d(val* self, long p0, val* p1) {
1987 array__Array___91d_93d_61d(self, p0, p1);
1988 RET_LABEL:;
1989 }
1990 /* method array#Array#add for (self: Array[nullable Object], nullable Object) */
1991 void array__Array__add(val* self, val* p0) {
1992 short int var /* : Bool */;
1993 int cltype;
1994 int idtype;
1995 const struct type* type_struct;
1996 short int is_nullable;
1997 const char* var_class_name;
1998 val* var_item /* var item: nullable Object */;
1999 long var1 /* : Int */;
2000 long var_l /* var l: Int */;
2001 long var2 /* : Int */;
2002 short int var3 /* : Bool */;
2003 short int var5 /* : Bool */;
2004 int cltype6;
2005 int idtype7;
2006 const char* var_class_name8;
2007 short int var9 /* : Bool */;
2008 long var10 /* : Int */;
2009 long var11 /* : Int */;
2010 long var13 /* : Int */;
2011 long var14 /* : Int */;
2012 long var15 /* : Int */;
2013 long var17 /* : Int */;
2014 val* var18 /* : nullable NativeArray[nullable Object] */;
2015 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa SimpleCollection#0 */
2016 /* <p0:nullable Object> isa SimpleCollection#0 */
2017 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__SimpleCollection_FT0];
2018 cltype = type_struct->color;
2019 idtype = type_struct->id;
2020 is_nullable = type_struct->is_nullable;
2021 if(p0 == NULL) {
2022 var = is_nullable;
2023 } else {
2024 if(cltype >= p0->type->table_size) {
2025 var = 0;
2026 } else {
2027 var = p0->type->type_table[cltype] == idtype;
2028 }
2029 }
2030 if (!var) {
2031 var_class_name = p0 == NULL ? "null" : p0->type->name;
2032 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "SimpleCollection#0", var_class_name);
2033 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 271);
2034 show_backtrace(1);
2035 }
2036 var_item = p0;
2037 var1 = self->attrs[COLOR_array__AbstractArrayRead___length].l; /* _length on <self:Array[nullable Object]> */
2038 var_l = var1;
2039 var2 = self->attrs[COLOR_array__Array___capacity].l; /* _capacity on <self:Array[nullable Object]> */
2040 { /* Inline kernel#Int#<= (var2,var_l) */
2041 /* Covariant cast for argument 0 (i) <var_l:Int> isa OTHER */
2042 /* <var_l:Int> isa OTHER */
2043 var5 = 1; /* easy <var_l:Int> isa OTHER*/
2044 if (!var5) {
2045 var_class_name8 = type_kernel__Int.name;
2046 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name8);
2047 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 260);
2048 show_backtrace(1);
2049 }
2050 var9 = var2 <= var_l;
2051 var3 = var9;
2052 goto RET_LABEL4;
2053 RET_LABEL4:(void)0;
2054 }
2055 if (var3){
2056 var10 = 1;
2057 { /* Inline kernel#Int#+ (var_l,var10) */
2058 var13 = var_l + var10;
2059 var11 = var13;
2060 goto RET_LABEL12;
2061 RET_LABEL12:(void)0;
2062 }
2063 ((void (*)(val*, long))(self->class->vft[COLOR_array__AbstractArray__enlarge]))(self, var11) /* enlarge on <self:Array[nullable Object]>*/;
2064 } else {
2065 }
2066 var14 = 1;
2067 { /* Inline kernel#Int#+ (var_l,var14) */
2068 var17 = var_l + var14;
2069 var15 = var17;
2070 goto RET_LABEL16;
2071 RET_LABEL16:(void)0;
2072 }
2073 self->attrs[COLOR_array__AbstractArrayRead___length].l = var15; /* _length on <self:Array[nullable Object]> */
2074 var18 = self->attrs[COLOR_array__Array___items].val; /* _items on <self:Array[nullable Object]> */
2075 if (var18 == NULL) {
2076 fprintf(stderr, "Runtime error: %s", "Reciever is null");
2077 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 278);
2078 show_backtrace(1);
2079 } else {
2080 ((void (*)(val*, long, val*))(var18->class->vft[COLOR_array__NativeArray___91d_93d_61d]))(var18, var_l, var_item) /* []= on <var18:nullable NativeArray[nullable Object]>*/;
2081 }
2082 RET_LABEL:;
2083 }
2084 /* method array#Array#add for (self: Object, nullable Object) */
2085 void VIRTUAL_array__Array__add(val* self, val* p0) {
2086 array__Array__add(self, p0);
2087 RET_LABEL:;
2088 }
2089 /* method array#Array#enlarge for (self: Array[nullable Object], Int) */
2090 void array__Array__enlarge(val* self, long p0) {
2091 long var_cap /* var cap: Int */;
2092 long var /* : Int */;
2093 long var_c /* var c: Int */;
2094 short int var1 /* : Bool */;
2095 short int var3 /* : Bool */;
2096 int cltype;
2097 int idtype;
2098 const char* var_class_name;
2099 short int var4 /* : Bool */;
2100 short int var5 /* : Bool */;
2101 short int var7 /* : Bool */;
2102 int cltype8;
2103 int idtype9;
2104 const char* var_class_name10;
2105 short int var11 /* : Bool */;
2106 long var12 /* : Int */;
2107 long var13 /* : Int */;
2108 long var15 /* : Int */;
2109 long var16 /* : Int */;
2110 long var17 /* : Int */;
2111 long var19 /* : Int */;
2112 val* var20 /* : NativeArray[nullable Object] */;
2113 val* var_a /* var a: NativeArray[nullable Object] */;
2114 long var21 /* : Int */;
2115 long var22 /* : Int */;
2116 short int var23 /* : Bool */;
2117 short int var25 /* : Bool */;
2118 int cltype26;
2119 int idtype27;
2120 const char* var_class_name28;
2121 short int var29 /* : Bool */;
2122 val* var30 /* : nullable NativeArray[nullable Object] */;
2123 long var31 /* : Int */;
2124 var_cap = p0;
2125 var = self->attrs[COLOR_array__Array___capacity].l; /* _capacity on <self:Array[nullable Object]> */
2126 var_c = var;
2127 { /* Inline kernel#Int#<= (var_cap,var_c) */
2128 /* Covariant cast for argument 0 (i) <var_c:Int> isa OTHER */
2129 /* <var_c:Int> isa OTHER */
2130 var3 = 1; /* easy <var_c:Int> isa OTHER*/
2131 if (!var3) {
2132 var_class_name = type_kernel__Int.name;
2133 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
2134 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 260);
2135 show_backtrace(1);
2136 }
2137 var4 = var_cap <= var_c;
2138 var1 = var4;
2139 goto RET_LABEL2;
2140 RET_LABEL2:(void)0;
2141 }
2142 if (var1){
2143 goto RET_LABEL;
2144 } else {
2145 }
2146 for(;;) {
2147 { /* Inline kernel#Int#<= (var_c,var_cap) */
2148 /* Covariant cast for argument 0 (i) <var_cap:Int> isa OTHER */
2149 /* <var_cap:Int> isa OTHER */
2150 var7 = 1; /* easy <var_cap:Int> isa OTHER*/
2151 if (!var7) {
2152 var_class_name10 = type_kernel__Int.name;
2153 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name10);
2154 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 260);
2155 show_backtrace(1);
2156 }
2157 var11 = var_c <= var_cap;
2158 var5 = var11;
2159 goto RET_LABEL6;
2160 RET_LABEL6:(void)0;
2161 }
2162 if (!var5) break;
2163 var12 = 2;
2164 { /* Inline kernel#Int#* (var_c,var12) */
2165 var15 = var_c * var12;
2166 var13 = var15;
2167 goto RET_LABEL14;
2168 RET_LABEL14:(void)0;
2169 }
2170 var16 = 2;
2171 { /* Inline kernel#Int#+ (var13,var16) */
2172 var19 = var13 + var16;
2173 var17 = var19;
2174 goto RET_LABEL18;
2175 RET_LABEL18:(void)0;
2176 }
2177 var_c = var17;
2178 CONTINUE_label: (void)0;
2179 }
2180 BREAK_label: (void)0;
2181 var20 = ((val* (*)(val*, long))(self->class->vft[COLOR_array__ArrayCapable__calloc_array]))(self, var_c) /* calloc_array on <self:Array[nullable Object]>*/;
2182 var_a = var20;
2183 var21 = self->attrs[COLOR_array__Array___capacity].l; /* _capacity on <self:Array[nullable Object]> */
2184 var22 = 0;
2185 { /* Inline kernel#Int#> (var21,var22) */
2186 /* Covariant cast for argument 0 (i) <var22:Int> isa OTHER */
2187 /* <var22:Int> isa OTHER */
2188 var25 = 1; /* easy <var22:Int> isa OTHER*/
2189 if (!var25) {
2190 var_class_name28 = type_kernel__Int.name;
2191 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name28);
2192 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 263);
2193 show_backtrace(1);
2194 }
2195 var29 = var21 > var22;
2196 var23 = var29;
2197 goto RET_LABEL24;
2198 RET_LABEL24:(void)0;
2199 }
2200 if (var23){
2201 var30 = self->attrs[COLOR_array__Array___items].val; /* _items on <self:Array[nullable Object]> */
2202 var31 = self->attrs[COLOR_array__AbstractArrayRead___length].l; /* _length on <self:Array[nullable Object]> */
2203 if (var30 == NULL) {
2204 fprintf(stderr, "Runtime error: %s", "Reciever is null");
2205 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 287);
2206 show_backtrace(1);
2207 } else {
2208 ((void (*)(val*, val*, long))(var30->class->vft[COLOR_array__NativeArray__copy_to]))(var30, var_a, var31) /* copy_to on <var30:nullable NativeArray[nullable Object]>*/;
2209 }
2210 } else {
2211 }
2212 self->attrs[COLOR_array__Array___items].val = var_a; /* _items on <self:Array[nullable Object]> */
2213 self->attrs[COLOR_array__Array___capacity].l = var_c; /* _capacity on <self:Array[nullable Object]> */
2214 RET_LABEL:;
2215 }
2216 /* method array#Array#enlarge for (self: Object, Int) */
2217 void VIRTUAL_array__Array__enlarge(val* self, long p0) {
2218 array__Array__enlarge(self, p0);
2219 RET_LABEL:;
2220 }
2221 /* method array#Array#init for (self: Array[nullable Object]) */
2222 void array__Array__init(val* self) {
2223 long var /* : Int */;
2224 long var1 /* : Int */;
2225 ((void (*)(val*))(self->class->vft[COLOR_array__AbstractArray__init]))(self) /* init on <self:Array[nullable Object]>*/;
2226 var = 0;
2227 self->attrs[COLOR_array__Array___capacity].l = var; /* _capacity on <self:Array[nullable Object]> */
2228 var1 = 0;
2229 self->attrs[COLOR_array__AbstractArrayRead___length].l = var1; /* _length on <self:Array[nullable Object]> */
2230 RET_LABEL:;
2231 }
2232 /* method array#Array#init for (self: Object) */
2233 void VIRTUAL_array__Array__init(val* self) {
2234 array__Array__init(self);
2235 RET_LABEL:;
2236 }
2237 /* method array#Array#from for (self: Array[nullable Object], Collection[nullable Object]) */
2238 void array__Array__from(val* self, val* p0) {
2239 short int var /* : Bool */;
2240 int cltype;
2241 int idtype;
2242 const struct type* type_struct;
2243 const char* var_class_name;
2244 val* var_items /* var items: Collection[nullable Object] */;
2245 long var1 /* : Int */;
2246 /* Covariant cast for argument 0 (items) <p0:Collection[nullable Object]> isa Collection[Array#0] */
2247 /* <p0:Collection[nullable Object]> isa Collection[Array#0] */
2248 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collectionarray__Array_FT0];
2249 cltype = type_struct->color;
2250 idtype = type_struct->id;
2251 if(cltype >= p0->type->table_size) {
2252 var = 0;
2253 } else {
2254 var = p0->type->type_table[cltype] == idtype;
2255 }
2256 if (!var) {
2257 var_class_name = p0 == NULL ? "null" : p0->type->name;
2258 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection[Array#0]", var_class_name);
2259 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 299);
2260 show_backtrace(1);
2261 }
2262 var_items = p0;
2263 var1 = ((long (*)(val*))(var_items->class->vft[COLOR_abstract_collection__Collection__length]))(var_items) /* length on <var_items:Collection[nullable Object]>*/;
2264 ((void (*)(val*, long))(self->class->vft[COLOR_array__Array__with_capacity]))(self, var1) /* with_capacity on <self:Array[nullable Object]>*/;
2265 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__SimpleCollection__add_all]))(self, var_items) /* add_all on <self:Array[nullable Object]>*/;
2266 RET_LABEL:;
2267 }
2268 /* method array#Array#from for (self: Object, Collection[nullable Object]) */
2269 void VIRTUAL_array__Array__from(val* self, val* p0) {
2270 array__Array__from(self, p0);
2271 RET_LABEL:;
2272 }
2273 /* method array#Array#with_items for (self: Array[nullable Object], Array[nullable Object]) */
2274 void array__Array__with_items(val* self, val* p0) {
2275 val* var_objects /* var objects: Array[nullable Object] */;
2276 val* var /* : nullable NativeArray[nullable Object] */;
2277 long var1 /* : Int */;
2278 long var2 /* : Int */;
2279 var_objects = p0;
2280 ((void (*)(val*))(self->class->vft[COLOR_array__AbstractArray__init]))(self) /* init on <self:Array[nullable Object]>*/;
2281 var = var_objects->attrs[COLOR_array__Array___items].val; /* _items on <var_objects:Array[nullable Object]> */
2282 self->attrs[COLOR_array__Array___items].val = var; /* _items on <self:Array[nullable Object]> */
2283 var1 = var_objects->attrs[COLOR_array__Array___capacity].l; /* _capacity on <var_objects:Array[nullable Object]> */
2284 self->attrs[COLOR_array__Array___capacity].l = var1; /* _capacity on <self:Array[nullable Object]> */
2285 var2 = ((long (*)(val*))(var_objects->class->vft[COLOR_abstract_collection__Collection__length]))(var_objects) /* length on <var_objects:Array[nullable Object]>*/;
2286 self->attrs[COLOR_array__AbstractArrayRead___length].l = var2; /* _length on <self:Array[nullable Object]> */
2287 RET_LABEL:;
2288 }
2289 /* method array#Array#with_items for (self: Object, Array[nullable Object]) */
2290 void VIRTUAL_array__Array__with_items(val* self, val* p0) {
2291 array__Array__with_items(self, p0);
2292 RET_LABEL:;
2293 }
2294 /* method array#Array#with_capacity for (self: Array[nullable Object], Int) */
2295 void array__Array__with_capacity(val* self, long p0) {
2296 long var_cap /* var cap: Int */;
2297 long var /* : Int */;
2298 short int var1 /* : Bool */;
2299 short int var3 /* : Bool */;
2300 int cltype;
2301 int idtype;
2302 const char* var_class_name;
2303 short int var4 /* : Bool */;
2304 val* var5 /* : NativeArray[nullable Object] */;
2305 long var6 /* : Int */;
2306 var_cap = p0;
2307 ((void (*)(val*))(self->class->vft[COLOR_array__AbstractArray__init]))(self) /* init on <self:Array[nullable Object]>*/;
2308 var = 0;
2309 { /* Inline kernel#Int#>= (var_cap,var) */
2310 /* Covariant cast for argument 0 (i) <var:Int> isa OTHER */
2311 /* <var:Int> isa OTHER */
2312 var3 = 1; /* easy <var:Int> isa OTHER*/
2313 if (!var3) {
2314 var_class_name = type_kernel__Int.name;
2315 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
2316 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 262);
2317 show_backtrace(1);
2318 }
2319 var4 = var_cap >= var;
2320 var1 = var4;
2321 goto RET_LABEL2;
2322 RET_LABEL2:(void)0;
2323 }
2324 if (!var1) {
2325 fprintf(stderr, "Runtime error: %s", "Assert \'positive\' failed");
2326 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 316);
2327 show_backtrace(1);
2328 }
2329 var5 = ((val* (*)(val*, long))(self->class->vft[COLOR_array__ArrayCapable__calloc_array]))(self, var_cap) /* calloc_array on <self:Array[nullable Object]>*/;
2330 self->attrs[COLOR_array__Array___items].val = var5; /* _items on <self:Array[nullable Object]> */
2331 self->attrs[COLOR_array__Array___capacity].l = var_cap; /* _capacity on <self:Array[nullable Object]> */
2332 var6 = 0;
2333 self->attrs[COLOR_array__AbstractArrayRead___length].l = var6; /* _length on <self:Array[nullable Object]> */
2334 RET_LABEL:;
2335 }
2336 /* method array#Array#with_capacity for (self: Object, Int) */
2337 void VIRTUAL_array__Array__with_capacity(val* self, long p0) {
2338 array__Array__with_capacity(self, p0);
2339 RET_LABEL:;
2340 }
2341 /* method array#Array#filled_with for (self: Array[nullable Object], nullable Object, Int) */
2342 void array__Array__filled_with(val* self, val* p0, long p1) {
2343 short int var /* : Bool */;
2344 int cltype;
2345 int idtype;
2346 const struct type* type_struct;
2347 short int is_nullable;
2348 const char* var_class_name;
2349 val* var_value /* var value: nullable Object */;
2350 long var_count /* var count: Int */;
2351 long var1 /* : Int */;
2352 short int var2 /* : Bool */;
2353 short int var4 /* : Bool */;
2354 int cltype5;
2355 int idtype6;
2356 const char* var_class_name7;
2357 short int var8 /* : Bool */;
2358 val* var9 /* : NativeArray[nullable Object] */;
2359 long var10 /* : Int */;
2360 long var_i /* var i: Int */;
2361 short int var11 /* : Bool */;
2362 short int var13 /* : Bool */;
2363 int cltype14;
2364 int idtype15;
2365 const char* var_class_name16;
2366 short int var17 /* : Bool */;
2367 long var18 /* : Int */;
2368 long var19 /* : Int */;
2369 long var21 /* : Int */;
2370 /* Covariant cast for argument 0 (value) <p0:nullable Object> isa Array#0 */
2371 /* <p0:nullable Object> isa Array#0 */
2372 type_struct = self->type->resolution_table->types[COLOR_array__Array_FT0];
2373 cltype = type_struct->color;
2374 idtype = type_struct->id;
2375 is_nullable = type_struct->is_nullable;
2376 if(p0 == NULL) {
2377 var = is_nullable;
2378 } else {
2379 if(cltype >= p0->type->table_size) {
2380 var = 0;
2381 } else {
2382 var = p0->type->type_table[cltype] == idtype;
2383 }
2384 }
2385 if (!var) {
2386 var_class_name = p0 == NULL ? "null" : p0->type->name;
2387 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Array#0", var_class_name);
2388 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 322);
2389 show_backtrace(1);
2390 }
2391 var_value = p0;
2392 var_count = p1;
2393 ((void (*)(val*))(self->class->vft[COLOR_array__AbstractArray__init]))(self) /* init on <self:Array[nullable Object]>*/;
2394 var1 = 0;
2395 { /* Inline kernel#Int#>= (var_count,var1) */
2396 /* Covariant cast for argument 0 (i) <var1:Int> isa OTHER */
2397 /* <var1:Int> isa OTHER */
2398 var4 = 1; /* easy <var1:Int> isa OTHER*/
2399 if (!var4) {
2400 var_class_name7 = type_kernel__Int.name;
2401 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name7);
2402 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 262);
2403 show_backtrace(1);
2404 }
2405 var8 = var_count >= var1;
2406 var2 = var8;
2407 goto RET_LABEL3;
2408 RET_LABEL3:(void)0;
2409 }
2410 if (!var2) {
2411 fprintf(stderr, "Runtime error: %s", "Assert \'positive\' failed");
2412 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 325);
2413 show_backtrace(1);
2414 }
2415 var9 = ((val* (*)(val*, long))(self->class->vft[COLOR_array__ArrayCapable__calloc_array]))(self, var_count) /* calloc_array on <self:Array[nullable Object]>*/;
2416 self->attrs[COLOR_array__Array___items].val = var9; /* _items on <self:Array[nullable Object]> */
2417 self->attrs[COLOR_array__Array___capacity].l = var_count; /* _capacity on <self:Array[nullable Object]> */
2418 self->attrs[COLOR_array__AbstractArrayRead___length].l = var_count; /* _length on <self:Array[nullable Object]> */
2419 var10 = 0;
2420 var_i = var10;
2421 for(;;) {
2422 { /* Inline kernel#Int#< (var_i,var_count) */
2423 /* Covariant cast for argument 0 (i) <var_count:Int> isa OTHER */
2424 /* <var_count:Int> isa OTHER */
2425 var13 = 1; /* easy <var_count:Int> isa OTHER*/
2426 if (!var13) {
2427 var_class_name16 = type_kernel__Int.name;
2428 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name16);
2429 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 261);
2430 show_backtrace(1);
2431 }
2432 var17 = var_i < var_count;
2433 var11 = var17;
2434 goto RET_LABEL12;
2435 RET_LABEL12:(void)0;
2436 }
2437 if (!var11) break;
2438 ((void (*)(val*, long, val*))(self->class->vft[COLOR_abstract_collection__Sequence___91d_93d_61d]))(self, var_i, var_value) /* []= on <self:Array[nullable Object]>*/;
2439 var18 = 1;
2440 { /* Inline kernel#Int#+ (var_i,var18) */
2441 var21 = var_i + var18;
2442 var19 = var21;
2443 goto RET_LABEL20;
2444 RET_LABEL20:(void)0;
2445 }
2446 var_i = var19;
2447 CONTINUE_label: (void)0;
2448 }
2449 BREAK_label: (void)0;
2450 RET_LABEL:;
2451 }
2452 /* method array#Array#filled_with for (self: Object, nullable Object, Int) */
2453 void VIRTUAL_array__Array__filled_with(val* self, val* p0, long p1) {
2454 array__Array__filled_with(self, p0, p1);
2455 RET_LABEL:;
2456 }
2457 /* method array#Array#with_native for (self: Array[nullable Object], NativeArray[nullable Object], Int) */
2458 void array__Array__with_native(val* self, val* p0, long p1) {
2459 short int var /* : Bool */;
2460 int cltype;
2461 int idtype;
2462 const struct type* type_struct;
2463 const char* var_class_name;
2464 val* var_nat /* var nat: NativeArray[nullable Object] */;
2465 long var_size /* var size: Int */;
2466 long var1 /* : Int */;
2467 short int var2 /* : Bool */;
2468 short int var4 /* : Bool */;
2469 int cltype5;
2470 int idtype6;
2471 const char* var_class_name7;
2472 short int var8 /* : Bool */;
2473 /* Covariant cast for argument 0 (nat) <p0:NativeArray[nullable Object]> isa NativeArray[Array#0] */
2474 /* <p0:NativeArray[nullable Object]> isa NativeArray[Array#0] */
2475 type_struct = self->type->resolution_table->types[COLOR_array__NativeArrayarray__Array_FT0];
2476 cltype = type_struct->color;
2477 idtype = type_struct->id;
2478 if(cltype >= p0->type->table_size) {
2479 var = 0;
2480 } else {
2481 var = p0->type->type_table[cltype] == idtype;
2482 }
2483 if (!var) {
2484 var_class_name = p0 == NULL ? "null" : p0->type->name;
2485 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "NativeArray[Array#0]", var_class_name);
2486 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 336);
2487 show_backtrace(1);
2488 }
2489 var_nat = p0;
2490 var_size = p1;
2491 ((void (*)(val*))(self->class->vft[COLOR_array__AbstractArray__init]))(self) /* init on <self:Array[nullable Object]>*/;
2492 var1 = 0;
2493 { /* Inline kernel#Int#>= (var_size,var1) */
2494 /* Covariant cast for argument 0 (i) <var1:Int> isa OTHER */
2495 /* <var1:Int> isa OTHER */
2496 var4 = 1; /* easy <var1:Int> isa OTHER*/
2497 if (!var4) {
2498 var_class_name7 = type_kernel__Int.name;
2499 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name7);
2500 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 262);
2501 show_backtrace(1);
2502 }
2503 var8 = var_size >= var1;
2504 var2 = var8;
2505 goto RET_LABEL3;
2506 RET_LABEL3:(void)0;
2507 }
2508 if (!var2) {
2509 fprintf(stderr, "Runtime error: %s", "Assert \'positive\' failed");
2510 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 339);
2511 show_backtrace(1);
2512 }
2513 self->attrs[COLOR_array__Array___items].val = var_nat; /* _items on <self:Array[nullable Object]> */
2514 self->attrs[COLOR_array__Array___capacity].l = var_size; /* _capacity on <self:Array[nullable Object]> */
2515 self->attrs[COLOR_array__AbstractArrayRead___length].l = var_size; /* _length on <self:Array[nullable Object]> */
2516 RET_LABEL:;
2517 }
2518 /* method array#Array#with_native for (self: Object, NativeArray[nullable Object], Int) */
2519 void VIRTUAL_array__Array__with_native(val* self, val* p0, long p1) {
2520 array__Array__with_native(self, p0, p1);
2521 RET_LABEL:;
2522 }
2523 /* method array#Array#intern_items for (self: Array[nullable Object]): NativeArray[nullable Object] */
2524 val* array__Array__intern_items(val* self) {
2525 val* var /* : NativeArray[nullable Object] */;
2526 val* var1 /* : nullable NativeArray[nullable Object] */;
2527 var1 = self->attrs[COLOR_array__Array___items].val; /* _items on <self:Array[nullable Object]> */
2528 if (var1 == NULL) {
2529 fprintf(stderr, "Runtime error: %s", "Cast failed");
2530 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 350);
2531 show_backtrace(1);
2532 }
2533 var = var1;
2534 goto RET_LABEL;
2535 RET_LABEL:;
2536 return var;
2537 }
2538 /* method array#Array#intern_items for (self: Object): NativeArray[nullable Object] */
2539 val* VIRTUAL_array__Array__intern_items(val* self) {
2540 val* var /* : NativeArray[nullable Object] */;
2541 val* var1 /* : NativeArray[nullable Object] */;
2542 var1 = array__Array__intern_items(self);
2543 var = var1;
2544 RET_LABEL:;
2545 return var;
2546 }
2547 /* method array#ArrayIterator#item for (self: ArrayIterator[nullable Object]): nullable Object */
2548 val* array__ArrayIterator__item(val* self) {
2549 val* var /* : nullable Object */;
2550 val* var1 /* : AbstractArrayRead[nullable Object] */;
2551 long var2 /* : Int */;
2552 val* var3 /* : nullable Object */;
2553 var1 = self->attrs[COLOR_array__ArrayIterator___array].val; /* _array on <self:ArrayIterator[nullable Object]> */
2554 if (var1 == NULL) {
2555 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _array");
2556 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 360);
2557 show_backtrace(1);
2558 }
2559 var2 = self->attrs[COLOR_array__ArrayIterator___index].l; /* _index on <self:ArrayIterator[nullable Object]> */
2560 var3 = ((val* (*)(val*, long))(var1->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var1, var2) /* [] on <var1:AbstractArrayRead[nullable Object]>*/;
2561 var = var3;
2562 goto RET_LABEL;
2563 RET_LABEL:;
2564 return var;
2565 }
2566 /* method array#ArrayIterator#item for (self: Object): nullable Object */
2567 val* VIRTUAL_array__ArrayIterator__item(val* self) {
2568 val* var /* : nullable Object */;
2569 val* var1 /* : nullable Object */;
2570 var1 = array__ArrayIterator__item(self);
2571 var = var1;
2572 RET_LABEL:;
2573 return var;
2574 }
2575 /* method array#ArrayIterator#is_ok for (self: ArrayIterator[nullable Object]): Bool */
2576 short int array__ArrayIterator__is_ok(val* self) {
2577 short int var /* : Bool */;
2578 long var1 /* : Int */;
2579 val* var2 /* : AbstractArrayRead[nullable Object] */;
2580 long var3 /* : Int */;
2581 short int var4 /* : Bool */;
2582 short int var6 /* : Bool */;
2583 int cltype;
2584 int idtype;
2585 const char* var_class_name;
2586 short int var7 /* : Bool */;
2587 var1 = self->attrs[COLOR_array__ArrayIterator___index].l; /* _index on <self:ArrayIterator[nullable Object]> */
2588 var2 = self->attrs[COLOR_array__ArrayIterator___array].val; /* _array on <self:ArrayIterator[nullable Object]> */
2589 if (var2 == NULL) {
2590 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _array");
2591 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 364);
2592 show_backtrace(1);
2593 }
2594 var3 = ((long (*)(val*))(var2->class->vft[COLOR_abstract_collection__Collection__length]))(var2) /* length on <var2:AbstractArrayRead[nullable Object]>*/;
2595 { /* Inline kernel#Int#< (var1,var3) */
2596 /* Covariant cast for argument 0 (i) <var3:Int> isa OTHER */
2597 /* <var3:Int> isa OTHER */
2598 var6 = 1; /* easy <var3:Int> isa OTHER*/
2599 if (!var6) {
2600 var_class_name = type_kernel__Int.name;
2601 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
2602 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 261);
2603 show_backtrace(1);
2604 }
2605 var7 = var1 < var3;
2606 var4 = var7;
2607 goto RET_LABEL5;
2608 RET_LABEL5:(void)0;
2609 }
2610 var = var4;
2611 goto RET_LABEL;
2612 RET_LABEL:;
2613 return var;
2614 }
2615 /* method array#ArrayIterator#is_ok for (self: Object): Bool */
2616 short int VIRTUAL_array__ArrayIterator__is_ok(val* self) {
2617 short int var /* : Bool */;
2618 short int var1 /* : Bool */;
2619 var1 = array__ArrayIterator__is_ok(self);
2620 var = var1;
2621 RET_LABEL:;
2622 return var;
2623 }
2624 /* method array#ArrayIterator#next for (self: ArrayIterator[nullable Object]) */
2625 void array__ArrayIterator__next(val* self) {
2626 val* var_ /* var : ArrayIterator[nullable Object] */;
2627 long var /* : Int */;
2628 long var1 /* : Int */;
2629 long var2 /* : Int */;
2630 long var4 /* : Int */;
2631 var_ = self;
2632 var = var_->attrs[COLOR_array__ArrayIterator___index].l; /* _index on <var_:ArrayIterator[nullable Object]> */
2633 var1 = 1;
2634 { /* Inline kernel#Int#+ (var,var1) */
2635 var4 = var + var1;
2636 var2 = var4;
2637 goto RET_LABEL3;
2638 RET_LABEL3:(void)0;
2639 }
2640 var_->attrs[COLOR_array__ArrayIterator___index].l = var2; /* _index on <var_:ArrayIterator[nullable Object]> */
2641 RET_LABEL:;
2642 }
2643 /* method array#ArrayIterator#next for (self: Object) */
2644 void VIRTUAL_array__ArrayIterator__next(val* self) {
2645 array__ArrayIterator__next(self);
2646 RET_LABEL:;
2647 }
2648 /* method array#ArrayIterator#init for (self: ArrayIterator[nullable Object], AbstractArrayRead[nullable Object]) */
2649 void array__ArrayIterator__init(val* self, val* p0) {
2650 short int var /* : Bool */;
2651 int cltype;
2652 int idtype;
2653 const struct type* type_struct;
2654 const char* var_class_name;
2655 val* var_a /* var a: AbstractArrayRead[nullable Object] */;
2656 long var1 /* : Int */;
2657 /* Covariant cast for argument 0 (a) <p0:AbstractArrayRead[nullable Object]> isa AbstractArrayRead[ArrayIterator#0] */
2658 /* <p0:AbstractArrayRead[nullable Object]> isa AbstractArrayRead[ArrayIterator#0] */
2659 type_struct = self->type->resolution_table->types[COLOR_array__AbstractArrayReadarray__ArrayIterator_FT0];
2660 cltype = type_struct->color;
2661 idtype = type_struct->id;
2662 if(cltype >= p0->type->table_size) {
2663 var = 0;
2664 } else {
2665 var = p0->type->type_table[cltype] == idtype;
2666 }
2667 if (!var) {
2668 var_class_name = p0 == NULL ? "null" : p0->type->name;
2669 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "AbstractArrayRead[ArrayIterator#0]", var_class_name);
2670 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 368);
2671 show_backtrace(1);
2672 }
2673 var_a = p0;
2674 self->attrs[COLOR_array__ArrayIterator___array].val = var_a; /* _array on <self:ArrayIterator[nullable Object]> */
2675 var1 = 0;
2676 self->attrs[COLOR_array__ArrayIterator___index].l = var1; /* _index on <self:ArrayIterator[nullable Object]> */
2677 RET_LABEL:;
2678 }
2679 /* method array#ArrayIterator#init for (self: Object, AbstractArrayRead[nullable Object]) */
2680 void VIRTUAL_array__ArrayIterator__init(val* self, val* p0) {
2681 array__ArrayIterator__init(self, p0);
2682 RET_LABEL:;
2683 }
2684 /* method array#ArrayIterator#index for (self: ArrayIterator[nullable Object]): Int */
2685 long array__ArrayIterator__index(val* self) {
2686 long var /* : Int */;
2687 long var1 /* : Int */;
2688 var1 = self->attrs[COLOR_array__ArrayIterator___index].l; /* _index on <self:ArrayIterator[nullable Object]> */
2689 var = var1;
2690 RET_LABEL:;
2691 return var;
2692 }
2693 /* method array#ArrayIterator#index for (self: Object): Int */
2694 long VIRTUAL_array__ArrayIterator__index(val* self) {
2695 long var /* : Int */;
2696 long var1 /* : Int */;
2697 var1 = array__ArrayIterator__index(self);
2698 var = var1;
2699 RET_LABEL:;
2700 return var;
2701 }
2702 /* method array#ArraySet#has for (self: ArraySet[Object], Object): Bool */
2703 short int array__ArraySet__has(val* self, val* p0) {
2704 short int var /* : Bool */;
2705 short int var1 /* : Bool */;
2706 int cltype;
2707 int idtype;
2708 const struct type* type_struct;
2709 const char* var_class_name;
2710 val* var_e /* var e: Object */;
2711 val* var2 /* : Array[Object] */;
2712 short int var3 /* : Bool */;
2713 /* Covariant cast for argument 0 (e) <p0:Object> isa Collection#0 */
2714 /* <p0:Object> isa Collection#0 */
2715 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collection_FT0];
2716 cltype = type_struct->color;
2717 idtype = type_struct->id;
2718 if(cltype >= p0->type->table_size) {
2719 var1 = 0;
2720 } else {
2721 var1 = p0->type->type_table[cltype] == idtype;
2722 }
2723 if (!var1) {
2724 var_class_name = p0 == NULL ? "null" : p0->type->name;
2725 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection#0", var_class_name);
2726 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 387);
2727 show_backtrace(1);
2728 }
2729 var_e = p0;
2730 var2 = self->attrs[COLOR_array__ArraySet___array].val; /* _array on <self:ArraySet[Object]> */
2731 if (var2 == NULL) {
2732 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _array");
2733 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 387);
2734 show_backtrace(1);
2735 }
2736 var3 = ((short int (*)(val*, val*))(var2->class->vft[COLOR_abstract_collection__Collection__has]))(var2, var_e) /* has on <var2:Array[Object]>*/;
2737 var = var3;
2738 goto RET_LABEL;
2739 RET_LABEL:;
2740 return var;
2741 }
2742 /* method array#ArraySet#has for (self: Object, nullable Object): Bool */
2743 short int VIRTUAL_array__ArraySet__has(val* self, val* p0) {
2744 short int var /* : Bool */;
2745 short int var1 /* : Bool */;
2746 var1 = array__ArraySet__has(self, p0);
2747 var = var1;
2748 RET_LABEL:;
2749 return var;
2750 }
2751 /* method array#ArraySet#add for (self: ArraySet[Object], Object) */
2752 void array__ArraySet__add(val* self, val* p0) {
2753 short int var /* : Bool */;
2754 int cltype;
2755 int idtype;
2756 const struct type* type_struct;
2757 const char* var_class_name;
2758 val* var_e /* var e: Object */;
2759 val* var1 /* : Array[Object] */;
2760 short int var2 /* : Bool */;
2761 short int var3 /* : Bool */;
2762 val* var4 /* : Array[Object] */;
2763 /* Covariant cast for argument 0 (e) <p0:Object> isa SimpleCollection#0 */
2764 /* <p0:Object> isa SimpleCollection#0 */
2765 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__SimpleCollection_FT0];
2766 cltype = type_struct->color;
2767 idtype = type_struct->id;
2768 if(cltype >= p0->type->table_size) {
2769 var = 0;
2770 } else {
2771 var = p0->type->type_table[cltype] == idtype;
2772 }
2773 if (!var) {
2774 var_class_name = p0 == NULL ? "null" : p0->type->name;
2775 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "SimpleCollection#0", var_class_name);
2776 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 389);
2777 show_backtrace(1);
2778 }
2779 var_e = p0;
2780 var1 = self->attrs[COLOR_array__ArraySet___array].val; /* _array on <self:ArraySet[Object]> */
2781 if (var1 == NULL) {
2782 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _array");
2783 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 389);
2784 show_backtrace(1);
2785 }
2786 var2 = ((short int (*)(val*, val*))(var1->class->vft[COLOR_abstract_collection__Collection__has]))(var1, var_e) /* has on <var1:Array[Object]>*/;
2787 var3 = !var2;
2788 if (var3){
2789 var4 = self->attrs[COLOR_array__ArraySet___array].val; /* _array on <self:ArraySet[Object]> */
2790 if (var4 == NULL) {
2791 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _array");
2792 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 389);
2793 show_backtrace(1);
2794 }
2795 ((void (*)(val*, val*))(var4->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var4, var_e) /* add on <var4:Array[Object]>*/;
2796 } else {
2797 }
2798 RET_LABEL:;
2799 }
2800 /* method array#ArraySet#add for (self: Object, nullable Object) */
2801 void VIRTUAL_array__ArraySet__add(val* self, val* p0) {
2802 array__ArraySet__add(self, p0);
2803 RET_LABEL:;
2804 }
2805 /* method array#ArraySet#is_empty for (self: ArraySet[Object]): Bool */
2806 short int array__ArraySet__is_empty(val* self) {
2807 short int var /* : Bool */;
2808 val* var1 /* : Array[Object] */;
2809 short int var2 /* : Bool */;
2810 var1 = self->attrs[COLOR_array__ArraySet___array].val; /* _array on <self:ArraySet[Object]> */
2811 if (var1 == NULL) {
2812 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _array");
2813 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 391);
2814 show_backtrace(1);
2815 }
2816 var2 = ((short int (*)(val*))(var1->class->vft[COLOR_abstract_collection__Collection__is_empty]))(var1) /* is_empty on <var1:Array[Object]>*/;
2817 var = var2;
2818 goto RET_LABEL;
2819 RET_LABEL:;
2820 return var;
2821 }
2822 /* method array#ArraySet#is_empty for (self: Object): Bool */
2823 short int VIRTUAL_array__ArraySet__is_empty(val* self) {
2824 short int var /* : Bool */;
2825 short int var1 /* : Bool */;
2826 var1 = array__ArraySet__is_empty(self);
2827 var = var1;
2828 RET_LABEL:;
2829 return var;
2830 }
2831 /* method array#ArraySet#length for (self: ArraySet[Object]): Int */
2832 long array__ArraySet__length(val* self) {
2833 long var /* : Int */;
2834 val* var1 /* : Array[Object] */;
2835 long var2 /* : Int */;
2836 var1 = self->attrs[COLOR_array__ArraySet___array].val; /* _array on <self:ArraySet[Object]> */
2837 if (var1 == NULL) {
2838 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _array");
2839 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 393);
2840 show_backtrace(1);
2841 }
2842 var2 = ((long (*)(val*))(var1->class->vft[COLOR_abstract_collection__Collection__length]))(var1) /* length on <var1:Array[Object]>*/;
2843 var = var2;
2844 goto RET_LABEL;
2845 RET_LABEL:;
2846 return var;
2847 }
2848 /* method array#ArraySet#length for (self: Object): Int */
2849 long VIRTUAL_array__ArraySet__length(val* self) {
2850 long var /* : Int */;
2851 long var1 /* : Int */;
2852 var1 = array__ArraySet__length(self);
2853 var = var1;
2854 RET_LABEL:;
2855 return var;
2856 }
2857 /* method array#ArraySet#first for (self: ArraySet[Object]): Object */
2858 val* array__ArraySet__first(val* self) {
2859 val* var /* : Object */;
2860 val* var1 /* : Array[Object] */;
2861 long var2 /* : Int */;
2862 long var3 /* : Int */;
2863 short int var4 /* : Bool */;
2864 short int var6 /* : Bool */;
2865 int cltype;
2866 int idtype;
2867 const char* var_class_name;
2868 short int var7 /* : Bool */;
2869 val* var8 /* : Array[Object] */;
2870 val* var9 /* : nullable Object */;
2871 var1 = self->attrs[COLOR_array__ArraySet___array].val; /* _array on <self:ArraySet[Object]> */
2872 if (var1 == NULL) {
2873 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _array");
2874 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 397);
2875 show_backtrace(1);
2876 }
2877 var2 = ((long (*)(val*))(var1->class->vft[COLOR_abstract_collection__Collection__length]))(var1) /* length on <var1:Array[Object]>*/;
2878 var3 = 0;
2879 { /* Inline kernel#Int#> (var2,var3) */
2880 /* Covariant cast for argument 0 (i) <var3:Int> isa OTHER */
2881 /* <var3:Int> isa OTHER */
2882 var6 = 1; /* easy <var3:Int> isa OTHER*/
2883 if (!var6) {
2884 var_class_name = type_kernel__Int.name;
2885 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
2886 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 263);
2887 show_backtrace(1);
2888 }
2889 var7 = var2 > var3;
2890 var4 = var7;
2891 goto RET_LABEL5;
2892 RET_LABEL5:(void)0;
2893 }
2894 if (!var4) {
2895 fprintf(stderr, "Runtime error: %s", "Assert failed");
2896 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 397);
2897 show_backtrace(1);
2898 }
2899 var8 = self->attrs[COLOR_array__ArraySet___array].val; /* _array on <self:ArraySet[Object]> */
2900 if (var8 == NULL) {
2901 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _array");
2902 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 398);
2903 show_backtrace(1);
2904 }
2905 var9 = ((val* (*)(val*))(var8->class->vft[COLOR_abstract_collection__Collection__first]))(var8) /* first on <var8:Array[Object]>*/;
2906 var = var9;
2907 goto RET_LABEL;
2908 RET_LABEL:;
2909 return var;
2910 }
2911 /* method array#ArraySet#first for (self: Object): nullable Object */
2912 val* VIRTUAL_array__ArraySet__first(val* self) {
2913 val* var /* : nullable Object */;
2914 val* var1 /* : Object */;
2915 var1 = array__ArraySet__first(self);
2916 var = var1;
2917 RET_LABEL:;
2918 return var;
2919 }
2920 /* method array#ArraySet#remove for (self: ArraySet[Object], Object) */
2921 void array__ArraySet__remove(val* self, val* p0) {
2922 short int var /* : Bool */;
2923 int cltype;
2924 int idtype;
2925 const struct type* type_struct;
2926 const char* var_class_name;
2927 val* var_item /* var item: Object */;
2928 val* var1 /* : Array[Object] */;
2929 long var2 /* : Int */;
2930 long var_i /* var i: Int */;
2931 long var3 /* : Int */;
2932 short int var4 /* : Bool */;
2933 short int var6 /* : Bool */;
2934 int cltype7;
2935 int idtype8;
2936 const char* var_class_name9;
2937 short int var10 /* : Bool */;
2938 /* Covariant cast for argument 0 (item) <p0:Object> isa RemovableCollection#0 */
2939 /* <p0:Object> isa RemovableCollection#0 */
2940 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__RemovableCollection_FT0];
2941 cltype = type_struct->color;
2942 idtype = type_struct->id;
2943 if(cltype >= p0->type->table_size) {
2944 var = 0;
2945 } else {
2946 var = p0->type->type_table[cltype] == idtype;
2947 }
2948 if (!var) {
2949 var_class_name = p0 == NULL ? "null" : p0->type->name;
2950 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "RemovableCollection#0", var_class_name);
2951 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 401);
2952 show_backtrace(1);
2953 }
2954 var_item = p0;
2955 var1 = self->attrs[COLOR_array__ArraySet___array].val; /* _array on <self:ArraySet[Object]> */
2956 if (var1 == NULL) {
2957 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _array");
2958 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 403);
2959 show_backtrace(1);
2960 }
2961 var2 = ((long (*)(val*, val*))(var1->class->vft[COLOR_abstract_collection__SequenceRead__index_of]))(var1, var_item) /* index_of on <var1:Array[Object]>*/;
2962 var_i = var2;
2963 var3 = 0;
2964 { /* Inline kernel#Int#>= (var_i,var3) */
2965 /* Covariant cast for argument 0 (i) <var3:Int> isa OTHER */
2966 /* <var3:Int> isa OTHER */
2967 var6 = 1; /* easy <var3:Int> isa OTHER*/
2968 if (!var6) {
2969 var_class_name9 = type_kernel__Int.name;
2970 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name9);
2971 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 262);
2972 show_backtrace(1);
2973 }
2974 var10 = var_i >= var3;
2975 var4 = var10;
2976 goto RET_LABEL5;
2977 RET_LABEL5:(void)0;
2978 }
2979 if (var4){
2980 ((void (*)(val*, long))(self->class->vft[COLOR_array__ArraySet__remove_at]))(self, var_i) /* remove_at on <self:ArraySet[Object]>*/;
2981 } else {
2982 }
2983 RET_LABEL:;
2984 }
2985 /* method array#ArraySet#remove for (self: Object, nullable Object) */
2986 void VIRTUAL_array__ArraySet__remove(val* self, val* p0) {
2987 array__ArraySet__remove(self, p0);
2988 RET_LABEL:;
2989 }
2990 /* method array#ArraySet#remove_all for (self: ArraySet[Object], Object) */
2991 void array__ArraySet__remove_all(val* self, val* p0) {
2992 short int var /* : Bool */;
2993 int cltype;
2994 int idtype;
2995 const struct type* type_struct;
2996 const char* var_class_name;
2997 val* var_item /* var item: Object */;
2998 /* Covariant cast for argument 0 (item) <p0:Object> isa RemovableCollection#0 */
2999 /* <p0:Object> isa RemovableCollection#0 */
3000 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__RemovableCollection_FT0];
3001 cltype = type_struct->color;
3002 idtype = type_struct->id;
3003 if(cltype >= p0->type->table_size) {
3004 var = 0;
3005 } else {
3006 var = p0->type->type_table[cltype] == idtype;
3007 }
3008 if (!var) {
3009 var_class_name = p0 == NULL ? "null" : p0->type->name;
3010 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "RemovableCollection#0", var_class_name);
3011 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 407);
3012 show_backtrace(1);
3013 }
3014 var_item = p0;
3015 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__RemovableCollection__remove]))(self, var_item) /* remove on <self:ArraySet[Object]>*/;
3016 RET_LABEL:;
3017 }
3018 /* method array#ArraySet#remove_all for (self: Object, nullable Object) */
3019 void VIRTUAL_array__ArraySet__remove_all(val* self, val* p0) {
3020 array__ArraySet__remove_all(self, p0);
3021 RET_LABEL:;
3022 }
3023 /* method array#ArraySet#clear for (self: ArraySet[Object]) */
3024 void array__ArraySet__clear(val* self) {
3025 val* var /* : Array[Object] */;
3026 var = self->attrs[COLOR_array__ArraySet___array].val; /* _array on <self:ArraySet[Object]> */
3027 if (var == NULL) {
3028 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _array");
3029 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 409);
3030 show_backtrace(1);
3031 }
3032 ((void (*)(val*))(var->class->vft[COLOR_abstract_collection__RemovableCollection__clear]))(var) /* clear on <var:Array[Object]>*/;
3033 RET_LABEL:;
3034 }
3035 /* method array#ArraySet#clear for (self: Object) */
3036 void VIRTUAL_array__ArraySet__clear(val* self) {
3037 array__ArraySet__clear(self);
3038 RET_LABEL:;
3039 }
3040 /* method array#ArraySet#iterator for (self: ArraySet[Object]): Iterator[Object] */
3041 val* array__ArraySet__iterator(val* self) {
3042 val* var /* : Iterator[Object] */;
3043 val* var1 /* : ArraySetIterator[Object] */;
3044 val* var2 /* : Array[Object] */;
3045 val* var3 /* : Iterator[nullable Object] */;
3046 var1 = NEW_array__ArraySetIterator(self->type->resolution_table->types[COLOR_array__ArraySetIteratorarray__ArraySet_FT0]);
3047 var2 = self->attrs[COLOR_array__ArraySet___array].val; /* _array on <self:ArraySet[Object]> */
3048 if (var2 == NULL) {
3049 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _array");
3050 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 411);
3051 show_backtrace(1);
3052 }
3053 var3 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_collection__Collection__iterator]))(var2) /* iterator on <var2:Array[Object]>*/;
3054 ((void (*)(val*, val*))(var1->class->vft[COLOR_array__ArraySetIterator__init]))(var1, var3) /* init on <var1:ArraySetIterator[Object]>*/;
3055 var = var1;
3056 goto RET_LABEL;
3057 RET_LABEL:;
3058 return var;
3059 }
3060 /* method array#ArraySet#iterator for (self: Object): Iterator[nullable Object] */
3061 val* VIRTUAL_array__ArraySet__iterator(val* self) {
3062 val* var /* : Iterator[nullable Object] */;
3063 val* var1 /* : Iterator[Object] */;
3064 var1 = array__ArraySet__iterator(self);
3065 var = var1;
3066 RET_LABEL:;
3067 return var;
3068 }
3069 /* method array#ArraySet#enlarge for (self: ArraySet[Object], Int) */
3070 void array__ArraySet__enlarge(val* self, long p0) {
3071 long var_cap /* var cap: Int */;
3072 val* var /* : Array[Object] */;
3073 var_cap = p0;
3074 var = self->attrs[COLOR_array__ArraySet___array].val; /* _array on <self:ArraySet[Object]> */
3075 if (var == NULL) {
3076 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _array");
3077 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 414);
3078 show_backtrace(1);
3079 }
3080 ((void (*)(val*, long))(var->class->vft[COLOR_array__AbstractArray__enlarge]))(var, var_cap) /* enlarge on <var:Array[Object]>*/;
3081 RET_LABEL:;
3082 }
3083 /* method array#ArraySet#enlarge for (self: Object, Int) */
3084 void VIRTUAL_array__ArraySet__enlarge(val* self, long p0) {
3085 array__ArraySet__enlarge(self, p0);
3086 RET_LABEL:;
3087 }
3088 /* method array#ArraySet#remove_at for (self: ArraySet[Object], Int) */
3089 void array__ArraySet__remove_at(val* self, long p0) {
3090 long var_i /* var i: Int */;
3091 val* var /* : Array[Object] */;
3092 val* var1 /* : Array[Object] */;
3093 val* var2 /* : nullable Object */;
3094 val* var3 /* : Array[Object] */;
3095 val* var4 /* : nullable Object */;
3096 var_i = p0;
3097 var = self->attrs[COLOR_array__ArraySet___array].val; /* _array on <self:ArraySet[Object]> */
3098 if (var == NULL) {
3099 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _array");
3100 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 418);
3101 show_backtrace(1);
3102 }
3103 var1 = self->attrs[COLOR_array__ArraySet___array].val; /* _array on <self:ArraySet[Object]> */
3104 if (var1 == NULL) {
3105 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _array");
3106 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 418);
3107 show_backtrace(1);
3108 }
3109 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_abstract_collection__SequenceRead__last]))(var1) /* last on <var1:Array[Object]>*/;
3110 ((void (*)(val*, long, val*))(var->class->vft[COLOR_abstract_collection__Sequence___91d_93d_61d]))(var, var_i, var2) /* []= on <var:Array[Object]>*/;
3111 var3 = self->attrs[COLOR_array__ArraySet___array].val; /* _array on <self:ArraySet[Object]> */
3112 if (var3 == NULL) {
3113 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _array");
3114 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 419);
3115 show_backtrace(1);
3116 }
3117 var4 = ((val* (*)(val*))(var3->class->vft[COLOR_abstract_collection__Sequence__pop]))(var3) /* pop on <var3:Array[Object]>*/;
3118 var4;
3119 RET_LABEL:;
3120 }
3121 /* method array#ArraySet#remove_at for (self: Object, Int) */
3122 void VIRTUAL_array__ArraySet__remove_at(val* self, long p0) {
3123 array__ArraySet__remove_at(self, p0);
3124 RET_LABEL:;
3125 }
3126 /* method array#ArraySet#init for (self: ArraySet[Object]) */
3127 void array__ArraySet__init(val* self) {
3128 val* var /* : Array[Object] */;
3129 var = NEW_array__Array(self->type->resolution_table->types[COLOR_array__Arrayarray__ArraySet_FT0]);
3130 ((void (*)(val*))(var->class->vft[COLOR_array__Array__init]))(var) /* init on <var:Array[Object]>*/;
3131 self->attrs[COLOR_array__ArraySet___array].val = var; /* _array on <self:ArraySet[Object]> */
3132 RET_LABEL:;
3133 }
3134 /* method array#ArraySet#init for (self: Object) */
3135 void VIRTUAL_array__ArraySet__init(val* self) {
3136 array__ArraySet__init(self);
3137 RET_LABEL:;
3138 }
3139 /* method array#ArraySet#with_capacity for (self: ArraySet[Object], Int) */
3140 void array__ArraySet__with_capacity(val* self, long p0) {
3141 long var_i /* var i: Int */;
3142 val* var /* : Array[Object] */;
3143 var_i = p0;
3144 var = NEW_array__Array(self->type->resolution_table->types[COLOR_array__Arrayarray__ArraySet_FT0]);
3145 ((void (*)(val*, long))(var->class->vft[COLOR_array__Array__with_capacity]))(var, var_i) /* with_capacity on <var:Array[Object]>*/;
3146 self->attrs[COLOR_array__ArraySet___array].val = var; /* _array on <self:ArraySet[Object]> */
3147 RET_LABEL:;
3148 }
3149 /* method array#ArraySet#with_capacity for (self: Object, Int) */
3150 void VIRTUAL_array__ArraySet__with_capacity(val* self, long p0) {
3151 array__ArraySet__with_capacity(self, p0);
3152 RET_LABEL:;
3153 }
3154 /* method array#ArraySetIterator#is_ok for (self: ArraySetIterator[Object]): Bool */
3155 short int array__ArraySetIterator__is_ok(val* self) {
3156 short int var /* : Bool */;
3157 val* var1 /* : ArrayIterator[Object] */;
3158 short int var2 /* : Bool */;
3159 var1 = self->attrs[COLOR_array__ArraySetIterator___iter].val; /* _iter on <self:ArraySetIterator[Object]> */
3160 if (var1 == NULL) {
3161 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _iter");
3162 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 433);
3163 show_backtrace(1);
3164 }
3165 var2 = ((short int (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var1) /* is_ok on <var1:ArrayIterator[Object]>*/;
3166 var = var2;
3167 goto RET_LABEL;
3168 RET_LABEL:;
3169 return var;
3170 }
3171 /* method array#ArraySetIterator#is_ok for (self: Object): Bool */
3172 short int VIRTUAL_array__ArraySetIterator__is_ok(val* self) {
3173 short int var /* : Bool */;
3174 short int var1 /* : Bool */;
3175 var1 = array__ArraySetIterator__is_ok(self);
3176 var = var1;
3177 RET_LABEL:;
3178 return var;
3179 }
3180 /* method array#ArraySetIterator#next for (self: ArraySetIterator[Object]) */
3181 void array__ArraySetIterator__next(val* self) {
3182 val* var /* : ArrayIterator[Object] */;
3183 var = self->attrs[COLOR_array__ArraySetIterator___iter].val; /* _iter on <self:ArraySetIterator[Object]> */
3184 if (var == NULL) {
3185 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _iter");
3186 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 435);
3187 show_backtrace(1);
3188 }
3189 ((void (*)(val*))(var->class->vft[COLOR_abstract_collection__Iterator__next]))(var) /* next on <var:ArrayIterator[Object]>*/;
3190 RET_LABEL:;
3191 }
3192 /* method array#ArraySetIterator#next for (self: Object) */
3193 void VIRTUAL_array__ArraySetIterator__next(val* self) {
3194 array__ArraySetIterator__next(self);
3195 RET_LABEL:;
3196 }
3197 /* method array#ArraySetIterator#item for (self: ArraySetIterator[Object]): Object */
3198 val* array__ArraySetIterator__item(val* self) {
3199 val* var /* : Object */;
3200 val* var1 /* : ArrayIterator[Object] */;
3201 val* var2 /* : nullable Object */;
3202 var1 = self->attrs[COLOR_array__ArraySetIterator___iter].val; /* _iter on <self:ArraySetIterator[Object]> */
3203 if (var1 == NULL) {
3204 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _iter");
3205 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 437);
3206 show_backtrace(1);
3207 }
3208 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__item]))(var1) /* item on <var1:ArrayIterator[Object]>*/;
3209 var = var2;
3210 goto RET_LABEL;
3211 RET_LABEL:;
3212 return var;
3213 }
3214 /* method array#ArraySetIterator#item for (self: Object): nullable Object */
3215 val* VIRTUAL_array__ArraySetIterator__item(val* self) {
3216 val* var /* : nullable Object */;
3217 val* var1 /* : Object */;
3218 var1 = array__ArraySetIterator__item(self);
3219 var = var1;
3220 RET_LABEL:;
3221 return var;
3222 }
3223 /* method array#ArraySetIterator#init for (self: ArraySetIterator[Object], ArrayIterator[Object]) */
3224 void array__ArraySetIterator__init(val* self, val* p0) {
3225 short int var /* : Bool */;
3226 int cltype;
3227 int idtype;
3228 const struct type* type_struct;
3229 const char* var_class_name;
3230 val* var_iter /* var iter: ArrayIterator[Object] */;
3231 /* Covariant cast for argument 0 (iter) <p0:ArrayIterator[Object]> isa ArrayIterator[ArraySetIterator#0] */
3232 /* <p0:ArrayIterator[Object]> isa ArrayIterator[ArraySetIterator#0] */
3233 type_struct = self->type->resolution_table->types[COLOR_array__ArrayIteratorarray__ArraySetIterator_FT0];
3234 cltype = type_struct->color;
3235 idtype = type_struct->id;
3236 if(cltype >= p0->type->table_size) {
3237 var = 0;
3238 } else {
3239 var = p0->type->type_table[cltype] == idtype;
3240 }
3241 if (!var) {
3242 var_class_name = p0 == NULL ? "null" : p0->type->name;
3243 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "ArrayIterator[ArraySetIterator#0]", var_class_name);
3244 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 439);
3245 show_backtrace(1);
3246 }
3247 var_iter = p0;
3248 self->attrs[COLOR_array__ArraySetIterator___iter].val = var_iter; /* _iter on <self:ArraySetIterator[Object]> */
3249 RET_LABEL:;
3250 }
3251 /* method array#ArraySetIterator#init for (self: Object, ArrayIterator[Object]) */
3252 void VIRTUAL_array__ArraySetIterator__init(val* self, val* p0) {
3253 array__ArraySetIterator__init(self, p0);
3254 RET_LABEL:;
3255 }
3256 /* method array#ArrayMap#[] for (self: ArrayMap[Object, nullable Object], Object): nullable Object */
3257 val* array__ArrayMap___91d_93d(val* self, val* p0) {
3258 val* var /* : nullable Object */;
3259 short int var1 /* : Bool */;
3260 int cltype;
3261 int idtype;
3262 const struct type* type_struct;
3263 const char* var_class_name;
3264 val* var_key /* var key: Object */;
3265 long var2 /* : Int */;
3266 long var_i /* var i: Int */;
3267 long var3 /* : Int */;
3268 short int var4 /* : Bool */;
3269 short int var6 /* : Bool */;
3270 int cltype7;
3271 int idtype8;
3272 const char* var_class_name9;
3273 short int var10 /* : Bool */;
3274 val* var11 /* : Array[Couple[Object, nullable Object]] */;
3275 val* var12 /* : nullable Object */;
3276 val* var13 /* : nullable Object */;
3277 /* Covariant cast for argument 0 (key) <p0:Object> isa MapRead#0 */
3278 /* <p0:Object> isa MapRead#0 */
3279 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__MapRead_FT0];
3280 cltype = type_struct->color;
3281 idtype = type_struct->id;
3282 if(cltype >= p0->type->table_size) {
3283 var1 = 0;
3284 } else {
3285 var1 = p0->type->type_table[cltype] == idtype;
3286 }
3287 if (!var1) {
3288 var_class_name = p0 == NULL ? "null" : p0->type->name;
3289 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapRead#0", var_class_name);
3290 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 449);
3291 show_backtrace(1);
3292 }
3293 var_key = p0;
3294 var2 = ((long (*)(val*, val*))(self->class->vft[COLOR_array__ArrayMap__index]))(self, var_key) /* index on <self:ArrayMap[Object, nullable Object]>*/;
3295 var_i = var2;
3296 var3 = 0;
3297 { /* Inline kernel#Int#>= (var_i,var3) */
3298 /* Covariant cast for argument 0 (i) <var3:Int> isa OTHER */
3299 /* <var3:Int> isa OTHER */
3300 var6 = 1; /* easy <var3:Int> isa OTHER*/
3301 if (!var6) {
3302 var_class_name9 = type_kernel__Int.name;
3303 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name9);
3304 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 262);
3305 show_backtrace(1);
3306 }
3307 var10 = var_i >= var3;
3308 var4 = var10;
3309 goto RET_LABEL5;
3310 RET_LABEL5:(void)0;
3311 }
3312 if (var4){
3313 var11 = self->attrs[COLOR_array__ArrayMap___items].val; /* _items on <self:ArrayMap[Object, nullable Object]> */
3314 if (var11 == NULL) {
3315 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
3316 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 454);
3317 show_backtrace(1);
3318 }
3319 var12 = ((val* (*)(val*, long))(var11->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var11, var_i) /* [] on <var11:Array[Couple[Object, nullable Object]]>*/;
3320 var13 = ((val* (*)(val*))(var12->class->vft[COLOR_abstract_collection__Couple__second]))(var12) /* second on <var12:nullable Object(Couple[Object, nullable Object])>*/;
3321 var = var13;
3322 goto RET_LABEL;
3323 } else {
3324 fprintf(stderr, "Runtime error: %s", "Aborted");
3325 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 456);
3326 show_backtrace(1);
3327 }
3328 RET_LABEL:;
3329 return var;
3330 }
3331 /* method array#ArrayMap#[] for (self: Object, Object): nullable Object */
3332 val* VIRTUAL_array__ArrayMap___91d_93d(val* self, val* p0) {
3333 val* var /* : nullable Object */;
3334 val* var1 /* : nullable Object */;
3335 var1 = array__ArrayMap___91d_93d(self, p0);
3336 var = var1;
3337 RET_LABEL:;
3338 return var;
3339 }
3340 /* method array#ArrayMap#[]= for (self: ArrayMap[Object, nullable Object], Object, nullable Object) */
3341 void array__ArrayMap___91d_93d_61d(val* self, val* p0, val* p1) {
3342 short int var /* : Bool */;
3343 int cltype;
3344 int idtype;
3345 const struct type* type_struct;
3346 const char* var_class_name;
3347 short int var1 /* : Bool */;
3348 int cltype2;
3349 int idtype3;
3350 const struct type* type_struct4;
3351 short int is_nullable;
3352 const char* var_class_name5;
3353 val* var_key /* var key: Object */;
3354 val* var_item /* var item: nullable Object */;
3355 long var6 /* : Int */;
3356 long var_i /* var i: Int */;
3357 long var7 /* : Int */;
3358 short int var8 /* : Bool */;
3359 short int var10 /* : Bool */;
3360 int cltype11;
3361 int idtype12;
3362 const char* var_class_name13;
3363 short int var14 /* : Bool */;
3364 val* var15 /* : Array[Couple[Object, nullable Object]] */;
3365 val* var16 /* : nullable Object */;
3366 val* var17 /* : Array[Couple[Object, nullable Object]] */;
3367 val* var18 /* : Couple[Object, nullable Object] */;
3368 /* Covariant cast for argument 0 (key) <p0:Object> isa Map#0 */
3369 /* <p0:Object> isa Map#0 */
3370 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Map_FT0];
3371 cltype = type_struct->color;
3372 idtype = type_struct->id;
3373 if(cltype >= p0->type->table_size) {
3374 var = 0;
3375 } else {
3376 var = p0->type->type_table[cltype] == idtype;
3377 }
3378 if (!var) {
3379 var_class_name = p0 == NULL ? "null" : p0->type->name;
3380 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Map#0", var_class_name);
3381 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 460);
3382 show_backtrace(1);
3383 }
3384 /* Covariant cast for argument 1 (item) <p1:nullable Object> isa Map#1 */
3385 /* <p1:nullable Object> isa Map#1 */
3386 type_struct4 = self->type->resolution_table->types[COLOR_abstract_collection__Map_FT1];
3387 cltype2 = type_struct4->color;
3388 idtype3 = type_struct4->id;
3389 is_nullable = type_struct4->is_nullable;
3390 if(p1 == NULL) {
3391 var1 = is_nullable;
3392 } else {
3393 if(cltype2 >= p1->type->table_size) {
3394 var1 = 0;
3395 } else {
3396 var1 = p1->type->type_table[cltype2] == idtype3;
3397 }
3398 }
3399 if (!var1) {
3400 var_class_name5 = p1 == NULL ? "null" : p1->type->name;
3401 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Map#1", var_class_name5);
3402 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 460);
3403 show_backtrace(1);
3404 }
3405 var_key = p0;
3406 var_item = p1;
3407 var6 = ((long (*)(val*, val*))(self->class->vft[COLOR_array__ArrayMap__index]))(self, var_key) /* index on <self:ArrayMap[Object, nullable Object]>*/;
3408 var_i = var6;
3409 var7 = 0;
3410 { /* Inline kernel#Int#>= (var_i,var7) */
3411 /* Covariant cast for argument 0 (i) <var7:Int> isa OTHER */
3412 /* <var7:Int> isa OTHER */
3413 var10 = 1; /* easy <var7:Int> isa OTHER*/
3414 if (!var10) {
3415 var_class_name13 = type_kernel__Int.name;
3416 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name13);
3417 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 262);
3418 show_backtrace(1);
3419 }
3420 var14 = var_i >= var7;
3421 var8 = var14;
3422 goto RET_LABEL9;
3423 RET_LABEL9:(void)0;
3424 }
3425 if (var8){
3426 var15 = self->attrs[COLOR_array__ArrayMap___items].val; /* _items on <self:ArrayMap[Object, nullable Object]> */
3427 if (var15 == NULL) {
3428 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
3429 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 465);
3430 show_backtrace(1);
3431 }
3432 var16 = ((val* (*)(val*, long))(var15->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var15, var_i) /* [] on <var15:Array[Couple[Object, nullable Object]]>*/;
3433 ((void (*)(val*, val*))(var16->class->vft[COLOR_abstract_collection__Couple__second_61d]))(var16, var_item) /* second= on <var16:nullable Object(Couple[Object, nullable Object])>*/;
3434 } else {
3435 var17 = self->attrs[COLOR_array__ArrayMap___items].val; /* _items on <self:ArrayMap[Object, nullable Object]> */
3436 if (var17 == NULL) {
3437 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
3438 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 467);
3439 show_backtrace(1);
3440 }
3441 var18 = NEW_abstract_collection__Couple(self->type->resolution_table->types[COLOR_abstract_collection__Couplearray__ArrayMap_FT0array__ArrayMap_FT1]);
3442 ((void (*)(val*, val*, val*))(var18->class->vft[COLOR_abstract_collection__Couple__init]))(var18, var_key, var_item) /* init on <var18:Couple[Object, nullable Object]>*/;
3443 ((void (*)(val*, val*))(var17->class->vft[COLOR_abstract_collection__Sequence__push]))(var17, var18) /* push on <var17:Array[Couple[Object, nullable Object]]>*/;
3444 }
3445 RET_LABEL:;
3446 }
3447 /* method array#ArrayMap#[]= for (self: Object, Object, nullable Object) */
3448 void VIRTUAL_array__ArrayMap___91d_93d_61d(val* self, val* p0, val* p1) {
3449 array__ArrayMap___91d_93d_61d(self, p0, p1);
3450 RET_LABEL:;
3451 }
3452 /* method array#ArrayMap#keys for (self: ArrayMap[Object, nullable Object]): ArrayMapKeys[Object, nullable Object] */
3453 val* array__ArrayMap__keys(val* self) {
3454 val* var /* : ArrayMapKeys[Object, nullable Object] */;
3455 val* var1 /* : ArrayMapKeys[Object, nullable Object] */;
3456 var1 = self->attrs[COLOR_array__ArrayMap___64dkeys].val; /* @keys on <self:ArrayMap[Object, nullable Object]> */
3457 if (var1 == NULL) {
3458 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @keys");
3459 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 471);
3460 show_backtrace(1);
3461 }
3462 var = var1;
3463 RET_LABEL:;
3464 return var;
3465 }
3466 /* method array#ArrayMap#keys for (self: Object): Collection[Object] */
3467 val* VIRTUAL_array__ArrayMap__keys(val* self) {
3468 val* var /* : Collection[Object] */;
3469 val* var1 /* : ArrayMapKeys[Object, nullable Object] */;
3470 var1 = array__ArrayMap__keys(self);
3471 var = var1;
3472 RET_LABEL:;
3473 return var;
3474 }
3475 /* method array#ArrayMap#keys= for (self: ArrayMap[Object, nullable Object], ArrayMapKeys[Object, nullable Object]) */
3476 void array__ArrayMap__keys_61d(val* self, val* p0) {
3477 short int var /* : Bool */;
3478 int cltype;
3479 int idtype;
3480 const struct type* type_struct;
3481 const char* var_class_name;
3482 /* Covariant cast for argument 0 (keys) <p0:ArrayMapKeys[Object, nullable Object]> isa ArrayMapKeys[ArrayMap#0, ArrayMap#1] */
3483 /* <p0:ArrayMapKeys[Object, nullable Object]> isa ArrayMapKeys[ArrayMap#0, ArrayMap#1] */
3484 type_struct = self->type->resolution_table->types[COLOR_array__ArrayMapKeysarray__ArrayMap_FT0array__ArrayMap_FT1];
3485 cltype = type_struct->color;
3486 idtype = type_struct->id;
3487 if(cltype >= p0->type->table_size) {
3488 var = 0;
3489 } else {
3490 var = p0->type->type_table[cltype] == idtype;
3491 }
3492 if (!var) {
3493 var_class_name = p0 == NULL ? "null" : p0->type->name;
3494 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "ArrayMapKeys[ArrayMap#0, ArrayMap#1]", var_class_name);
3495 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 471);
3496 show_backtrace(1);
3497 }
3498 self->attrs[COLOR_array__ArrayMap___64dkeys].val = p0; /* @keys on <self:ArrayMap[Object, nullable Object]> */
3499 RET_LABEL:;
3500 }
3501 /* method array#ArrayMap#keys= for (self: Object, ArrayMapKeys[Object, nullable Object]) */
3502 void VIRTUAL_array__ArrayMap__keys_61d(val* self, val* p0) {
3503 array__ArrayMap__keys_61d(self, p0);
3504 RET_LABEL:;
3505 }
3506 /* method array#ArrayMap#values for (self: ArrayMap[Object, nullable Object]): ArrayMapValues[Object, nullable Object] */
3507 val* array__ArrayMap__values(val* self) {
3508 val* var /* : ArrayMapValues[Object, nullable Object] */;
3509 val* var1 /* : ArrayMapValues[Object, nullable Object] */;
3510 var1 = self->attrs[COLOR_array__ArrayMap___64dvalues].val; /* @values on <self:ArrayMap[Object, nullable Object]> */
3511 if (var1 == NULL) {
3512 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @values");
3513 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 472);
3514 show_backtrace(1);
3515 }
3516 var = var1;
3517 RET_LABEL:;
3518 return var;
3519 }
3520 /* method array#ArrayMap#values for (self: Object): Collection[nullable Object] */
3521 val* VIRTUAL_array__ArrayMap__values(val* self) {
3522 val* var /* : Collection[nullable Object] */;
3523 val* var1 /* : ArrayMapValues[Object, nullable Object] */;
3524 var1 = array__ArrayMap__values(self);
3525 var = var1;
3526 RET_LABEL:;
3527 return var;
3528 }
3529 /* method array#ArrayMap#values= for (self: ArrayMap[Object, nullable Object], ArrayMapValues[Object, nullable Object]) */
3530 void array__ArrayMap__values_61d(val* self, val* p0) {
3531 short int var /* : Bool */;
3532 int cltype;
3533 int idtype;
3534 const struct type* type_struct;
3535 const char* var_class_name;
3536 /* Covariant cast for argument 0 (values) <p0:ArrayMapValues[Object, nullable Object]> isa ArrayMapValues[ArrayMap#0, ArrayMap#1] */
3537 /* <p0:ArrayMapValues[Object, nullable Object]> isa ArrayMapValues[ArrayMap#0, ArrayMap#1] */
3538 type_struct = self->type->resolution_table->types[COLOR_array__ArrayMapValuesarray__ArrayMap_FT0array__ArrayMap_FT1];
3539 cltype = type_struct->color;
3540 idtype = type_struct->id;
3541 if(cltype >= p0->type->table_size) {
3542 var = 0;
3543 } else {
3544 var = p0->type->type_table[cltype] == idtype;
3545 }
3546 if (!var) {
3547 var_class_name = p0 == NULL ? "null" : p0->type->name;
3548 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "ArrayMapValues[ArrayMap#0, ArrayMap#1]", var_class_name);
3549 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 472);
3550 show_backtrace(1);
3551 }
3552 self->attrs[COLOR_array__ArrayMap___64dvalues].val = p0; /* @values on <self:ArrayMap[Object, nullable Object]> */
3553 RET_LABEL:;
3554 }
3555 /* method array#ArrayMap#values= for (self: Object, ArrayMapValues[Object, nullable Object]) */
3556 void VIRTUAL_array__ArrayMap__values_61d(val* self, val* p0) {
3557 array__ArrayMap__values_61d(self, p0);
3558 RET_LABEL:;
3559 }
3560 /* method array#ArrayMap#length for (self: ArrayMap[Object, nullable Object]): Int */
3561 long array__ArrayMap__length(val* self) {
3562 long var /* : Int */;
3563 val* var1 /* : Array[Couple[Object, nullable Object]] */;
3564 long var2 /* : Int */;
3565 var1 = self->attrs[COLOR_array__ArrayMap___items].val; /* _items on <self:ArrayMap[Object, nullable Object]> */
3566 if (var1 == NULL) {
3567 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
3568 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 475);
3569 show_backtrace(1);
3570 }
3571 var2 = ((long (*)(val*))(var1->class->vft[COLOR_abstract_collection__Collection__length]))(var1) /* length on <var1:Array[Couple[Object, nullable Object]]>*/;
3572 var = var2;
3573 goto RET_LABEL;
3574 RET_LABEL:;
3575 return var;
3576 }
3577 /* method array#ArrayMap#length for (self: Object): Int */
3578 long VIRTUAL_array__ArrayMap__length(val* self) {
3579 long var /* : Int */;
3580 long var1 /* : Int */;
3581 var1 = array__ArrayMap__length(self);
3582 var = var1;
3583 RET_LABEL:;
3584 return var;
3585 }
3586 /* method array#ArrayMap#iterator for (self: ArrayMap[Object, nullable Object]): CoupleMapIterator[Object, nullable Object] */
3587 val* array__ArrayMap__iterator(val* self) {
3588 val* var /* : CoupleMapIterator[Object, nullable Object] */;
3589 val* var1 /* : CoupleMapIterator[Object, nullable Object] */;
3590 val* var2 /* : Array[Couple[Object, nullable Object]] */;
3591 val* var3 /* : Iterator[nullable Object] */;
3592 var1 = NEW_abstract_collection__CoupleMapIterator(self->type->resolution_table->types[COLOR_abstract_collection__CoupleMapIteratorarray__ArrayMap_FT0array__ArrayMap_FT1]);
3593 var2 = self->attrs[COLOR_array__ArrayMap___items].val; /* _items on <self:ArrayMap[Object, nullable Object]> */
3594 if (var2 == NULL) {
3595 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
3596 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 477);
3597 show_backtrace(1);
3598 }
3599 var3 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_collection__Collection__iterator]))(var2) /* iterator on <var2:Array[Couple[Object, nullable Object]]>*/;
3600 ((void (*)(val*, val*))(var1->class->vft[COLOR_abstract_collection__CoupleMapIterator__init]))(var1, var3) /* init on <var1:CoupleMapIterator[Object, nullable Object]>*/;
3601 var = var1;
3602 goto RET_LABEL;
3603 RET_LABEL:;
3604 return var;
3605 }
3606 /* method array#ArrayMap#iterator for (self: Object): MapIterator[Object, nullable Object] */
3607 val* VIRTUAL_array__ArrayMap__iterator(val* self) {
3608 val* var /* : MapIterator[Object, nullable Object] */;
3609 val* var1 /* : CoupleMapIterator[Object, nullable Object] */;
3610 var1 = array__ArrayMap__iterator(self);
3611 var = var1;
3612 RET_LABEL:;
3613 return var;
3614 }
3615 /* method array#ArrayMap#is_empty for (self: ArrayMap[Object, nullable Object]): Bool */
3616 short int array__ArrayMap__is_empty(val* self) {
3617 short int var /* : Bool */;
3618 val* var1 /* : Array[Couple[Object, nullable Object]] */;
3619 short int var2 /* : Bool */;
3620 var1 = self->attrs[COLOR_array__ArrayMap___items].val; /* _items on <self:ArrayMap[Object, nullable Object]> */
3621 if (var1 == NULL) {
3622 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
3623 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 479);
3624 show_backtrace(1);
3625 }
3626 var2 = ((short int (*)(val*))(var1->class->vft[COLOR_abstract_collection__Collection__is_empty]))(var1) /* is_empty on <var1:Array[Couple[Object, nullable Object]]>*/;
3627 var = var2;
3628 goto RET_LABEL;
3629 RET_LABEL:;
3630 return var;
3631 }
3632 /* method array#ArrayMap#is_empty for (self: Object): Bool */
3633 short int VIRTUAL_array__ArrayMap__is_empty(val* self) {
3634 short int var /* : Bool */;
3635 short int var1 /* : Bool */;
3636 var1 = array__ArrayMap__is_empty(self);
3637 var = var1;
3638 RET_LABEL:;
3639 return var;
3640 }
3641 /* method array#ArrayMap#clear for (self: ArrayMap[Object, nullable Object]) */
3642 void array__ArrayMap__clear(val* self) {
3643 val* var /* : Array[Couple[Object, nullable Object]] */;
3644 var = self->attrs[COLOR_array__ArrayMap___items].val; /* _items on <self:ArrayMap[Object, nullable Object]> */
3645 if (var == NULL) {
3646 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
3647 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 481);
3648 show_backtrace(1);
3649 }
3650 ((void (*)(val*))(var->class->vft[COLOR_abstract_collection__RemovableCollection__clear]))(var) /* clear on <var:Array[Couple[Object, nullable Object]]>*/;
3651 RET_LABEL:;
3652 }
3653 /* method array#ArrayMap#clear for (self: Object) */
3654 void VIRTUAL_array__ArrayMap__clear(val* self) {
3655 array__ArrayMap__clear(self);
3656 RET_LABEL:;
3657 }
3658 /* method array#ArrayMap#enlarge for (self: ArrayMap[Object, nullable Object], Int) */
3659 void array__ArrayMap__enlarge(val* self, long p0) {
3660 long var_cap /* var cap: Int */;
3661 val* var /* : Array[Couple[Object, nullable Object]] */;
3662 var_cap = p0;
3663 var = self->attrs[COLOR_array__ArrayMap___items].val; /* _items on <self:ArrayMap[Object, nullable Object]> */
3664 if (var == NULL) {
3665 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
3666 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 484);
3667 show_backtrace(1);
3668 }
3669 ((void (*)(val*, long))(var->class->vft[COLOR_array__AbstractArray__enlarge]))(var, var_cap) /* enlarge on <var:Array[Couple[Object, nullable Object]]>*/;
3670 RET_LABEL:;
3671 }
3672 /* method array#ArrayMap#enlarge for (self: Object, Int) */
3673 void VIRTUAL_array__ArrayMap__enlarge(val* self, long p0) {
3674 array__ArrayMap__enlarge(self, p0);
3675 RET_LABEL:;
3676 }
3677 /* method array#ArrayMap#couple_at for (self: ArrayMap[Object, nullable Object], Object): nullable Couple[Object, nullable Object] */
3678 val* array__ArrayMap__couple_at(val* self, val* p0) {
3679 val* var /* : nullable Couple[Object, nullable Object] */;
3680 short int var1 /* : Bool */;
3681 int cltype;
3682 int idtype;
3683 const struct type* type_struct;
3684 const char* var_class_name;
3685 val* var_key /* var key: Object */;
3686 long var2 /* : Int */;
3687 long var_i /* var i: Int */;
3688 long var3 /* : Int */;
3689 short int var4 /* : Bool */;
3690 short int var6 /* : Bool */;
3691 int cltype7;
3692 int idtype8;
3693 const char* var_class_name9;
3694 short int var10 /* : Bool */;
3695 val* var11 /* : Array[Couple[Object, nullable Object]] */;
3696 val* var12 /* : nullable Object */;
3697 val* var13 /* : null */;
3698 /* Covariant cast for argument 0 (key) <p0:Object> isa CoupleMap#0 */
3699 /* <p0:Object> isa CoupleMap#0 */
3700 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__CoupleMap_FT0];
3701 cltype = type_struct->color;
3702 idtype = type_struct->id;
3703 if(cltype >= p0->type->table_size) {
3704 var1 = 0;
3705 } else {
3706 var1 = p0->type->type_table[cltype] == idtype;
3707 }
3708 if (!var1) {
3709 var_class_name = p0 == NULL ? "null" : p0->type->name;
3710 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "CoupleMap#0", var_class_name);
3711 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 486);
3712 show_backtrace(1);
3713 }
3714 var_key = p0;
3715 var2 = ((long (*)(val*, val*))(self->class->vft[COLOR_array__ArrayMap__index]))(self, var_key) /* index on <self:ArrayMap[Object, nullable Object]>*/;
3716 var_i = var2;
3717 var3 = 0;
3718 { /* Inline kernel#Int#>= (var_i,var3) */
3719 /* Covariant cast for argument 0 (i) <var3:Int> isa OTHER */
3720 /* <var3:Int> isa OTHER */
3721 var6 = 1; /* easy <var3:Int> isa OTHER*/
3722 if (!var6) {
3723 var_class_name9 = type_kernel__Int.name;
3724 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name9);
3725 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 262);
3726 show_backtrace(1);
3727 }
3728 var10 = var_i >= var3;
3729 var4 = var10;
3730 goto RET_LABEL5;
3731 RET_LABEL5:(void)0;
3732 }
3733 if (var4){
3734 var11 = self->attrs[COLOR_array__ArrayMap___items].val; /* _items on <self:ArrayMap[Object, nullable Object]> */
3735 if (var11 == NULL) {
3736 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
3737 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 490);
3738 show_backtrace(1);
3739 }
3740 var12 = ((val* (*)(val*, long))(var11->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var11, var_i) /* [] on <var11:Array[Couple[Object, nullable Object]]>*/;
3741 var = var12;
3742 goto RET_LABEL;
3743 } else {
3744 var13 = NULL;
3745 var = var13;
3746 goto RET_LABEL;
3747 }
3748 RET_LABEL:;
3749 return var;
3750 }
3751 /* method array#ArrayMap#couple_at for (self: Object, Object): nullable Couple[Object, nullable Object] */
3752 val* VIRTUAL_array__ArrayMap__couple_at(val* self, val* p0) {
3753 val* var /* : nullable Couple[Object, nullable Object] */;
3754 val* var1 /* : nullable Couple[Object, nullable Object] */;
3755 var1 = array__ArrayMap__couple_at(self, p0);
3756 var = var1;
3757 RET_LABEL:;
3758 return var;
3759 }
3760 /* method array#ArrayMap#remove_at_index for (self: ArrayMap[Object, nullable Object], Int) */
3761 void array__ArrayMap__remove_at_index(val* self, long p0) {
3762 long var_i /* var i: Int */;
3763 val* var /* : Array[Couple[Object, nullable Object]] */;
3764 val* var1 /* : Array[Couple[Object, nullable Object]] */;
3765 val* var2 /* : nullable Object */;
3766 val* var3 /* : Array[Couple[Object, nullable Object]] */;
3767 val* var4 /* : nullable Object */;
3768 var_i = p0;
3769 var = self->attrs[COLOR_array__ArrayMap___items].val; /* _items on <self:ArrayMap[Object, nullable Object]> */
3770 if (var == NULL) {
3771 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
3772 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 502);
3773 show_backtrace(1);
3774 }
3775 var1 = self->attrs[COLOR_array__ArrayMap___items].val; /* _items on <self:ArrayMap[Object, nullable Object]> */
3776 if (var1 == NULL) {
3777 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
3778 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 502);
3779 show_backtrace(1);
3780 }
3781 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_abstract_collection__SequenceRead__last]))(var1) /* last on <var1:Array[Couple[Object, nullable Object]]>*/;
3782 ((void (*)(val*, long, val*))(var->class->vft[COLOR_abstract_collection__Sequence___91d_93d_61d]))(var, var_i, var2) /* []= on <var:Array[Couple[Object, nullable Object]]>*/;
3783 var3 = self->attrs[COLOR_array__ArrayMap___items].val; /* _items on <self:ArrayMap[Object, nullable Object]> */
3784 if (var3 == NULL) {
3785 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
3786 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 503);
3787 show_backtrace(1);
3788 }
3789 var4 = ((val* (*)(val*))(var3->class->vft[COLOR_abstract_collection__Sequence__pop]))(var3) /* pop on <var3:Array[Couple[Object, nullable Object]]>*/;
3790 var4;
3791 RET_LABEL:;
3792 }
3793 /* method array#ArrayMap#remove_at_index for (self: Object, Int) */
3794 void VIRTUAL_array__ArrayMap__remove_at_index(val* self, long p0) {
3795 array__ArrayMap__remove_at_index(self, p0);
3796 RET_LABEL:;
3797 }
3798 /* method array#ArrayMap#index for (self: ArrayMap[Object, nullable Object], Object): Int */
3799 long array__ArrayMap__index(val* self, val* p0) {
3800 long var /* : Int */;
3801 short int var1 /* : Bool */;
3802 int cltype;
3803 int idtype;
3804 const struct type* type_struct;
3805 const char* var_class_name;
3806 val* var_key /* var key: Object */;
3807 long var2 /* : Int */;
3808 long var_l /* var l: Int */;
3809 short int var3 /* : Bool */;
3810 val* var4 /* : Array[Couple[Object, nullable Object]] */;
3811 long var5 /* : Int */;
3812 short int var6 /* : Bool */;
3813 short int var8 /* : Bool */;
3814 int cltype9;
3815 int idtype10;
3816 const char* var_class_name11;
3817 short int var12 /* : Bool */;
3818 short int var_ /* var : Bool */;
3819 val* var13 /* : Array[Couple[Object, nullable Object]] */;
3820 val* var14 /* : nullable Object */;
3821 val* var15 /* : nullable Object */;
3822 short int var16 /* : Bool */;
3823 long var17 /* : Int */;
3824 long var_i /* var i: Int */;
3825 val* var18 /* : Array[Couple[Object, nullable Object]] */;
3826 long var19 /* : Int */;
3827 short int var20 /* : Bool */;
3828 short int var22 /* : Bool */;
3829 int cltype23;
3830 int idtype24;
3831 const char* var_class_name25;
3832 short int var26 /* : Bool */;
3833 val* var27 /* : Array[Couple[Object, nullable Object]] */;
3834 val* var28 /* : nullable Object */;
3835 val* var29 /* : nullable Object */;
3836 short int var30 /* : Bool */;
3837 long var31 /* : Int */;
3838 long var32 /* : Int */;
3839 long var34 /* : Int */;
3840 long var35 /* : Int */;
3841 long var36 /* : Int */;
3842 long var38 /* : Int */;
3843 /* Covariant cast for argument 0 (key) <p0:Object> isa ArrayMap#0 */
3844 /* <p0:Object> isa ArrayMap#0 */
3845 type_struct = self->type->resolution_table->types[COLOR_array__ArrayMap_FT0];
3846 cltype = type_struct->color;
3847 idtype = type_struct->id;
3848 if(cltype >= p0->type->table_size) {
3849 var1 = 0;
3850 } else {
3851 var1 = p0->type->type_table[cltype] == idtype;
3852 }
3853 if (!var1) {
3854 var_class_name = p0 == NULL ? "null" : p0->type->name;
3855 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "ArrayMap#0", var_class_name);
3856 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 509);
3857 show_backtrace(1);
3858 }
3859 var_key = p0;
3860 var2 = self->attrs[COLOR_array__ArrayMap___last_index].l; /* _last_index on <self:ArrayMap[Object, nullable Object]> */
3861 var_l = var2;
3862 var4 = self->attrs[COLOR_array__ArrayMap___items].val; /* _items on <self:ArrayMap[Object, nullable Object]> */
3863 if (var4 == NULL) {
3864 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
3865 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 514);
3866 show_backtrace(1);
3867 }
3868 var5 = ((long (*)(val*))(var4->class->vft[COLOR_abstract_collection__Collection__length]))(var4) /* length on <var4:Array[Couple[Object, nullable Object]]>*/;
3869 { /* Inline kernel#Int#< (var_l,var5) */
3870 /* Covariant cast for argument 0 (i) <var5:Int> isa OTHER */
3871 /* <var5:Int> isa OTHER */
3872 var8 = 1; /* easy <var5:Int> isa OTHER*/
3873 if (!var8) {
3874 var_class_name11 = type_kernel__Int.name;
3875 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name11);
3876 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 261);
3877 show_backtrace(1);
3878 }
3879 var12 = var_l < var5;
3880 var6 = var12;
3881 goto RET_LABEL7;
3882 RET_LABEL7:(void)0;
3883 }
3884 var_ = var6;
3885 if (var6){
3886 var13 = self->attrs[COLOR_array__ArrayMap___items].val; /* _items on <self:ArrayMap[Object, nullable Object]> */
3887 if (var13 == NULL) {
3888 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
3889 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 514);
3890 show_backtrace(1);
3891 }
3892 var14 = ((val* (*)(val*, long))(var13->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var13, var_l) /* [] on <var13:Array[Couple[Object, nullable Object]]>*/;
3893 var15 = ((val* (*)(val*))(var14->class->vft[COLOR_abstract_collection__Couple__first]))(var14) /* first on <var14:nullable Object(Couple[Object, nullable Object])>*/;
3894 var16 = ((short int (*)(val*, val*))(var15->class->vft[COLOR_kernel__Object___61d_61d]))(var15, var_key) /* == on <var15:nullable Object(Object)>*/;
3895 var3 = var16;
3896 } else {
3897 var3 = var_;
3898 }
3899 if (var3){
3900 var = var_l;
3901 goto RET_LABEL;
3902 } else {
3903 }
3904 var17 = 0;
3905 var_i = var17;
3906 for(;;) {
3907 var18 = self->attrs[COLOR_array__ArrayMap___items].val; /* _items on <self:ArrayMap[Object, nullable Object]> */
3908 if (var18 == NULL) {
3909 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
3910 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 517);
3911 show_backtrace(1);
3912 }
3913 var19 = ((long (*)(val*))(var18->class->vft[COLOR_abstract_collection__Collection__length]))(var18) /* length on <var18:Array[Couple[Object, nullable Object]]>*/;
3914 { /* Inline kernel#Int#< (var_i,var19) */
3915 /* Covariant cast for argument 0 (i) <var19:Int> isa OTHER */
3916 /* <var19:Int> isa OTHER */
3917 var22 = 1; /* easy <var19:Int> isa OTHER*/
3918 if (!var22) {
3919 var_class_name25 = type_kernel__Int.name;
3920 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name25);
3921 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 261);
3922 show_backtrace(1);
3923 }
3924 var26 = var_i < var19;
3925 var20 = var26;
3926 goto RET_LABEL21;
3927 RET_LABEL21:(void)0;
3928 }
3929 if (!var20) break;
3930 var27 = self->attrs[COLOR_array__ArrayMap___items].val; /* _items on <self:ArrayMap[Object, nullable Object]> */
3931 if (var27 == NULL) {
3932 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
3933 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 518);
3934 show_backtrace(1);
3935 }
3936 var28 = ((val* (*)(val*, long))(var27->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var27, var_i) /* [] on <var27:Array[Couple[Object, nullable Object]]>*/;
3937 var29 = ((val* (*)(val*))(var28->class->vft[COLOR_abstract_collection__Couple__first]))(var28) /* first on <var28:nullable Object(Couple[Object, nullable Object])>*/;
3938 var30 = ((short int (*)(val*, val*))(var29->class->vft[COLOR_kernel__Object___61d_61d]))(var29, var_key) /* == on <var29:nullable Object(Object)>*/;
3939 if (var30){
3940 self->attrs[COLOR_array__ArrayMap___last_index].l = var_i; /* _last_index on <self:ArrayMap[Object, nullable Object]> */
3941 var = var_i;
3942 goto RET_LABEL;
3943 } else {
3944 }
3945 var31 = 1;
3946 { /* Inline kernel#Int#+ (var_i,var31) */
3947 var34 = var_i + var31;
3948 var32 = var34;
3949 goto RET_LABEL33;
3950 RET_LABEL33:(void)0;
3951 }
3952 var_i = var32;
3953 CONTINUE_label: (void)0;
3954 }
3955 BREAK_label: (void)0;
3956 var35 = 1;
3957 { /* Inline kernel#Int#unary - (var35) */
3958 var38 = -var35;
3959 var36 = var38;
3960 goto RET_LABEL37;
3961 RET_LABEL37:(void)0;
3962 }
3963 var = var36;
3964 goto RET_LABEL;
3965 RET_LABEL:;
3966 return var;
3967 }
3968 /* method array#ArrayMap#index for (self: Object, Object): Int */
3969 long VIRTUAL_array__ArrayMap__index(val* self, val* p0) {
3970 long var /* : Int */;
3971 long var1 /* : Int */;
3972 var1 = array__ArrayMap__index(self, p0);
3973 var = var1;
3974 RET_LABEL:;
3975 return var;
3976 }
3977 /* method array#ArrayMap#init for (self: ArrayMap[Object, nullable Object]) */
3978 void array__ArrayMap__init(val* self) {
3979 val* var /* : Array[Couple[Object, nullable Object]] */;
3980 var = NEW_array__Array(self->type->resolution_table->types[COLOR_array__Arrayabstract_collection__Couplearray__ArrayMap_FT0array__ArrayMap_FT1]);
3981 ((void (*)(val*))(var->class->vft[COLOR_array__Array__init]))(var) /* init on <var:Array[Couple[Object, nullable Object]]>*/;
3982 self->attrs[COLOR_array__ArrayMap___items].val = var; /* _items on <self:ArrayMap[Object, nullable Object]> */
3983 RET_LABEL:;
3984 }
3985 /* method array#ArrayMap#init for (self: Object) */
3986 void VIRTUAL_array__ArrayMap__init(val* self) {
3987 array__ArrayMap__init(self);
3988 RET_LABEL:;
3989 }
3990 /* method array#ArrayMapKeys#map for (self: ArrayMapKeys[Object, nullable Object]): ArrayMap[Object, nullable Object] */
3991 val* array__ArrayMapKeys__map(val* self) {
3992 val* var /* : ArrayMap[Object, nullable Object] */;
3993 val* var1 /* : ArrayMap[Object, nullable Object] */;
3994 var1 = self->attrs[COLOR_array__ArrayMapKeys___64dmap].val; /* @map on <self:ArrayMapKeys[Object, nullable Object]> */
3995 if (var1 == NULL) {
3996 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @map");
3997 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 536);
3998 show_backtrace(1);
3999 }
4000 var = var1;
4001 RET_LABEL:;
4002 return var;
4003 }
4004 /* method array#ArrayMapKeys#map for (self: Object): ArrayMap[Object, nullable Object] */
4005 val* VIRTUAL_array__ArrayMapKeys__map(val* self) {
4006 val* var /* : ArrayMap[Object, nullable Object] */;
4007 val* var1 /* : ArrayMap[Object, nullable Object] */;
4008 var1 = array__ArrayMapKeys__map(self);
4009 var = var1;
4010 RET_LABEL:;
4011 return var;
4012 }
4013 /* method array#ArrayMapKeys#map= for (self: ArrayMapKeys[Object, nullable Object], ArrayMap[Object, nullable Object]) */
4014 void array__ArrayMapKeys__map_61d(val* self, val* p0) {
4015 short int var /* : Bool */;
4016 int cltype;
4017 int idtype;
4018 const struct type* type_struct;
4019 const char* var_class_name;
4020 /* Covariant cast for argument 0 (map) <p0:ArrayMap[Object, nullable Object]> isa ArrayMap[ArrayMapKeys#0, ArrayMapKeys#1] */
4021 /* <p0:ArrayMap[Object, nullable Object]> isa ArrayMap[ArrayMapKeys#0, ArrayMapKeys#1] */
4022 type_struct = self->type->resolution_table->types[COLOR_array__ArrayMaparray__ArrayMapKeys_FT0array__ArrayMapKeys_FT1];
4023 cltype = type_struct->color;
4024 idtype = type_struct->id;
4025 if(cltype >= p0->type->table_size) {
4026 var = 0;
4027 } else {
4028 var = p0->type->type_table[cltype] == idtype;
4029 }
4030 if (!var) {
4031 var_class_name = p0 == NULL ? "null" : p0->type->name;
4032 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "ArrayMap[ArrayMapKeys#0, ArrayMapKeys#1]", var_class_name);
4033 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 536);
4034 show_backtrace(1);
4035 }
4036 self->attrs[COLOR_array__ArrayMapKeys___64dmap].val = p0; /* @map on <self:ArrayMapKeys[Object, nullable Object]> */
4037 RET_LABEL:;
4038 }
4039 /* method array#ArrayMapKeys#map= for (self: Object, ArrayMap[Object, nullable Object]) */
4040 void VIRTUAL_array__ArrayMapKeys__map_61d(val* self, val* p0) {
4041 array__ArrayMapKeys__map_61d(self, p0);
4042 RET_LABEL:;
4043 }
4044 /* method array#ArrayMapKeys#count for (self: ArrayMapKeys[Object, nullable Object], Object): Int */
4045 long array__ArrayMapKeys__count(val* self, val* p0) {
4046 long var /* : Int */;
4047 short int var1 /* : Bool */;
4048 int cltype;
4049 int idtype;
4050 const struct type* type_struct;
4051 const char* var_class_name;
4052 val* var_k /* var k: Object */;
4053 short int var2 /* : Bool */;
4054 long var3 /* : Int */;
4055 long var4 /* : Int */;
4056 /* Covariant cast for argument 0 (k) <p0:Object> isa Collection#0 */
4057 /* <p0:Object> isa Collection#0 */
4058 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collection_FT0];
4059 cltype = type_struct->color;
4060 idtype = type_struct->id;
4061 if(cltype >= p0->type->table_size) {
4062 var1 = 0;
4063 } else {
4064 var1 = p0->type->type_table[cltype] == idtype;
4065 }
4066 if (!var1) {
4067 var_class_name = p0 == NULL ? "null" : p0->type->name;
4068 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection#0", var_class_name);
4069 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 538);
4070 show_backtrace(1);
4071 }
4072 var_k = p0;
4073 var2 = ((short int (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__Collection__has]))(self, var_k) /* has on <self:ArrayMapKeys[Object, nullable Object]>*/;
4074 if (var2){
4075 var3 = 1;
4076 var = var3;
4077 goto RET_LABEL;
4078 } else {
4079 var4 = 0;
4080 var = var4;
4081 goto RET_LABEL;
4082 }
4083 RET_LABEL:;
4084 return var;
4085 }
4086 /* method array#ArrayMapKeys#count for (self: Object, nullable Object): Int */
4087 long VIRTUAL_array__ArrayMapKeys__count(val* self, val* p0) {
4088 long var /* : Int */;
4089 long var1 /* : Int */;
4090 var1 = array__ArrayMapKeys__count(self, p0);
4091 var = var1;
4092 RET_LABEL:;
4093 return var;
4094 }
4095 /* method array#ArrayMapKeys#first for (self: ArrayMapKeys[Object, nullable Object]): Object */
4096 val* array__ArrayMapKeys__first(val* self) {
4097 val* var /* : Object */;
4098 val* var1 /* : ArrayMap[Object, nullable Object] */;
4099 val* var2 /* : Array[Couple[Object, nullable Object]] */;
4100 val* var3 /* : nullable Object */;
4101 val* var4 /* : nullable Object */;
4102 var1 = ((val* (*)(val*))(self->class->vft[COLOR_array__ArrayMapKeys__map]))(self) /* map on <self:ArrayMapKeys[Object, nullable Object]>*/;
4103 var2 = var1->attrs[COLOR_array__ArrayMap___items].val; /* _items on <var1:ArrayMap[Object, nullable Object]> */
4104 if (var2 == NULL) {
4105 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
4106 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 539);
4107 show_backtrace(1);
4108 }
4109 var3 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_collection__Collection__first]))(var2) /* first on <var2:Array[Couple[Object, nullable Object]]>*/;
4110 var4 = ((val* (*)(val*))(var3->class->vft[COLOR_abstract_collection__Couple__first]))(var3) /* first on <var3:nullable Object(Couple[Object, nullable Object])>*/;
4111 var = var4;
4112 goto RET_LABEL;
4113 RET_LABEL:;
4114 return var;
4115 }
4116 /* method array#ArrayMapKeys#first for (self: Object): nullable Object */
4117 val* VIRTUAL_array__ArrayMapKeys__first(val* self) {
4118 val* var /* : nullable Object */;
4119 val* var1 /* : Object */;
4120 var1 = array__ArrayMapKeys__first(self);
4121 var = var1;
4122 RET_LABEL:;
4123 return var;
4124 }
4125 /* method array#ArrayMapKeys#has for (self: ArrayMapKeys[Object, nullable Object], Object): Bool */
4126 short int array__ArrayMapKeys__has(val* self, val* p0) {
4127 short int var /* : Bool */;
4128 short int var1 /* : Bool */;
4129 int cltype;
4130 int idtype;
4131 const struct type* type_struct;
4132 const char* var_class_name;
4133 val* var_k /* var k: Object */;
4134 val* var2 /* : ArrayMap[Object, nullable Object] */;
4135 long var3 /* : Int */;
4136 long var4 /* : Int */;
4137 short int var5 /* : Bool */;
4138 short int var7 /* : Bool */;
4139 int cltype8;
4140 int idtype9;
4141 const char* var_class_name10;
4142 short int var11 /* : Bool */;
4143 /* Covariant cast for argument 0 (k) <p0:Object> isa Collection#0 */
4144 /* <p0:Object> isa Collection#0 */
4145 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collection_FT0];
4146 cltype = type_struct->color;
4147 idtype = type_struct->id;
4148 if(cltype >= p0->type->table_size) {
4149 var1 = 0;
4150 } else {
4151 var1 = p0->type->type_table[cltype] == idtype;
4152 }
4153 if (!var1) {
4154 var_class_name = p0 == NULL ? "null" : p0->type->name;
4155 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection#0", var_class_name);
4156 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 540);
4157 show_backtrace(1);
4158 }
4159 var_k = p0;
4160 var2 = ((val* (*)(val*))(self->class->vft[COLOR_array__ArrayMapKeys__map]))(self) /* map on <self:ArrayMapKeys[Object, nullable Object]>*/;
4161 var3 = ((long (*)(val*, val*))(var2->class->vft[COLOR_array__ArrayMap__index]))(var2, var_k) /* index on <var2:ArrayMap[Object, nullable Object]>*/;
4162 var4 = 0;
4163 { /* Inline kernel#Int#>= (var3,var4) */
4164 /* Covariant cast for argument 0 (i) <var4:Int> isa OTHER */
4165 /* <var4:Int> isa OTHER */
4166 var7 = 1; /* easy <var4:Int> isa OTHER*/
4167 if (!var7) {
4168 var_class_name10 = type_kernel__Int.name;
4169 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name10);
4170 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 262);
4171 show_backtrace(1);
4172 }
4173 var11 = var3 >= var4;
4174 var5 = var11;
4175 goto RET_LABEL6;
4176 RET_LABEL6:(void)0;
4177 }
4178 var = var5;
4179 goto RET_LABEL;
4180 RET_LABEL:;
4181 return var;
4182 }
4183 /* method array#ArrayMapKeys#has for (self: Object, nullable Object): Bool */
4184 short int VIRTUAL_array__ArrayMapKeys__has(val* self, val* p0) {
4185 short int var /* : Bool */;
4186 short int var1 /* : Bool */;
4187 var1 = array__ArrayMapKeys__has(self, p0);
4188 var = var1;
4189 RET_LABEL:;
4190 return var;
4191 }
4192 /* method array#ArrayMapKeys#has_only for (self: ArrayMapKeys[Object, nullable Object], Object): Bool */
4193 short int array__ArrayMapKeys__has_only(val* self, val* p0) {
4194 short int var /* : Bool */;
4195 short int var1 /* : Bool */;
4196 int cltype;
4197 int idtype;
4198 const struct type* type_struct;
4199 const char* var_class_name;
4200 val* var_k /* var k: Object */;
4201 short int var2 /* : Bool */;
4202 short int var3 /* : Bool */;
4203 short int var4 /* : Bool */;
4204 short int var_ /* var : Bool */;
4205 long var5 /* : Int */;
4206 long var6 /* : Int */;
4207 short int var7 /* : Bool */;
4208 short int var9 /* : Bool */;
4209 short int var_10 /* var : Bool */;
4210 short int var11 /* : Bool */;
4211 /* Covariant cast for argument 0 (k) <p0:Object> isa Collection#0 */
4212 /* <p0:Object> isa Collection#0 */
4213 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collection_FT0];
4214 cltype = type_struct->color;
4215 idtype = type_struct->id;
4216 if(cltype >= p0->type->table_size) {
4217 var1 = 0;
4218 } else {
4219 var1 = p0->type->type_table[cltype] == idtype;
4220 }
4221 if (!var1) {
4222 var_class_name = p0 == NULL ? "null" : p0->type->name;
4223 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection#0", var_class_name);
4224 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 541);
4225 show_backtrace(1);
4226 }
4227 var_k = p0;
4228 var4 = ((short int (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__Collection__has]))(self, var_k) /* has on <self:ArrayMapKeys[Object, nullable Object]>*/;
4229 var_ = var4;
4230 if (var4){
4231 var5 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:ArrayMapKeys[Object, nullable Object]>*/;
4232 var6 = 1;
4233 { /* Inline kernel#Int#== (var5,var6) */
4234 var9 = var5 == var6;
4235 var7 = var9;
4236 goto RET_LABEL8;
4237 RET_LABEL8:(void)0;
4238 }
4239 var3 = var7;
4240 } else {
4241 var3 = var_;
4242 }
4243 var_10 = var3;
4244 if (var3){
4245 var2 = var_10;
4246 } else {
4247 var11 = ((short int (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__is_empty]))(self) /* is_empty on <self:ArrayMapKeys[Object, nullable Object]>*/;
4248 var2 = var11;
4249 }
4250 var = var2;
4251 goto RET_LABEL;
4252 RET_LABEL:;
4253 return var;
4254 }
4255 /* method array#ArrayMapKeys#has_only for (self: Object, nullable Object): Bool */
4256 short int VIRTUAL_array__ArrayMapKeys__has_only(val* self, val* p0) {
4257 short int var /* : Bool */;
4258 short int var1 /* : Bool */;
4259 var1 = array__ArrayMapKeys__has_only(self, p0);
4260 var = var1;
4261 RET_LABEL:;
4262 return var;
4263 }
4264 /* method array#ArrayMapKeys#is_empty for (self: ArrayMapKeys[Object, nullable Object]): Bool */
4265 short int array__ArrayMapKeys__is_empty(val* self) {
4266 short int var /* : Bool */;
4267 val* var1 /* : ArrayMap[Object, nullable Object] */;
4268 short int var2 /* : Bool */;
4269 var1 = ((val* (*)(val*))(self->class->vft[COLOR_array__ArrayMapKeys__map]))(self) /* map on <self:ArrayMapKeys[Object, nullable Object]>*/;
4270 var2 = ((short int (*)(val*))(var1->class->vft[COLOR_abstract_collection__MapRead__is_empty]))(var1) /* is_empty on <var1:ArrayMap[Object, nullable Object]>*/;
4271 var = var2;
4272 goto RET_LABEL;
4273 RET_LABEL:;
4274 return var;
4275 }
4276 /* method array#ArrayMapKeys#is_empty for (self: Object): Bool */
4277 short int VIRTUAL_array__ArrayMapKeys__is_empty(val* self) {
4278 short int var /* : Bool */;
4279 short int var1 /* : Bool */;
4280 var1 = array__ArrayMapKeys__is_empty(self);
4281 var = var1;
4282 RET_LABEL:;
4283 return var;
4284 }
4285 /* method array#ArrayMapKeys#length for (self: ArrayMapKeys[Object, nullable Object]): Int */
4286 long array__ArrayMapKeys__length(val* self) {
4287 long var /* : Int */;
4288 val* var1 /* : ArrayMap[Object, nullable Object] */;
4289 long var2 /* : Int */;
4290 var1 = ((val* (*)(val*))(self->class->vft[COLOR_array__ArrayMapKeys__map]))(self) /* map on <self:ArrayMapKeys[Object, nullable Object]>*/;
4291 var2 = ((long (*)(val*))(var1->class->vft[COLOR_abstract_collection__MapRead__length]))(var1) /* length on <var1:ArrayMap[Object, nullable Object]>*/;
4292 var = var2;
4293 goto RET_LABEL;
4294 RET_LABEL:;
4295 return var;
4296 }
4297 /* method array#ArrayMapKeys#length for (self: Object): Int */
4298 long VIRTUAL_array__ArrayMapKeys__length(val* self) {
4299 long var /* : Int */;
4300 long var1 /* : Int */;
4301 var1 = array__ArrayMapKeys__length(self);
4302 var = var1;
4303 RET_LABEL:;
4304 return var;
4305 }
4306 /* method array#ArrayMapKeys#iterator for (self: ArrayMapKeys[Object, nullable Object]): Iterator[Object] */
4307 val* array__ArrayMapKeys__iterator(val* self) {
4308 val* var /* : Iterator[Object] */;
4309 val* var1 /* : MapKeysIterator[Object, nullable Object] */;
4310 val* var2 /* : ArrayMap[Object, nullable Object] */;
4311 val* var3 /* : MapIterator[Object, nullable Object] */;
4312 var1 = NEW_abstract_collection__MapKeysIterator(self->type->resolution_table->types[COLOR_abstract_collection__MapKeysIteratorarray__ArrayMapKeys_FT0array__ArrayMapKeys_FT1]);
4313 var2 = ((val* (*)(val*))(self->class->vft[COLOR_array__ArrayMapKeys__map]))(self) /* map on <self:ArrayMapKeys[Object, nullable Object]>*/;
4314 var3 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_collection__MapRead__iterator]))(var2) /* iterator on <var2:ArrayMap[Object, nullable Object]>*/;
4315 ((void (*)(val*, val*))(var1->class->vft[COLOR_abstract_collection__MapKeysIterator__init]))(var1, var3) /* init on <var1:MapKeysIterator[Object, nullable Object]>*/;
4316 var = var1;
4317 goto RET_LABEL;
4318 RET_LABEL:;
4319 return var;
4320 }
4321 /* method array#ArrayMapKeys#iterator for (self: Object): Iterator[nullable Object] */
4322 val* VIRTUAL_array__ArrayMapKeys__iterator(val* self) {
4323 val* var /* : Iterator[nullable Object] */;
4324 val* var1 /* : Iterator[Object] */;
4325 var1 = array__ArrayMapKeys__iterator(self);
4326 var = var1;
4327 RET_LABEL:;
4328 return var;
4329 }
4330 /* method array#ArrayMapKeys#clear for (self: ArrayMapKeys[Object, nullable Object]) */
4331 void array__ArrayMapKeys__clear(val* self) {
4332 val* var /* : ArrayMap[Object, nullable Object] */;
4333 var = ((val* (*)(val*))(self->class->vft[COLOR_array__ArrayMapKeys__map]))(self) /* map on <self:ArrayMapKeys[Object, nullable Object]>*/;
4334 ((void (*)(val*))(var->class->vft[COLOR_abstract_collection__Map__clear]))(var) /* clear on <var:ArrayMap[Object, nullable Object]>*/;
4335 RET_LABEL:;
4336 }
4337 /* method array#ArrayMapKeys#clear for (self: Object) */
4338 void VIRTUAL_array__ArrayMapKeys__clear(val* self) {
4339 array__ArrayMapKeys__clear(self);
4340 RET_LABEL:;
4341 }
4342 /* method array#ArrayMapKeys#remove for (self: ArrayMapKeys[Object, nullable Object], Object) */
4343 void array__ArrayMapKeys__remove(val* self, val* p0) {
4344 short int var /* : Bool */;
4345 int cltype;
4346 int idtype;
4347 const struct type* type_struct;
4348 const char* var_class_name;
4349 val* var_key /* var key: Object */;
4350 val* var1 /* : ArrayMap[Object, nullable Object] */;
4351 long var2 /* : Int */;
4352 long var_i /* var i: Int */;
4353 long var3 /* : Int */;
4354 short int var4 /* : Bool */;
4355 short int var6 /* : Bool */;
4356 int cltype7;
4357 int idtype8;
4358 const char* var_class_name9;
4359 short int var10 /* : Bool */;
4360 val* var11 /* : ArrayMap[Object, nullable Object] */;
4361 /* Covariant cast for argument 0 (key) <p0:Object> isa RemovableCollection#0 */
4362 /* <p0:Object> isa RemovableCollection#0 */
4363 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__RemovableCollection_FT0];
4364 cltype = type_struct->color;
4365 idtype = type_struct->id;
4366 if(cltype >= p0->type->table_size) {
4367 var = 0;
4368 } else {
4369 var = p0->type->type_table[cltype] == idtype;
4370 }
4371 if (!var) {
4372 var_class_name = p0 == NULL ? "null" : p0->type->name;
4373 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "RemovableCollection#0", var_class_name);
4374 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 546);
4375 show_backtrace(1);
4376 }
4377 var_key = p0;
4378 var1 = ((val* (*)(val*))(self->class->vft[COLOR_array__ArrayMapKeys__map]))(self) /* map on <self:ArrayMapKeys[Object, nullable Object]>*/;
4379 var2 = ((long (*)(val*, val*))(var1->class->vft[COLOR_array__ArrayMap__index]))(var1, var_key) /* index on <var1:ArrayMap[Object, nullable Object]>*/;
4380 var_i = var2;
4381 var3 = 0;
4382 { /* Inline kernel#Int#>= (var_i,var3) */
4383 /* Covariant cast for argument 0 (i) <var3:Int> isa OTHER */
4384 /* <var3:Int> isa OTHER */
4385 var6 = 1; /* easy <var3:Int> isa OTHER*/
4386 if (!var6) {
4387 var_class_name9 = type_kernel__Int.name;
4388 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name9);
4389 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 262);
4390 show_backtrace(1);
4391 }
4392 var10 = var_i >= var3;
4393 var4 = var10;
4394 goto RET_LABEL5;
4395 RET_LABEL5:(void)0;
4396 }
4397 if (var4){
4398 var11 = ((val* (*)(val*))(self->class->vft[COLOR_array__ArrayMapKeys__map]))(self) /* map on <self:ArrayMapKeys[Object, nullable Object]>*/;
4399 ((void (*)(val*, long))(var11->class->vft[COLOR_array__ArrayMap__remove_at_index]))(var11, var_i) /* remove_at_index on <var11:ArrayMap[Object, nullable Object]>*/;
4400 } else {
4401 }
4402 RET_LABEL:;
4403 }
4404 /* method array#ArrayMapKeys#remove for (self: Object, nullable Object) */
4405 void VIRTUAL_array__ArrayMapKeys__remove(val* self, val* p0) {
4406 array__ArrayMapKeys__remove(self, p0);
4407 RET_LABEL:;
4408 }
4409 /* method array#ArrayMapKeys#remove_all for (self: ArrayMapKeys[Object, nullable Object], Object) */
4410 void array__ArrayMapKeys__remove_all(val* self, val* p0) {
4411 short int var /* : Bool */;
4412 int cltype;
4413 int idtype;
4414 const struct type* type_struct;
4415 const char* var_class_name;
4416 val* var_key /* var key: Object */;
4417 /* Covariant cast for argument 0 (key) <p0:Object> isa RemovableCollection#0 */
4418 /* <p0:Object> isa RemovableCollection#0 */
4419 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__RemovableCollection_FT0];
4420 cltype = type_struct->color;
4421 idtype = type_struct->id;
4422 if(cltype >= p0->type->table_size) {
4423 var = 0;
4424 } else {
4425 var = p0->type->type_table[cltype] == idtype;
4426 }
4427 if (!var) {
4428 var_class_name = p0 == NULL ? "null" : p0->type->name;
4429 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "RemovableCollection#0", var_class_name);
4430 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 551);
4431 show_backtrace(1);
4432 }
4433 var_key = p0;
4434 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__RemovableCollection__remove]))(self, var_key) /* remove on <self:ArrayMapKeys[Object, nullable Object]>*/;
4435 RET_LABEL:;
4436 }
4437 /* method array#ArrayMapKeys#remove_all for (self: Object, nullable Object) */
4438 void VIRTUAL_array__ArrayMapKeys__remove_all(val* self, val* p0) {
4439 array__ArrayMapKeys__remove_all(self, p0);
4440 RET_LABEL:;
4441 }
4442 /* method array#ArrayMapKeys#init for (self: ArrayMapKeys[Object, nullable Object], ArrayMap[Object, nullable Object]) */
4443 void array__ArrayMapKeys__init(val* self, val* p0) {
4444 short int var /* : Bool */;
4445 int cltype;
4446 int idtype;
4447 const struct type* type_struct;
4448 const char* var_class_name;
4449 /* Covariant cast for argument 0 (map) <p0:ArrayMap[Object, nullable Object]> isa ArrayMap[ArrayMapKeys#0, ArrayMapKeys#1] */
4450 /* <p0:ArrayMap[Object, nullable Object]> isa ArrayMap[ArrayMapKeys#0, ArrayMapKeys#1] */
4451 type_struct = self->type->resolution_table->types[COLOR_array__ArrayMaparray__ArrayMapKeys_FT0array__ArrayMapKeys_FT1];
4452 cltype = type_struct->color;
4453 idtype = type_struct->id;
4454 if(cltype >= p0->type->table_size) {
4455 var = 0;
4456 } else {
4457 var = p0->type->type_table[cltype] == idtype;
4458 }
4459 if (!var) {
4460 var_class_name = p0 == NULL ? "null" : p0->type->name;
4461 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "ArrayMap[ArrayMapKeys#0, ArrayMapKeys#1]", var_class_name);
4462 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 534);
4463 show_backtrace(1);
4464 }
4465 self->attrs[COLOR_array__ArrayMapKeys___64dmap].val = p0; /* @map on <self:ArrayMapKeys[Object, nullable Object]> */
4466 RET_LABEL:;
4467 }
4468 /* method array#ArrayMapKeys#init for (self: Object, ArrayMap[Object, nullable Object]) */
4469 void VIRTUAL_array__ArrayMapKeys__init(val* self, val* p0) {
4470 array__ArrayMapKeys__init(self, p0);
4471 RET_LABEL:;
4472 }
4473 /* method array#ArrayMapValues#map for (self: ArrayMapValues[Object, nullable Object]): ArrayMap[Object, nullable Object] */
4474 val* array__ArrayMapValues__map(val* self) {
4475 val* var /* : ArrayMap[Object, nullable Object] */;
4476 val* var1 /* : ArrayMap[Object, nullable Object] */;
4477 var1 = self->attrs[COLOR_array__ArrayMapValues___64dmap].val; /* @map on <self:ArrayMapValues[Object, nullable Object]> */
4478 if (var1 == NULL) {
4479 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @map");
4480 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 556);
4481 show_backtrace(1);
4482 }
4483 var = var1;
4484 RET_LABEL:;
4485 return var;
4486 }
4487 /* method array#ArrayMapValues#map for (self: Object): ArrayMap[Object, nullable Object] */
4488 val* VIRTUAL_array__ArrayMapValues__map(val* self) {
4489 val* var /* : ArrayMap[Object, nullable Object] */;
4490 val* var1 /* : ArrayMap[Object, nullable Object] */;
4491 var1 = array__ArrayMapValues__map(self);
4492 var = var1;
4493 RET_LABEL:;
4494 return var;
4495 }
4496 /* method array#ArrayMapValues#map= for (self: ArrayMapValues[Object, nullable Object], ArrayMap[Object, nullable Object]) */
4497 void array__ArrayMapValues__map_61d(val* self, val* p0) {
4498 short int var /* : Bool */;
4499 int cltype;
4500 int idtype;
4501 const struct type* type_struct;
4502 const char* var_class_name;
4503 /* Covariant cast for argument 0 (map) <p0:ArrayMap[Object, nullable Object]> isa ArrayMap[ArrayMapValues#0, ArrayMapValues#1] */
4504 /* <p0:ArrayMap[Object, nullable Object]> isa ArrayMap[ArrayMapValues#0, ArrayMapValues#1] */
4505 type_struct = self->type->resolution_table->types[COLOR_array__ArrayMaparray__ArrayMapValues_FT0array__ArrayMapValues_FT1];
4506 cltype = type_struct->color;
4507 idtype = type_struct->id;
4508 if(cltype >= p0->type->table_size) {
4509 var = 0;
4510 } else {
4511 var = p0->type->type_table[cltype] == idtype;
4512 }
4513 if (!var) {
4514 var_class_name = p0 == NULL ? "null" : p0->type->name;
4515 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "ArrayMap[ArrayMapValues#0, ArrayMapValues#1]", var_class_name);
4516 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 556);
4517 show_backtrace(1);
4518 }
4519 self->attrs[COLOR_array__ArrayMapValues___64dmap].val = p0; /* @map on <self:ArrayMapValues[Object, nullable Object]> */
4520 RET_LABEL:;
4521 }
4522 /* method array#ArrayMapValues#map= for (self: Object, ArrayMap[Object, nullable Object]) */
4523 void VIRTUAL_array__ArrayMapValues__map_61d(val* self, val* p0) {
4524 array__ArrayMapValues__map_61d(self, p0);
4525 RET_LABEL:;
4526 }
4527 /* method array#ArrayMapValues#first for (self: ArrayMapValues[Object, nullable Object]): nullable Object */
4528 val* array__ArrayMapValues__first(val* self) {
4529 val* var /* : nullable Object */;
4530 val* var1 /* : ArrayMap[Object, nullable Object] */;
4531 val* var2 /* : Array[Couple[Object, nullable Object]] */;
4532 val* var3 /* : nullable Object */;
4533 val* var4 /* : nullable Object */;
4534 var1 = ((val* (*)(val*))(self->class->vft[COLOR_array__ArrayMapValues__map]))(self) /* map on <self:ArrayMapValues[Object, nullable Object]>*/;
4535 var2 = var1->attrs[COLOR_array__ArrayMap___items].val; /* _items on <var1:ArrayMap[Object, nullable Object]> */
4536 if (var2 == NULL) {
4537 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
4538 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 558);
4539 show_backtrace(1);
4540 }
4541 var3 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_collection__Collection__first]))(var2) /* first on <var2:Array[Couple[Object, nullable Object]]>*/;
4542 var4 = ((val* (*)(val*))(var3->class->vft[COLOR_abstract_collection__Couple__second]))(var3) /* second on <var3:nullable Object(Couple[Object, nullable Object])>*/;
4543 var = var4;
4544 goto RET_LABEL;
4545 RET_LABEL:;
4546 return var;
4547 }
4548 /* method array#ArrayMapValues#first for (self: Object): nullable Object */
4549 val* VIRTUAL_array__ArrayMapValues__first(val* self) {
4550 val* var /* : nullable Object */;
4551 val* var1 /* : nullable Object */;
4552 var1 = array__ArrayMapValues__first(self);
4553 var = var1;
4554 RET_LABEL:;
4555 return var;
4556 }
4557 /* method array#ArrayMapValues#is_empty for (self: ArrayMapValues[Object, nullable Object]): Bool */
4558 short int array__ArrayMapValues__is_empty(val* self) {
4559 short int var /* : Bool */;
4560 val* var1 /* : ArrayMap[Object, nullable Object] */;
4561 short int var2 /* : Bool */;
4562 var1 = ((val* (*)(val*))(self->class->vft[COLOR_array__ArrayMapValues__map]))(self) /* map on <self:ArrayMapValues[Object, nullable Object]>*/;
4563 var2 = ((short int (*)(val*))(var1->class->vft[COLOR_abstract_collection__MapRead__is_empty]))(var1) /* is_empty on <var1:ArrayMap[Object, nullable Object]>*/;
4564 var = var2;
4565 goto RET_LABEL;
4566 RET_LABEL:;
4567 return var;
4568 }
4569 /* method array#ArrayMapValues#is_empty for (self: Object): Bool */
4570 short int VIRTUAL_array__ArrayMapValues__is_empty(val* self) {
4571 short int var /* : Bool */;
4572 short int var1 /* : Bool */;
4573 var1 = array__ArrayMapValues__is_empty(self);
4574 var = var1;
4575 RET_LABEL:;
4576 return var;
4577 }
4578 /* method array#ArrayMapValues#length for (self: ArrayMapValues[Object, nullable Object]): Int */
4579 long array__ArrayMapValues__length(val* self) {
4580 long var /* : Int */;
4581 val* var1 /* : ArrayMap[Object, nullable Object] */;
4582 long var2 /* : Int */;
4583 var1 = ((val* (*)(val*))(self->class->vft[COLOR_array__ArrayMapValues__map]))(self) /* map on <self:ArrayMapValues[Object, nullable Object]>*/;
4584 var2 = ((long (*)(val*))(var1->class->vft[COLOR_abstract_collection__MapRead__length]))(var1) /* length on <var1:ArrayMap[Object, nullable Object]>*/;
4585 var = var2;
4586 goto RET_LABEL;
4587 RET_LABEL:;
4588 return var;
4589 }
4590 /* method array#ArrayMapValues#length for (self: Object): Int */
4591 long VIRTUAL_array__ArrayMapValues__length(val* self) {
4592 long var /* : Int */;
4593 long var1 /* : Int */;
4594 var1 = array__ArrayMapValues__length(self);
4595 var = var1;
4596 RET_LABEL:;
4597 return var;
4598 }
4599 /* method array#ArrayMapValues#iterator for (self: ArrayMapValues[Object, nullable Object]): Iterator[nullable Object] */
4600 val* array__ArrayMapValues__iterator(val* self) {
4601 val* var /* : Iterator[nullable Object] */;
4602 val* var1 /* : MapValuesIterator[Object, nullable Object] */;
4603 val* var2 /* : ArrayMap[Object, nullable Object] */;
4604 val* var3 /* : MapIterator[Object, nullable Object] */;
4605 var1 = NEW_abstract_collection__MapValuesIterator(self->type->resolution_table->types[COLOR_abstract_collection__MapValuesIteratorarray__ArrayMapValues_FT0array__ArrayMapValues_FT1]);
4606 var2 = ((val* (*)(val*))(self->class->vft[COLOR_array__ArrayMapValues__map]))(self) /* map on <self:ArrayMapValues[Object, nullable Object]>*/;
4607 var3 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_collection__MapRead__iterator]))(var2) /* iterator on <var2:ArrayMap[Object, nullable Object]>*/;
4608 ((void (*)(val*, val*))(var1->class->vft[COLOR_abstract_collection__MapValuesIterator__init]))(var1, var3) /* init on <var1:MapValuesIterator[Object, nullable Object]>*/;
4609 var = var1;
4610 goto RET_LABEL;
4611 RET_LABEL:;
4612 return var;
4613 }
4614 /* method array#ArrayMapValues#iterator for (self: Object): Iterator[nullable Object] */
4615 val* VIRTUAL_array__ArrayMapValues__iterator(val* self) {
4616 val* var /* : Iterator[nullable Object] */;
4617 val* var1 /* : Iterator[nullable Object] */;
4618 var1 = array__ArrayMapValues__iterator(self);
4619 var = var1;
4620 RET_LABEL:;
4621 return var;
4622 }
4623 /* method array#ArrayMapValues#has for (self: ArrayMapValues[Object, nullable Object], nullable Object): Bool */
4624 short int array__ArrayMapValues__has(val* self, val* p0) {
4625 short int var /* : Bool */;
4626 short int var1 /* : Bool */;
4627 int cltype;
4628 int idtype;
4629 const struct type* type_struct;
4630 short int is_nullable;
4631 const char* var_class_name;
4632 val* var_item /* var item: nullable Object */;
4633 val* var2 /* : ArrayMap[Object, nullable Object] */;
4634 val* var3 /* : Array[Couple[Object, nullable Object]] */;
4635 val* var4 /* : Iterator[nullable Object] */;
4636 short int var5 /* : Bool */;
4637 val* var6 /* : nullable Object */;
4638 val* var_i /* var i: Couple[Object, nullable Object] */;
4639 val* var7 /* : nullable Object */;
4640 short int var8 /* : Bool */;
4641 short int var9 /* : Bool */;
4642 short int var10 /* : Bool */;
4643 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa Collection#0 */
4644 /* <p0:nullable Object> isa Collection#0 */
4645 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collection_FT0];
4646 cltype = type_struct->color;
4647 idtype = type_struct->id;
4648 is_nullable = type_struct->is_nullable;
4649 if(p0 == NULL) {
4650 var1 = is_nullable;
4651 } else {
4652 if(cltype >= p0->type->table_size) {
4653 var1 = 0;
4654 } else {
4655 var1 = p0->type->type_table[cltype] == idtype;
4656 }
4657 }
4658 if (!var1) {
4659 var_class_name = p0 == NULL ? "null" : p0->type->name;
4660 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection#0", var_class_name);
4661 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 563);
4662 show_backtrace(1);
4663 }
4664 var_item = p0;
4665 var2 = ((val* (*)(val*))(self->class->vft[COLOR_array__ArrayMapValues__map]))(self) /* map on <self:ArrayMapValues[Object, nullable Object]>*/;
4666 var3 = var2->attrs[COLOR_array__ArrayMap___items].val; /* _items on <var2:ArrayMap[Object, nullable Object]> */
4667 if (var3 == NULL) {
4668 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
4669 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 566);
4670 show_backtrace(1);
4671 }
4672 var4 = ((val* (*)(val*))(var3->class->vft[COLOR_abstract_collection__Collection__iterator]))(var3) /* iterator on <var3:Array[Couple[Object, nullable Object]]>*/;
4673 for(;;) {
4674 var5 = ((short int (*)(val*))(var4->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var4) /* is_ok on <var4:Iterator[nullable Object]>*/;
4675 if(!var5) break;
4676 var6 = ((val* (*)(val*))(var4->class->vft[COLOR_abstract_collection__Iterator__item]))(var4) /* item on <var4:Iterator[nullable Object]>*/;
4677 var_i = var6;
4678 var7 = ((val* (*)(val*))(var_i->class->vft[COLOR_abstract_collection__Couple__second]))(var_i) /* second on <var_i:Couple[Object, nullable Object]>*/;
4679 if (var7 == NULL) {
4680 var8 = (var_item == NULL);
4681 } else {
4682 var8 = ((short int (*)(val*, val*))(var7->class->vft[COLOR_kernel__Object___61d_61d]))(var7, var_item) /* == on <var7:nullable Object>*/;
4683 }
4684 if (var8){
4685 var9 = 1;
4686 var = var9;
4687 goto RET_LABEL;
4688 } else {
4689 }
4690 CONTINUE_label: (void)0;
4691 ((void (*)(val*))(var4->class->vft[COLOR_abstract_collection__Iterator__next]))(var4) /* next on <var4:Iterator[nullable Object]>*/;
4692 }
4693 BREAK_label: (void)0;
4694 var10 = 0;
4695 var = var10;
4696 goto RET_LABEL;
4697 RET_LABEL:;
4698 return var;
4699 }
4700 /* method array#ArrayMapValues#has for (self: Object, nullable Object): Bool */
4701 short int VIRTUAL_array__ArrayMapValues__has(val* self, val* p0) {
4702 short int var /* : Bool */;
4703 short int var1 /* : Bool */;
4704 var1 = array__ArrayMapValues__has(self, p0);
4705 var = var1;
4706 RET_LABEL:;
4707 return var;
4708 }
4709 /* method array#ArrayMapValues#has_only for (self: ArrayMapValues[Object, nullable Object], nullable Object): Bool */
4710 short int array__ArrayMapValues__has_only(val* self, val* p0) {
4711 short int var /* : Bool */;
4712 short int var1 /* : Bool */;
4713 int cltype;
4714 int idtype;
4715 const struct type* type_struct;
4716 short int is_nullable;
4717 const char* var_class_name;
4718 val* var_item /* var item: nullable Object */;
4719 val* var2 /* : ArrayMap[Object, nullable Object] */;
4720 val* var3 /* : Array[Couple[Object, nullable Object]] */;
4721 val* var4 /* : Iterator[nullable Object] */;
4722 short int var5 /* : Bool */;
4723 val* var6 /* : nullable Object */;
4724 val* var_i /* var i: Couple[Object, nullable Object] */;
4725 val* var7 /* : nullable Object */;
4726 short int var8 /* : Bool */;
4727 short int var9 /* : Bool */;
4728 short int var10 /* : Bool */;
4729 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa Collection#0 */
4730 /* <p0:nullable Object> isa Collection#0 */
4731 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collection_FT0];
4732 cltype = type_struct->color;
4733 idtype = type_struct->id;
4734 is_nullable = type_struct->is_nullable;
4735 if(p0 == NULL) {
4736 var1 = is_nullable;
4737 } else {
4738 if(cltype >= p0->type->table_size) {
4739 var1 = 0;
4740 } else {
4741 var1 = p0->type->type_table[cltype] == idtype;
4742 }
4743 }
4744 if (!var1) {
4745 var_class_name = p0 == NULL ? "null" : p0->type->name;
4746 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection#0", var_class_name);
4747 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 570);
4748 show_backtrace(1);
4749 }
4750 var_item = p0;
4751 var2 = ((val* (*)(val*))(self->class->vft[COLOR_array__ArrayMapValues__map]))(self) /* map on <self:ArrayMapValues[Object, nullable Object]>*/;
4752 var3 = var2->attrs[COLOR_array__ArrayMap___items].val; /* _items on <var2:ArrayMap[Object, nullable Object]> */
4753 if (var3 == NULL) {
4754 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
4755 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 573);
4756 show_backtrace(1);
4757 }
4758 var4 = ((val* (*)(val*))(var3->class->vft[COLOR_abstract_collection__Collection__iterator]))(var3) /* iterator on <var3:Array[Couple[Object, nullable Object]]>*/;
4759 for(;;) {
4760 var5 = ((short int (*)(val*))(var4->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var4) /* is_ok on <var4:Iterator[nullable Object]>*/;
4761 if(!var5) break;
4762 var6 = ((val* (*)(val*))(var4->class->vft[COLOR_abstract_collection__Iterator__item]))(var4) /* item on <var4:Iterator[nullable Object]>*/;
4763 var_i = var6;
4764 var7 = ((val* (*)(val*))(var_i->class->vft[COLOR_abstract_collection__Couple__second]))(var_i) /* second on <var_i:Couple[Object, nullable Object]>*/;
4765 if (var7 == NULL) {
4766 var8 = (var_item != NULL);
4767 } else {
4768 var8 = ((short int (*)(val*, val*))(var7->class->vft[COLOR_kernel__Object___33d_61d]))(var7, var_item) /* != on <var7:nullable Object>*/;
4769 }
4770 if (var8){
4771 var9 = 0;
4772 var = var9;
4773 goto RET_LABEL;
4774 } else {
4775 }
4776 CONTINUE_label: (void)0;
4777 ((void (*)(val*))(var4->class->vft[COLOR_abstract_collection__Iterator__next]))(var4) /* next on <var4:Iterator[nullable Object]>*/;
4778 }
4779 BREAK_label: (void)0;
4780 var10 = 1;
4781 var = var10;
4782 goto RET_LABEL;
4783 RET_LABEL:;
4784 return var;
4785 }
4786 /* method array#ArrayMapValues#has_only for (self: Object, nullable Object): Bool */
4787 short int VIRTUAL_array__ArrayMapValues__has_only(val* self, val* p0) {
4788 short int var /* : Bool */;
4789 short int var1 /* : Bool */;
4790 var1 = array__ArrayMapValues__has_only(self, p0);
4791 var = var1;
4792 RET_LABEL:;
4793 return var;
4794 }
4795 /* method array#ArrayMapValues#count for (self: ArrayMapValues[Object, nullable Object], nullable Object): Int */
4796 long array__ArrayMapValues__count(val* self, val* p0) {
4797 long var /* : Int */;
4798 short int var1 /* : Bool */;
4799 int cltype;
4800 int idtype;
4801 const struct type* type_struct;
4802 short int is_nullable;
4803 const char* var_class_name;
4804 val* var_item /* var item: nullable Object */;
4805 long var2 /* : Int */;
4806 long var_nb /* var nb: Int */;
4807 val* var3 /* : ArrayMap[Object, nullable Object] */;
4808 val* var4 /* : Array[Couple[Object, nullable Object]] */;
4809 val* var5 /* : Iterator[nullable Object] */;
4810 short int var6 /* : Bool */;
4811 val* var7 /* : nullable Object */;
4812 val* var_i /* var i: Couple[Object, nullable Object] */;
4813 val* var8 /* : nullable Object */;
4814 short int var9 /* : Bool */;
4815 long var10 /* : Int */;
4816 long var11 /* : Int */;
4817 long var13 /* : Int */;
4818 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa Collection#0 */
4819 /* <p0:nullable Object> isa Collection#0 */
4820 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collection_FT0];
4821 cltype = type_struct->color;
4822 idtype = type_struct->id;
4823 is_nullable = type_struct->is_nullable;
4824 if(p0 == NULL) {
4825 var1 = is_nullable;
4826 } else {
4827 if(cltype >= p0->type->table_size) {
4828 var1 = 0;
4829 } else {
4830 var1 = p0->type->type_table[cltype] == idtype;
4831 }
4832 }
4833 if (!var1) {
4834 var_class_name = p0 == NULL ? "null" : p0->type->name;
4835 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection#0", var_class_name);
4836 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 577);
4837 show_backtrace(1);
4838 }
4839 var_item = p0;
4840 var2 = 0;
4841 var_nb = var2;
4842 var3 = ((val* (*)(val*))(self->class->vft[COLOR_array__ArrayMapValues__map]))(self) /* map on <self:ArrayMapValues[Object, nullable Object]>*/;
4843 var4 = var3->attrs[COLOR_array__ArrayMap___items].val; /* _items on <var3:ArrayMap[Object, nullable Object]> */
4844 if (var4 == NULL) {
4845 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
4846 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 581);
4847 show_backtrace(1);
4848 }
4849 var5 = ((val* (*)(val*))(var4->class->vft[COLOR_abstract_collection__Collection__iterator]))(var4) /* iterator on <var4:Array[Couple[Object, nullable Object]]>*/;
4850 for(;;) {
4851 var6 = ((short int (*)(val*))(var5->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var5) /* is_ok on <var5:Iterator[nullable Object]>*/;
4852 if(!var6) break;
4853 var7 = ((val* (*)(val*))(var5->class->vft[COLOR_abstract_collection__Iterator__item]))(var5) /* item on <var5:Iterator[nullable Object]>*/;
4854 var_i = var7;
4855 var8 = ((val* (*)(val*))(var_i->class->vft[COLOR_abstract_collection__Couple__second]))(var_i) /* second on <var_i:Couple[Object, nullable Object]>*/;
4856 if (var8 == NULL) {
4857 var9 = (var_item == NULL);
4858 } else {
4859 var9 = ((short int (*)(val*, val*))(var8->class->vft[COLOR_kernel__Object___61d_61d]))(var8, var_item) /* == on <var8:nullable Object>*/;
4860 }
4861 if (var9){
4862 var10 = 1;
4863 { /* Inline kernel#Int#+ (var_nb,var10) */
4864 var13 = var_nb + var10;
4865 var11 = var13;
4866 goto RET_LABEL12;
4867 RET_LABEL12:(void)0;
4868 }
4869 var_nb = var11;
4870 } else {
4871 }
4872 CONTINUE_label: (void)0;
4873 ((void (*)(val*))(var5->class->vft[COLOR_abstract_collection__Iterator__next]))(var5) /* next on <var5:Iterator[nullable Object]>*/;
4874 }
4875 BREAK_label: (void)0;
4876 var = var_nb;
4877 goto RET_LABEL;
4878 RET_LABEL:;
4879 return var;
4880 }
4881 /* method array#ArrayMapValues#count for (self: Object, nullable Object): Int */
4882 long VIRTUAL_array__ArrayMapValues__count(val* self, val* p0) {
4883 long var /* : Int */;
4884 long var1 /* : Int */;
4885 var1 = array__ArrayMapValues__count(self, p0);
4886 var = var1;
4887 RET_LABEL:;
4888 return var;
4889 }
4890 /* method array#ArrayMapValues#clear for (self: ArrayMapValues[Object, nullable Object]) */
4891 void array__ArrayMapValues__clear(val* self) {
4892 val* var /* : ArrayMap[Object, nullable Object] */;
4893 var = ((val* (*)(val*))(self->class->vft[COLOR_array__ArrayMapValues__map]))(self) /* map on <self:ArrayMapValues[Object, nullable Object]>*/;
4894 ((void (*)(val*))(var->class->vft[COLOR_abstract_collection__Map__clear]))(var) /* clear on <var:ArrayMap[Object, nullable Object]>*/;
4895 RET_LABEL:;
4896 }
4897 /* method array#ArrayMapValues#clear for (self: Object) */
4898 void VIRTUAL_array__ArrayMapValues__clear(val* self) {
4899 array__ArrayMapValues__clear(self);
4900 RET_LABEL:;
4901 }
4902 /* method array#ArrayMapValues#remove for (self: ArrayMapValues[Object, nullable Object], nullable Object) */
4903 void array__ArrayMapValues__remove(val* self, val* p0) {
4904 short int var /* : Bool */;
4905 int cltype;
4906 int idtype;
4907 const struct type* type_struct;
4908 short int is_nullable;
4909 const char* var_class_name;
4910 val* var_item /* var item: nullable Object */;
4911 val* var1 /* : ArrayMap[Object, nullable Object] */;
4912 val* var_map /* var map: ArrayMap[Object, nullable Object] */;
4913 val* var2 /* : Array[Couple[Object, nullable Object]] */;
4914 long var3 /* : Int */;
4915 long var4 /* : Int */;
4916 long var5 /* : Int */;
4917 long var7 /* : Int */;
4918 long var_i /* var i: Int */;
4919 long var8 /* : Int */;
4920 short int var9 /* : Bool */;
4921 short int var11 /* : Bool */;
4922 int cltype12;
4923 int idtype13;
4924 const char* var_class_name14;
4925 short int var15 /* : Bool */;
4926 val* var16 /* : Array[Couple[Object, nullable Object]] */;
4927 val* var17 /* : nullable Object */;
4928 val* var18 /* : nullable Object */;
4929 short int var19 /* : Bool */;
4930 long var20 /* : Int */;
4931 long var21 /* : Int */;
4932 long var23 /* : Int */;
4933 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa RemovableCollection#0 */
4934 /* <p0:nullable Object> isa RemovableCollection#0 */
4935 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__RemovableCollection_FT0];
4936 cltype = type_struct->color;
4937 idtype = type_struct->id;
4938 is_nullable = type_struct->is_nullable;
4939 if(p0 == NULL) {
4940 var = is_nullable;
4941 } else {
4942 if(cltype >= p0->type->table_size) {
4943 var = 0;
4944 } else {
4945 var = p0->type->type_table[cltype] == idtype;
4946 }
4947 }
4948 if (!var) {
4949 var_class_name = p0 == NULL ? "null" : p0->type->name;
4950 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "RemovableCollection#0", var_class_name);
4951 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 587);
4952 show_backtrace(1);
4953 }
4954 var_item = p0;
4955 var1 = ((val* (*)(val*))(self->class->vft[COLOR_array__ArrayMapValues__map]))(self) /* map on <self:ArrayMapValues[Object, nullable Object]>*/;
4956 var_map = var1;
4957 var2 = var_map->attrs[COLOR_array__ArrayMap___items].val; /* _items on <var_map:ArrayMap[Object, nullable Object]> */
4958 if (var2 == NULL) {
4959 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
4960 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 590);
4961 show_backtrace(1);
4962 }
4963 var3 = ((long (*)(val*))(var2->class->vft[COLOR_abstract_collection__Collection__length]))(var2) /* length on <var2:Array[Couple[Object, nullable Object]]>*/;
4964 var4 = 1;
4965 { /* Inline kernel#Int#- (var3,var4) */
4966 var7 = var3 - var4;
4967 var5 = var7;
4968 goto RET_LABEL6;
4969 RET_LABEL6:(void)0;
4970 }
4971 var_i = var5;
4972 for(;;) {
4973 var8 = 0;
4974 { /* Inline kernel#Int#>= (var_i,var8) */
4975 /* Covariant cast for argument 0 (i) <var8:Int> isa OTHER */
4976 /* <var8:Int> isa OTHER */
4977 var11 = 1; /* easy <var8:Int> isa OTHER*/
4978 if (!var11) {
4979 var_class_name14 = type_kernel__Int.name;
4980 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name14);
4981 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 262);
4982 show_backtrace(1);
4983 }
4984 var15 = var_i >= var8;
4985 var9 = var15;
4986 goto RET_LABEL10;
4987 RET_LABEL10:(void)0;
4988 }
4989 if (!var9) break;
4990 var16 = var_map->attrs[COLOR_array__ArrayMap___items].val; /* _items on <var_map:ArrayMap[Object, nullable Object]> */
4991 if (var16 == NULL) {
4992 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
4993 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 592);
4994 show_backtrace(1);
4995 }
4996 var17 = ((val* (*)(val*, long))(var16->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var16, var_i) /* [] on <var16:Array[Couple[Object, nullable Object]]>*/;
4997 var18 = ((val* (*)(val*))(var17->class->vft[COLOR_abstract_collection__Couple__second]))(var17) /* second on <var17:nullable Object(Couple[Object, nullable Object])>*/;
4998 if (var18 == NULL) {
4999 var19 = (var_item == NULL);
5000 } else {
5001 var19 = ((short int (*)(val*, val*))(var18->class->vft[COLOR_kernel__Object___61d_61d]))(var18, var_item) /* == on <var18:nullable Object>*/;
5002 }
5003 if (var19){
5004 ((void (*)(val*, long))(var_map->class->vft[COLOR_array__ArrayMap__remove_at_index]))(var_map, var_i) /* remove_at_index on <var_map:ArrayMap[Object, nullable Object]>*/;
5005 goto RET_LABEL;
5006 } else {
5007 }
5008 var20 = 1;
5009 { /* Inline kernel#Int#- (var_i,var20) */
5010 var23 = var_i - var20;
5011 var21 = var23;
5012 goto RET_LABEL22;
5013 RET_LABEL22:(void)0;
5014 }
5015 var_i = var21;
5016 CONTINUE_label: (void)0;
5017 }
5018 BREAK_label: (void)0;
5019 RET_LABEL:;
5020 }
5021 /* method array#ArrayMapValues#remove for (self: Object, nullable Object) */
5022 void VIRTUAL_array__ArrayMapValues__remove(val* self, val* p0) {
5023 array__ArrayMapValues__remove(self, p0);
5024 RET_LABEL:;
5025 }
5026 /* method array#ArrayMapValues#remove_all for (self: ArrayMapValues[Object, nullable Object], nullable Object) */
5027 void array__ArrayMapValues__remove_all(val* self, val* p0) {
5028 short int var /* : Bool */;
5029 int cltype;
5030 int idtype;
5031 const struct type* type_struct;
5032 short int is_nullable;
5033 const char* var_class_name;
5034 val* var_item /* var item: nullable Object */;
5035 val* var1 /* : ArrayMap[Object, nullable Object] */;
5036 val* var_map /* var map: ArrayMap[Object, nullable Object] */;
5037 val* var2 /* : Array[Couple[Object, nullable Object]] */;
5038 long var3 /* : Int */;
5039 long var4 /* : Int */;
5040 long var5 /* : Int */;
5041 long var7 /* : Int */;
5042 long var_i /* var i: Int */;
5043 long var8 /* : Int */;
5044 short int var9 /* : Bool */;
5045 short int var11 /* : Bool */;
5046 int cltype12;
5047 int idtype13;
5048 const char* var_class_name14;
5049 short int var15 /* : Bool */;
5050 val* var16 /* : Array[Couple[Object, nullable Object]] */;
5051 val* var17 /* : nullable Object */;
5052 val* var18 /* : nullable Object */;
5053 short int var19 /* : Bool */;
5054 long var20 /* : Int */;
5055 long var21 /* : Int */;
5056 long var23 /* : Int */;
5057 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa RemovableCollection#0 */
5058 /* <p0:nullable Object> isa RemovableCollection#0 */
5059 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__RemovableCollection_FT0];
5060 cltype = type_struct->color;
5061 idtype = type_struct->id;
5062 is_nullable = type_struct->is_nullable;
5063 if(p0 == NULL) {
5064 var = is_nullable;
5065 } else {
5066 if(cltype >= p0->type->table_size) {
5067 var = 0;
5068 } else {
5069 var = p0->type->type_table[cltype] == idtype;
5070 }
5071 }
5072 if (!var) {
5073 var_class_name = p0 == NULL ? "null" : p0->type->name;
5074 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "RemovableCollection#0", var_class_name);
5075 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 600);
5076 show_backtrace(1);
5077 }
5078 var_item = p0;
5079 var1 = ((val* (*)(val*))(self->class->vft[COLOR_array__ArrayMapValues__map]))(self) /* map on <self:ArrayMapValues[Object, nullable Object]>*/;
5080 var_map = var1;
5081 var2 = var_map->attrs[COLOR_array__ArrayMap___items].val; /* _items on <var_map:ArrayMap[Object, nullable Object]> */
5082 if (var2 == NULL) {
5083 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
5084 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 603);
5085 show_backtrace(1);
5086 }
5087 var3 = ((long (*)(val*))(var2->class->vft[COLOR_abstract_collection__Collection__length]))(var2) /* length on <var2:Array[Couple[Object, nullable Object]]>*/;
5088 var4 = 1;
5089 { /* Inline kernel#Int#- (var3,var4) */
5090 var7 = var3 - var4;
5091 var5 = var7;
5092 goto RET_LABEL6;
5093 RET_LABEL6:(void)0;
5094 }
5095 var_i = var5;
5096 for(;;) {
5097 var8 = 0;
5098 { /* Inline kernel#Int#>= (var_i,var8) */
5099 /* Covariant cast for argument 0 (i) <var8:Int> isa OTHER */
5100 /* <var8:Int> isa OTHER */
5101 var11 = 1; /* easy <var8:Int> isa OTHER*/
5102 if (!var11) {
5103 var_class_name14 = type_kernel__Int.name;
5104 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name14);
5105 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 262);
5106 show_backtrace(1);
5107 }
5108 var15 = var_i >= var8;
5109 var9 = var15;
5110 goto RET_LABEL10;
5111 RET_LABEL10:(void)0;
5112 }
5113 if (!var9) break;
5114 var16 = var_map->attrs[COLOR_array__ArrayMap___items].val; /* _items on <var_map:ArrayMap[Object, nullable Object]> */
5115 if (var16 == NULL) {
5116 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _items");
5117 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 605);
5118 show_backtrace(1);
5119 }
5120 var17 = ((val* (*)(val*, long))(var16->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var16, var_i) /* [] on <var16:Array[Couple[Object, nullable Object]]>*/;
5121 var18 = ((val* (*)(val*))(var17->class->vft[COLOR_abstract_collection__Couple__second]))(var17) /* second on <var17:nullable Object(Couple[Object, nullable Object])>*/;
5122 if (var18 == NULL) {
5123 var19 = (var_item == NULL);
5124 } else {
5125 var19 = ((short int (*)(val*, val*))(var18->class->vft[COLOR_kernel__Object___61d_61d]))(var18, var_item) /* == on <var18:nullable Object>*/;
5126 }
5127 if (var19){
5128 ((void (*)(val*, long))(var_map->class->vft[COLOR_array__ArrayMap__remove_at_index]))(var_map, var_i) /* remove_at_index on <var_map:ArrayMap[Object, nullable Object]>*/;
5129 } else {
5130 }
5131 var20 = 1;
5132 { /* Inline kernel#Int#- (var_i,var20) */
5133 var23 = var_i - var20;
5134 var21 = var23;
5135 goto RET_LABEL22;
5136 RET_LABEL22:(void)0;
5137 }
5138 var_i = var21;
5139 CONTINUE_label: (void)0;
5140 }
5141 BREAK_label: (void)0;
5142 RET_LABEL:;
5143 }
5144 /* method array#ArrayMapValues#remove_all for (self: Object, nullable Object) */
5145 void VIRTUAL_array__ArrayMapValues__remove_all(val* self, val* p0) {
5146 array__ArrayMapValues__remove_all(self, p0);
5147 RET_LABEL:;
5148 }
5149 /* method array#ArrayMapValues#init for (self: ArrayMapValues[Object, nullable Object], ArrayMap[Object, nullable Object]) */
5150 void array__ArrayMapValues__init(val* self, val* p0) {
5151 short int var /* : Bool */;
5152 int cltype;
5153 int idtype;
5154 const struct type* type_struct;
5155 const char* var_class_name;
5156 /* Covariant cast for argument 0 (map) <p0:ArrayMap[Object, nullable Object]> isa ArrayMap[ArrayMapValues#0, ArrayMapValues#1] */
5157 /* <p0:ArrayMap[Object, nullable Object]> isa ArrayMap[ArrayMapValues#0, ArrayMapValues#1] */
5158 type_struct = self->type->resolution_table->types[COLOR_array__ArrayMaparray__ArrayMapValues_FT0array__ArrayMapValues_FT1];
5159 cltype = type_struct->color;
5160 idtype = type_struct->id;
5161 if(cltype >= p0->type->table_size) {
5162 var = 0;
5163 } else {
5164 var = p0->type->type_table[cltype] == idtype;
5165 }
5166 if (!var) {
5167 var_class_name = p0 == NULL ? "null" : p0->type->name;
5168 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "ArrayMap[ArrayMapValues#0, ArrayMapValues#1]", var_class_name);
5169 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 554);
5170 show_backtrace(1);
5171 }
5172 self->attrs[COLOR_array__ArrayMapValues___64dmap].val = p0; /* @map on <self:ArrayMapValues[Object, nullable Object]> */
5173 RET_LABEL:;
5174 }
5175 /* method array#ArrayMapValues#init for (self: Object, ArrayMap[Object, nullable Object]) */
5176 void VIRTUAL_array__ArrayMapValues__init(val* self, val* p0) {
5177 array__ArrayMapValues__init(self, p0);
5178 RET_LABEL:;
5179 }
5180 /* method array#Iterator#to_a for (self: Iterator[nullable Object]): Array[nullable Object] */
5181 val* array__Iterator__to_a(val* self) {
5182 val* var /* : Array[nullable Object] */;
5183 val* var1 /* : Array[nullable Object] */;
5184 val* var_res /* var res: Array[nullable Object] */;
5185 short int var2 /* : Bool */;
5186 val* var3 /* : nullable Object */;
5187 var1 = NEW_array__Array(self->type->resolution_table->types[COLOR_array__Arrayabstract_collection__Iterator_FT0]);
5188 ((void (*)(val*))(var1->class->vft[COLOR_array__Array__init]))(var1) /* init on <var1:Array[nullable Object]>*/;
5189 var_res = var1;
5190 for(;;) {
5191 var2 = ((short int (*)(val*))(self->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(self) /* is_ok on <self:Iterator[nullable Object]>*/;
5192 if (!var2) break;
5193 var3 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__Iterator__item]))(self) /* item on <self:Iterator[nullable Object]>*/;
5194 ((void (*)(val*, val*))(var_res->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(var_res, var3) /* add on <var_res:Array[nullable Object]>*/;
5195 ((void (*)(val*))(self->class->vft[COLOR_abstract_collection__Iterator__next]))(self) /* next on <self:Iterator[nullable Object]>*/;
5196 CONTINUE_label: (void)0;
5197 }
5198 BREAK_label: (void)0;
5199 var = var_res;
5200 goto RET_LABEL;
5201 RET_LABEL:;
5202 return var;
5203 }
5204 /* method array#Iterator#to_a for (self: Object): Array[nullable Object] */
5205 val* VIRTUAL_array__Iterator__to_a(val* self) {
5206 val* var /* : Array[nullable Object] */;
5207 val* var1 /* : Array[nullable Object] */;
5208 var1 = array__Iterator__to_a(self);
5209 var = var1;
5210 RET_LABEL:;
5211 return var;
5212 }
5213 /* method array#Collection#to_a for (self: Collection[nullable Object]): Array[nullable Object] */
5214 val* array__Collection__to_a(val* self) {
5215 val* var /* : Array[nullable Object] */;
5216 val* var1 /* : Iterator[nullable Object] */;
5217 val* var2 /* : Array[nullable Object] */;
5218 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__iterator]))(self) /* iterator on <self:Collection[nullable Object]>*/;
5219 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_array__Iterator__to_a]))(var1) /* to_a on <var1:Iterator[nullable Object]>*/;
5220 var = var2;
5221 goto RET_LABEL;
5222 RET_LABEL:;
5223 return var;
5224 }
5225 /* method array#Collection#to_a for (self: Object): Array[nullable Object] */
5226 val* VIRTUAL_array__Collection__to_a(val* self) {
5227 val* var /* : Array[nullable Object] */;
5228 val* var1 /* : Array[nullable Object] */;
5229 var1 = array__Collection__to_a(self);
5230 var = var1;
5231 RET_LABEL:;
5232 return var;
5233 }
5234 /* method array#ArrayCapable#calloc_array for (self: ArrayCapable[nullable Object], Int): NativeArray[nullable Object] */
5235 val* array__ArrayCapable__calloc_array(val* self, long p0) {
5236 val* var /* : NativeArray[nullable Object] */;
5237 val* var1 /* : NativeArray[nullable Object] */;
5238 var1 = NEW_array__NativeArray(p0, self->type->resolution_table->types[COLOR_array__NativeArrayarray__ArrayCapable_FT0]);
5239 var = var1;
5240 goto RET_LABEL;
5241 RET_LABEL:;
5242 return var;
5243 }
5244 /* method array#ArrayCapable#calloc_array for (self: Object, Int): NativeArray[nullable Object] */
5245 val* VIRTUAL_array__ArrayCapable__calloc_array(val* self, long p0) {
5246 val* var /* : NativeArray[nullable Object] */;
5247 val* var1 /* : NativeArray[nullable Object] */;
5248 val* var3 /* : NativeArray[nullable Object] */;
5249 { /* Inline array#ArrayCapable#calloc_array (self,p0) */
5250 var3 = NEW_array__NativeArray(p0, self->type->resolution_table->types[COLOR_array__NativeArrayarray__ArrayCapable_FT0]);
5251 var1 = var3;
5252 goto RET_LABEL2;
5253 RET_LABEL2:(void)0;
5254 }
5255 var = var1;
5256 RET_LABEL:;
5257 return var;
5258 }
5259 /* method array#NativeArray#[] for (self: NativeArray[nullable Object], Int): nullable Object */
5260 val* array__NativeArray___91d_93d(val* self, long p0) {
5261 val* var /* : nullable Object */;
5262 val* var1 /* : nullable Object */;
5263 var1 = ((struct instance_array__NativeArray*)self)->values[p0];
5264 var = var1;
5265 goto RET_LABEL;
5266 RET_LABEL:;
5267 return var;
5268 }
5269 /* method array#NativeArray#[] for (self: Object, Int): nullable Object */
5270 val* VIRTUAL_array__NativeArray___91d_93d(val* self, long p0) {
5271 val* var /* : nullable Object */;
5272 val* var1 /* : nullable Object */;
5273 val* var3 /* : nullable Object */;
5274 { /* Inline array#NativeArray#[] (self,p0) */
5275 var3 = ((struct instance_array__NativeArray*)self)->values[p0];
5276 var1 = var3;
5277 goto RET_LABEL2;
5278 RET_LABEL2:(void)0;
5279 }
5280 var = var1;
5281 RET_LABEL:;
5282 return var;
5283 }
5284 /* method array#NativeArray#[]= for (self: NativeArray[nullable Object], Int, nullable Object) */
5285 void array__NativeArray___91d_93d_61d(val* self, long p0, val* p1) {
5286 short int var /* : Bool */;
5287 int cltype;
5288 int idtype;
5289 const struct type* type_struct;
5290 short int is_nullable;
5291 const char* var_class_name;
5292 /* Covariant cast for argument 1 (item) <p1:nullable Object> isa NativeArray#0 */
5293 /* <p1:nullable Object> isa NativeArray#0 */
5294 type_struct = self->type->resolution_table->types[COLOR_array__NativeArray_FT0];
5295 cltype = type_struct->color;
5296 idtype = type_struct->id;
5297 is_nullable = type_struct->is_nullable;
5298 if(p1 == NULL) {
5299 var = is_nullable;
5300 } else {
5301 if(cltype >= p1->type->table_size) {
5302 var = 0;
5303 } else {
5304 var = p1->type->type_table[cltype] == idtype;
5305 }
5306 }
5307 if (!var) {
5308 var_class_name = p1 == NULL ? "null" : p1->type->name;
5309 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "NativeArray#0", var_class_name);
5310 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 648);
5311 show_backtrace(1);
5312 }
5313 ((struct instance_array__NativeArray*)self)->values[p0]=p1;
5314 RET_LABEL:;
5315 }
5316 /* method array#NativeArray#[]= for (self: Object, Int, nullable Object) */
5317 void VIRTUAL_array__NativeArray___91d_93d_61d(val* self, long p0, val* p1) {
5318 short int var /* : Bool */;
5319 int cltype;
5320 int idtype;
5321 const struct type* type_struct;
5322 short int is_nullable;
5323 const char* var_class_name;
5324 { /* Inline array#NativeArray#[]= (self,p0,p1) */
5325 /* Covariant cast for argument 1 (item) <p1:nullable Object> isa NativeArray#0 */
5326 /* <p1:nullable Object> isa NativeArray#0 */
5327 type_struct = self->type->resolution_table->types[COLOR_array__NativeArray_FT0];
5328 cltype = type_struct->color;
5329 idtype = type_struct->id;
5330 is_nullable = type_struct->is_nullable;
5331 if(p1 == NULL) {
5332 var = is_nullable;
5333 } else {
5334 if(cltype >= p1->type->table_size) {
5335 var = 0;
5336 } else {
5337 var = p1->type->type_table[cltype] == idtype;
5338 }
5339 }
5340 if (!var) {
5341 var_class_name = p1 == NULL ? "null" : p1->type->name;
5342 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "NativeArray#0", var_class_name);
5343 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 648);
5344 show_backtrace(1);
5345 }
5346 ((struct instance_array__NativeArray*)self)->values[p0]=p1;
5347 RET_LABEL1:(void)0;
5348 }
5349 RET_LABEL:;
5350 }
5351 /* method array#NativeArray#copy_to for (self: NativeArray[nullable Object], NativeArray[nullable Object], Int) */
5352 void array__NativeArray__copy_to(val* self, val* p0, long p1) {
5353 short int var /* : Bool */;
5354 int cltype;
5355 int idtype;
5356 const struct type* type_struct;
5357 const char* var_class_name;
5358 /* Covariant cast for argument 0 (dest) <p0:NativeArray[nullable Object]> isa NativeArray[NativeArray#0] */
5359 /* <p0:NativeArray[nullable Object]> isa NativeArray[NativeArray#0] */
5360 type_struct = self->type->resolution_table->types[COLOR_array__NativeArrayarray__NativeArray_FT0];
5361 cltype = type_struct->color;
5362 idtype = type_struct->id;
5363 if(cltype >= p0->type->table_size) {
5364 var = 0;
5365 } else {
5366 var = p0->type->type_table[cltype] == idtype;
5367 }
5368 if (!var) {
5369 var_class_name = p0 == NULL ? "null" : p0->type->name;
5370 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "NativeArray[NativeArray#0]", var_class_name);
5371 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 649);
5372 show_backtrace(1);
5373 }
5374 memcpy(((struct instance_array__NativeArray*)p0)->values, ((struct instance_array__NativeArray*)self)->values, p1*sizeof(val*));
5375 RET_LABEL:;
5376 }
5377 /* method array#NativeArray#copy_to for (self: Object, NativeArray[nullable Object], Int) */
5378 void VIRTUAL_array__NativeArray__copy_to(val* self, val* p0, long p1) {
5379 short int var /* : Bool */;
5380 int cltype;
5381 int idtype;
5382 const struct type* type_struct;
5383 const char* var_class_name;
5384 { /* Inline array#NativeArray#copy_to (self,p0,p1) */
5385 /* Covariant cast for argument 0 (dest) <p0:NativeArray[nullable Object]> isa NativeArray[NativeArray#0] */
5386 /* <p0:NativeArray[nullable Object]> isa NativeArray[NativeArray#0] */
5387 type_struct = self->type->resolution_table->types[COLOR_array__NativeArrayarray__NativeArray_FT0];
5388 cltype = type_struct->color;
5389 idtype = type_struct->id;
5390 if(cltype >= p0->type->table_size) {
5391 var = 0;
5392 } else {
5393 var = p0->type->type_table[cltype] == idtype;
5394 }
5395 if (!var) {
5396 var_class_name = p0 == NULL ? "null" : p0->type->name;
5397 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "NativeArray[NativeArray#0]", var_class_name);
5398 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/array.nit", 649);
5399 show_backtrace(1);
5400 }
5401 memcpy(((struct instance_array__NativeArray*)p0)->values, ((struct instance_array__NativeArray*)self)->values, p1*sizeof(val*));
5402 RET_LABEL1:(void)0;
5403 }
5404 RET_LABEL:;
5405 }