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