c_src/abstract_collection.sep.1.c

   1 #include "abstract_collection.sep.0.h"
   2 /* method abstract_collection#Collection#iterator for (self: Collection[nullable Object]): Iterator[nullable Object] */
   3 val* abstract_collection__Collection__iterator(val* self) {
   4 val* var /* : Iterator[nullable Object] */;
   5 const char* var_class_name;
   6 var_class_name = self == NULL ? "null" : self->type->name;
   7 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "iterator", var_class_name);
   8 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 54);
   9 exit(1);
  10 RET_LABEL:;
  11 return var;
  12 }
  13 /* method abstract_collection#Collection#iterator for (self: Object): Iterator[nullable Object] */
  14 val* VIRTUAL_abstract_collection__Collection__iterator(val* self) {
  15 val* var /* : Iterator[nullable Object] */;
  16 val* var1 /* : Iterator[nullable Object] */;
  17 var1 = abstract_collection__Collection__iterator(self);
  18 var = var1;
  19 RET_LABEL:;
  20 return var;
  21 }
  22 /* method abstract_collection#Collection#is_empty for (self: Collection[nullable Object]): Bool */
  23 short int abstract_collection__Collection__is_empty(val* self) {
  24 short int var /* : Bool */;
  25 long var1 /* : Int */;
  26 long var2 /* : Int */;
  27 short int var3 /* : Bool */;
  28 short int var5 /* : Bool */;
  29 var1 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:Collection[nullable Object]>*/;
  30 var2 = 0;
  31 { /* Inline kernel#Int#== (var1,var2) */
  32 var5 = var1 == var2;
  33 var3 = var5;
  34 goto RET_LABEL4;
  35 RET_LABEL4:(void)0;
  36 }
  37 var = var3;
  38 goto RET_LABEL;
  39 RET_LABEL:;
  40 return var;
  41 }
  42 /* method abstract_collection#Collection#is_empty for (self: Object): Bool */
  43 short int VIRTUAL_abstract_collection__Collection__is_empty(val* self) {
  44 short int var /* : Bool */;
  45 short int var1 /* : Bool */;
  46 var1 = abstract_collection__Collection__is_empty(self);
  47 var = var1;
  48 RET_LABEL:;
  49 return var;
  50 }
  51 /* method abstract_collection#Collection#length for (self: Collection[nullable Object]): Int */
  52 long abstract_collection__Collection__length(val* self) {
  53 long var /* : Int */;
  54 long var1 /* : Int */;
  55 long var_nb /* var nb: Int */;
  56 val* var2 /* : Iterator[nullable Object] */;
  57 short int var3 /* : Bool */;
  58 val* var4 /* : nullable Object */;
  59 val* var_i /* var i: nullable Object */;
  60 long var5 /* : Int */;
  61 long var6 /* : Int */;
  62 long var8 /* : Int */;
  63 var1 = 0;
  64 var_nb = var1;
  65 var2 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__iterator]))(self) /* iterator on <self:Collection[nullable Object]>*/;
  66 for(;;) {
  67 var3 = ((short int (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var2) /* is_ok on <var2:Iterator[nullable Object]>*/;
  68 if(!var3) break;
  69 var4 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__item]))(var2) /* item on <var2:Iterator[nullable Object]>*/;
  70 var_i = var4;
  71 var5 = 1;
  72 { /* Inline kernel#Int#+ (var_nb,var5) */
  73 var8 = var_nb + var5;
  74 var6 = var8;
  75 goto RET_LABEL7;
  76 RET_LABEL7:(void)0;
  77 }
  78 var_nb = var6;
  79 CONTINUE_label: (void)0;
  80 ((void (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__next]))(var2) /* next on <var2:Iterator[nullable Object]>*/;
  81 }
  82 BREAK_label: (void)0;
  83 var = var_nb;
  84 goto RET_LABEL;
  85 RET_LABEL:;
  86 return var;
  87 }
  88 /* method abstract_collection#Collection#length for (self: Object): Int */
  89 long VIRTUAL_abstract_collection__Collection__length(val* self) {
  90 long var /* : Int */;
  91 long var1 /* : Int */;
  92 var1 = abstract_collection__Collection__length(self);
  93 var = var1;
  94 RET_LABEL:;
  95 return var;
  96 }
  97 /* method abstract_collection#Collection#has for (self: Collection[nullable Object], nullable Object): Bool */
  98 short int abstract_collection__Collection__has(val* self, val* p0) {
  99 short int var /* : Bool */;
 100 short int var1 /* : Bool */;
 101 int cltype;
 102 int idtype;
 103 const struct type* type_struct;
 104 short int is_nullable;
 105 const char* var_class_name;
 106 val* var_item /* var item: nullable Object */;
 107 val* var2 /* : Iterator[nullable Object] */;
 108 short int var3 /* : Bool */;
 109 val* var4 /* : nullable Object */;
 110 val* var_i /* var i: nullable Object */;
 111 short int var5 /* : Bool */;
 112 short int var6 /* : Bool */;
 113 short int var7 /* : Bool */;
 114 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa Collection#0 */
 115 /* <p0:nullable Object> isa Collection#0 */
 116 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collection_FT0];
 117 cltype = type_struct->color;
 118 idtype = type_struct->id;
 119 is_nullable = type_struct->is_nullable;
 120 if(p0 == NULL) {
 121 var1 = is_nullable;
 122 } else {
 123 if(cltype >= p0->type->table_size) {
 124 var1 = 0;
 125 } else {
 126 var1 = p0->type->type_table[cltype] == idtype;
 127 }
 128 }
 129 if (!var1) {
 130 var_class_name = p0 == NULL ? "null" : p0->type->name;
 131 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection#0", var_class_name);
 132 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 75);
 133 exit(1);
 134 }
 135 var_item = p0;
 136 var2 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__iterator]))(self) /* iterator on <self:Collection[nullable Object]>*/;
 137 for(;;) {
 138 var3 = ((short int (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var2) /* is_ok on <var2:Iterator[nullable Object]>*/;
 139 if(!var3) break;
 140 var4 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__item]))(var2) /* item on <var2:Iterator[nullable Object]>*/;
 141 var_i = var4;
 142 if (var_i == NULL) {
 143 var5 = (var_item == NULL);
 144 } else {
 145 var5 = ((short int (*)(val*, val*))(var_i->class->vft[COLOR_kernel__Object___61d_61d]))(var_i, var_item) /* == on <var_i:nullable Object>*/;
 146 }
 147 if (var5){
 148 var6 = 1;
 149 var = var6;
 150 goto RET_LABEL;
 151 } else {
 152 }
 153 CONTINUE_label: (void)0;
 154 ((void (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__next]))(var2) /* next on <var2:Iterator[nullable Object]>*/;
 155 }
 156 BREAK_label: (void)0;
 157 var7 = 0;
 158 var = var7;
 159 goto RET_LABEL;
 160 RET_LABEL:;
 161 return var;
 162 }
 163 /* method abstract_collection#Collection#has for (self: Object, nullable Object): Bool */
 164 short int VIRTUAL_abstract_collection__Collection__has(val* self, val* p0) {
 165 short int var /* : Bool */;
 166 short int var1 /* : Bool */;
 167 var1 = abstract_collection__Collection__has(self, p0);
 168 var = var1;
 169 RET_LABEL:;
 170 return var;
 171 }
 172 /* method abstract_collection#Collection#has_only for (self: Collection[nullable Object], nullable Object): Bool */
 173 short int abstract_collection__Collection__has_only(val* self, val* p0) {
 174 short int var /* : Bool */;
 175 short int var1 /* : Bool */;
 176 int cltype;
 177 int idtype;
 178 const struct type* type_struct;
 179 short int is_nullable;
 180 const char* var_class_name;
 181 val* var_item /* var item: nullable Object */;
 182 val* var2 /* : Iterator[nullable Object] */;
 183 short int var3 /* : Bool */;
 184 val* var4 /* : nullable Object */;
 185 val* var_i /* var i: nullable Object */;
 186 short int var5 /* : Bool */;
 187 short int var6 /* : Bool */;
 188 short int var7 /* : Bool */;
 189 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa Collection#0 */
 190 /* <p0:nullable Object> isa Collection#0 */
 191 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collection_FT0];
 192 cltype = type_struct->color;
 193 idtype = type_struct->id;
 194 is_nullable = type_struct->is_nullable;
 195 if(p0 == NULL) {
 196 var1 = is_nullable;
 197 } else {
 198 if(cltype >= p0->type->table_size) {
 199 var1 = 0;
 200 } else {
 201 var1 = p0->type->type_table[cltype] == idtype;
 202 }
 203 }
 204 if (!var1) {
 205 var_class_name = p0 == NULL ? "null" : p0->type->name;
 206 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection#0", var_class_name);
 207 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 88);
 208 exit(1);
 209 }
 210 var_item = p0;
 211 var2 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__iterator]))(self) /* iterator on <self:Collection[nullable Object]>*/;
 212 for(;;) {
 213 var3 = ((short int (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var2) /* is_ok on <var2:Iterator[nullable Object]>*/;
 214 if(!var3) break;
 215 var4 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__item]))(var2) /* item on <var2:Iterator[nullable Object]>*/;
 216 var_i = var4;
 217 if (var_i == NULL) {
 218 var5 = (var_item != NULL);
 219 } else {
 220 var5 = ((short int (*)(val*, val*))(var_i->class->vft[COLOR_kernel__Object___33d_61d]))(var_i, var_item) /* != on <var_i:nullable Object>*/;
 221 }
 222 if (var5){
 223 var6 = 0;
 224 var = var6;
 225 goto RET_LABEL;
 226 } else {
 227 }
 228 CONTINUE_label: (void)0;
 229 ((void (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__next]))(var2) /* next on <var2:Iterator[nullable Object]>*/;
 230 }
 231 BREAK_label: (void)0;
 232 var7 = 1;
 233 var = var7;
 234 goto RET_LABEL;
 235 RET_LABEL:;
 236 return var;
 237 }
 238 /* method abstract_collection#Collection#has_only for (self: Object, nullable Object): Bool */
 239 short int VIRTUAL_abstract_collection__Collection__has_only(val* self, val* p0) {
 240 short int var /* : Bool */;
 241 short int var1 /* : Bool */;
 242 var1 = abstract_collection__Collection__has_only(self, p0);
 243 var = var1;
 244 RET_LABEL:;
 245 return var;
 246 }
 247 /* method abstract_collection#Collection#count for (self: Collection[nullable Object], nullable Object): Int */
 248 long abstract_collection__Collection__count(val* self, val* p0) {
 249 long var /* : Int */;
 250 short int var1 /* : Bool */;
 251 int cltype;
 252 int idtype;
 253 const struct type* type_struct;
 254 short int is_nullable;
 255 const char* var_class_name;
 256 val* var_item /* var item: nullable Object */;
 257 long var2 /* : Int */;
 258 long var_nb /* var nb: Int */;
 259 val* var3 /* : Iterator[nullable Object] */;
 260 short int var4 /* : Bool */;
 261 val* var5 /* : nullable Object */;
 262 val* var_i /* var i: nullable Object */;
 263 short int var6 /* : Bool */;
 264 long var7 /* : Int */;
 265 long var8 /* : Int */;
 266 long var10 /* : Int */;
 267 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa Collection#0 */
 268 /* <p0:nullable Object> isa Collection#0 */
 269 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collection_FT0];
 270 cltype = type_struct->color;
 271 idtype = type_struct->id;
 272 is_nullable = type_struct->is_nullable;
 273 if(p0 == NULL) {
 274 var1 = is_nullable;
 275 } else {
 276 if(cltype >= p0->type->table_size) {
 277 var1 = 0;
 278 } else {
 279 var1 = p0->type->type_table[cltype] == idtype;
 280 }
 281 }
 282 if (!var1) {
 283 var_class_name = p0 == NULL ? "null" : p0->type->name;
 284 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection#0", var_class_name);
 285 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 105);
 286 exit(1);
 287 }
 288 var_item = p0;
 289 var2 = 0;
 290 var_nb = var2;
 291 var3 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__iterator]))(self) /* iterator on <self:Collection[nullable Object]>*/;
 292 for(;;) {
 293 var4 = ((short int (*)(val*))(var3->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var3) /* is_ok on <var3:Iterator[nullable Object]>*/;
 294 if(!var4) break;
 295 var5 = ((val* (*)(val*))(var3->class->vft[COLOR_abstract_collection__Iterator__item]))(var3) /* item on <var3:Iterator[nullable Object]>*/;
 296 var_i = var5;
 297 if (var_i == NULL) {
 298 var6 = (var_item == NULL);
 299 } else {
 300 var6 = ((short int (*)(val*, val*))(var_i->class->vft[COLOR_kernel__Object___61d_61d]))(var_i, var_item) /* == on <var_i:nullable Object>*/;
 301 }
 302 if (var6){
 303 var7 = 1;
 304 { /* Inline kernel#Int#+ (var_nb,var7) */
 305 var10 = var_nb + var7;
 306 var8 = var10;
 307 goto RET_LABEL9;
 308 RET_LABEL9:(void)0;
 309 }
 310 var_nb = var8;
 311 } else {
 312 }
 313 CONTINUE_label: (void)0;
 314 ((void (*)(val*))(var3->class->vft[COLOR_abstract_collection__Iterator__next]))(var3) /* next on <var3:Iterator[nullable Object]>*/;
 315 }
 316 BREAK_label: (void)0;
 317 var = var_nb;
 318 goto RET_LABEL;
 319 RET_LABEL:;
 320 return var;
 321 }
 322 /* method abstract_collection#Collection#count for (self: Object, nullable Object): Int */
 323 long VIRTUAL_abstract_collection__Collection__count(val* self, val* p0) {
 324 long var /* : Int */;
 325 long var1 /* : Int */;
 326 var1 = abstract_collection__Collection__count(self, p0);
 327 var = var1;
 328 RET_LABEL:;
 329 return var;
 330 }
 331 /* method abstract_collection#Collection#first for (self: Collection[nullable Object]): nullable Object */
 332 val* abstract_collection__Collection__first(val* self) {
 333 val* var /* : nullable Object */;
 334 long var1 /* : Int */;
 335 long var2 /* : Int */;
 336 short int var3 /* : Bool */;
 337 short int var5 /* : Bool */;
 338 int cltype;
 339 int idtype;
 340 const char* var_class_name;
 341 short int var6 /* : Bool */;
 342 val* var7 /* : Iterator[nullable Object] */;
 343 val* var8 /* : nullable Object */;
 344 var1 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:Collection[nullable Object]>*/;
 345 var2 = 0;
 346 { /* Inline kernel#Int#> (var1,var2) */
 347 /* Covariant cast for argument 0 (i) <var2:Int> isa OTHER */
 348 /* <var2:Int> isa OTHER */
 349 var5 = 1; /* easy <var2:Int> isa OTHER*/
 350 if (!var5) {
 351 var_class_name = type_kernel__Int.name;
 352 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
 353 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 263);
 354 exit(1);
 355 }
 356 var6 = var1 > var2;
 357 var3 = var6;
 358 goto RET_LABEL4;
 359 RET_LABEL4:(void)0;
 360 }
 361 if (!var3) {
 362 fprintf(stderr, "Runtime error: %s", "Assert failed");
 363 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 121);
 364 exit(1);
 365 }
 366 var7 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__iterator]))(self) /* iterator on <self:Collection[nullable Object]>*/;
 367 var8 = ((val* (*)(val*))(var7->class->vft[COLOR_abstract_collection__Iterator__item]))(var7) /* item on <var7:Iterator[nullable Object]>*/;
 368 var = var8;
 369 goto RET_LABEL;
 370 RET_LABEL:;
 371 return var;
 372 }
 373 /* method abstract_collection#Collection#first for (self: Object): nullable Object */
 374 val* VIRTUAL_abstract_collection__Collection__first(val* self) {
 375 val* var /* : nullable Object */;
 376 val* var1 /* : nullable Object */;
 377 var1 = abstract_collection__Collection__first(self);
 378 var = var1;
 379 RET_LABEL:;
 380 return var;
 381 }
 382 /* method abstract_collection#Collection#has_all for (self: Collection[nullable Object], Collection[nullable Object]): Bool */
 383 short int abstract_collection__Collection__has_all(val* self, val* p0) {
 384 short int var /* : Bool */;
 385 short int var1 /* : Bool */;
 386 int cltype;
 387 int idtype;
 388 const struct type* type_struct;
 389 const char* var_class_name;
 390 val* var_other /* var other: Collection[nullable Object] */;
 391 val* var2 /* : Iterator[nullable Object] */;
 392 short int var3 /* : Bool */;
 393 val* var4 /* : nullable Object */;
 394 val* var_x /* var x: nullable Object */;
 395 short int var5 /* : Bool */;
 396 short int var6 /* : Bool */;
 397 short int var7 /* : Bool */;
 398 short int var8 /* : Bool */;
 399 /* Covariant cast for argument 0 (other) <p0:Collection[nullable Object]> isa Collection[Collection#0] */
 400 /* <p0:Collection[nullable Object]> isa Collection[Collection#0] */
 401 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collectionabstract_collection__Collection_FT0];
 402 cltype = type_struct->color;
 403 idtype = type_struct->id;
 404 if(cltype >= p0->type->table_size) {
 405 var1 = 0;
 406 } else {
 407 var1 = p0->type->type_table[cltype] == idtype;
 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`", "Collection[Collection#0]", var_class_name);
 412 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 125);
 413 exit(1);
 414 }
 415 var_other = p0;
 416 var2 = ((val* (*)(val*))(var_other->class->vft[COLOR_abstract_collection__Collection__iterator]))(var_other) /* iterator on <var_other:Collection[nullable Object]>*/;
 417 for(;;) {
 418 var3 = ((short int (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var2) /* is_ok on <var2:Iterator[nullable Object]>*/;
 419 if(!var3) break;
 420 var4 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__item]))(var2) /* item on <var2:Iterator[nullable Object]>*/;
 421 var_x = var4;
 422 var5 = ((short int (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__Collection__has]))(self, var_x) /* has on <self:Collection[nullable Object]>*/;
 423 var6 = !var5;
 424 if (var6){
 425 var7 = 0;
 426 var = var7;
 427 goto RET_LABEL;
 428 } else {
 429 }
 430 CONTINUE_label: (void)0;
 431 ((void (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__next]))(var2) /* next on <var2:Iterator[nullable Object]>*/;
 432 }
 433 BREAK_label: (void)0;
 434 var8 = 1;
 435 var = var8;
 436 goto RET_LABEL;
 437 RET_LABEL:;
 438 return var;
 439 }
 440 /* method abstract_collection#Collection#has_all for (self: Object, Collection[nullable Object]): Bool */
 441 short int VIRTUAL_abstract_collection__Collection__has_all(val* self, val* p0) {
 442 short int var /* : Bool */;
 443 short int var1 /* : Bool */;
 444 var1 = abstract_collection__Collection__has_all(self, p0);
 445 var = var1;
 446 RET_LABEL:;
 447 return var;
 448 }
 449 /* method abstract_collection#Iterator#item for (self: Iterator[nullable Object]): nullable Object */
 450 val* abstract_collection__Iterator__item(val* self) {
 451 val* var /* : nullable Object */;
 452 const char* var_class_name;
 453 var_class_name = self == NULL ? "null" : self->type->name;
 454 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "item", var_class_name);
 455 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 141);
 456 exit(1);
 457 RET_LABEL:;
 458 return var;
 459 }
 460 /* method abstract_collection#Iterator#item for (self: Object): nullable Object */
 461 val* VIRTUAL_abstract_collection__Iterator__item(val* self) {
 462 val* var /* : nullable Object */;
 463 val* var1 /* : nullable Object */;
 464 var1 = abstract_collection__Iterator__item(self);
 465 var = var1;
 466 RET_LABEL:;
 467 return var;
 468 }
 469 /* method abstract_collection#Iterator#next for (self: Iterator[nullable Object]) */
 470 void abstract_collection__Iterator__next(val* self) {
 471 const char* var_class_name;
 472 var_class_name = self == NULL ? "null" : self->type->name;
 473 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "next", var_class_name);
 474 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 145);
 475 exit(1);
 476 RET_LABEL:;
 477 }
 478 /* method abstract_collection#Iterator#next for (self: Object) */
 479 void VIRTUAL_abstract_collection__Iterator__next(val* self) {
 480 abstract_collection__Iterator__next(self);
 481 RET_LABEL:;
 482 }
 483 /* method abstract_collection#Iterator#is_ok for (self: Iterator[nullable Object]): Bool */
 484 short int abstract_collection__Iterator__is_ok(val* self) {
 485 short int var /* : Bool */;
 486 const char* var_class_name;
 487 var_class_name = self == NULL ? "null" : self->type->name;
 488 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "is_ok", var_class_name);
 489 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 149);
 490 exit(1);
 491 RET_LABEL:;
 492 return var;
 493 }
 494 /* method abstract_collection#Iterator#is_ok for (self: Object): Bool */
 495 short int VIRTUAL_abstract_collection__Iterator__is_ok(val* self) {
 496 short int var /* : Bool */;
 497 short int var1 /* : Bool */;
 498 var1 = abstract_collection__Iterator__is_ok(self);
 499 var = var1;
 500 RET_LABEL:;
 501 return var;
 502 }
 503 /* method abstract_collection#Container#first for (self: Container[nullable Object]): nullable Object */
 504 val* abstract_collection__Container__first(val* self) {
 505 val* var /* : nullable Object */;
 506 val* var1 /* : nullable Object */;
 507 var1 = self->attrs[COLOR_abstract_collection__Container___item].val; /* _item on <self:Container[nullable Object]> */
 508 var = var1;
 509 goto RET_LABEL;
 510 RET_LABEL:;
 511 return var;
 512 }
 513 /* method abstract_collection#Container#first for (self: Object): nullable Object */
 514 val* VIRTUAL_abstract_collection__Container__first(val* self) {
 515 val* var /* : nullable Object */;
 516 val* var1 /* : nullable Object */;
 517 var1 = abstract_collection__Container__first(self);
 518 var = var1;
 519 RET_LABEL:;
 520 return var;
 521 }
 522 /* method abstract_collection#Container#is_empty for (self: Container[nullable Object]): Bool */
 523 short int abstract_collection__Container__is_empty(val* self) {
 524 short int var /* : Bool */;
 525 short int var1 /* : Bool */;
 526 var1 = 0;
 527 var = var1;
 528 goto RET_LABEL;
 529 RET_LABEL:;
 530 return var;
 531 }
 532 /* method abstract_collection#Container#is_empty for (self: Object): Bool */
 533 short int VIRTUAL_abstract_collection__Container__is_empty(val* self) {
 534 short int var /* : Bool */;
 535 short int var1 /* : Bool */;
 536 var1 = abstract_collection__Container__is_empty(self);
 537 var = var1;
 538 RET_LABEL:;
 539 return var;
 540 }
 541 /* method abstract_collection#Container#length for (self: Container[nullable Object]): Int */
 542 long abstract_collection__Container__length(val* self) {
 543 long var /* : Int */;
 544 long var1 /* : Int */;
 545 var1 = 1;
 546 var = var1;
 547 goto RET_LABEL;
 548 RET_LABEL:;
 549 return var;
 550 }
 551 /* method abstract_collection#Container#length for (self: Object): Int */
 552 long VIRTUAL_abstract_collection__Container__length(val* self) {
 553 long var /* : Int */;
 554 long var1 /* : Int */;
 555 var1 = abstract_collection__Container__length(self);
 556 var = var1;
 557 RET_LABEL:;
 558 return var;
 559 }
 560 /* method abstract_collection#Container#has for (self: Container[nullable Object], nullable Object): Bool */
 561 short int abstract_collection__Container__has(val* self, val* p0) {
 562 short int var /* : Bool */;
 563 short int var1 /* : Bool */;
 564 int cltype;
 565 int idtype;
 566 const struct type* type_struct;
 567 short int is_nullable;
 568 const char* var_class_name;
 569 val* var_an_item /* var an_item: nullable Object */;
 570 val* var2 /* : nullable Object */;
 571 short int var3 /* : Bool */;
 572 /* Covariant cast for argument 0 (an_item) <p0:nullable Object> isa Collection#0 */
 573 /* <p0:nullable Object> isa Collection#0 */
 574 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collection_FT0];
 575 cltype = type_struct->color;
 576 idtype = type_struct->id;
 577 is_nullable = type_struct->is_nullable;
 578 if(p0 == NULL) {
 579 var1 = is_nullable;
 580 } else {
 581 if(cltype >= p0->type->table_size) {
 582 var1 = 0;
 583 } else {
 584 var1 = p0->type->type_table[cltype] == idtype;
 585 }
 586 }
 587 if (!var1) {
 588 var_class_name = p0 == NULL ? "null" : p0->type->name;
 589 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection#0", var_class_name);
 590 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 163);
 591 exit(1);
 592 }
 593 var_an_item = p0;
 594 var2 = self->attrs[COLOR_abstract_collection__Container___item].val; /* _item on <self:Container[nullable Object]> */
 595 if (var2 == NULL) {
 596 var3 = (var_an_item == NULL);
 597 } else {
 598 var3 = ((short int (*)(val*, val*))(var2->class->vft[COLOR_kernel__Object___61d_61d]))(var2, var_an_item) /* == on <var2:nullable Object>*/;
 599 }
 600 var = var3;
 601 goto RET_LABEL;
 602 RET_LABEL:;
 603 return var;
 604 }
 605 /* method abstract_collection#Container#has for (self: Object, nullable Object): Bool */
 606 short int VIRTUAL_abstract_collection__Container__has(val* self, val* p0) {
 607 short int var /* : Bool */;
 608 short int var1 /* : Bool */;
 609 var1 = abstract_collection__Container__has(self, p0);
 610 var = var1;
 611 RET_LABEL:;
 612 return var;
 613 }
 614 /* method abstract_collection#Container#has_only for (self: Container[nullable Object], nullable Object): Bool */
 615 short int abstract_collection__Container__has_only(val* self, val* p0) {
 616 short int var /* : Bool */;
 617 short int var1 /* : Bool */;
 618 int cltype;
 619 int idtype;
 620 const struct type* type_struct;
 621 short int is_nullable;
 622 const char* var_class_name;
 623 val* var_an_item /* var an_item: nullable Object */;
 624 val* var2 /* : nullable Object */;
 625 short int var3 /* : Bool */;
 626 /* Covariant cast for argument 0 (an_item) <p0:nullable Object> isa Collection#0 */
 627 /* <p0:nullable Object> isa Collection#0 */
 628 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collection_FT0];
 629 cltype = type_struct->color;
 630 idtype = type_struct->id;
 631 is_nullable = type_struct->is_nullable;
 632 if(p0 == NULL) {
 633 var1 = is_nullable;
 634 } else {
 635 if(cltype >= p0->type->table_size) {
 636 var1 = 0;
 637 } else {
 638 var1 = p0->type->type_table[cltype] == idtype;
 639 }
 640 }
 641 if (!var1) {
 642 var_class_name = p0 == NULL ? "null" : p0->type->name;
 643 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection#0", var_class_name);
 644 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 165);
 645 exit(1);
 646 }
 647 var_an_item = p0;
 648 var2 = self->attrs[COLOR_abstract_collection__Container___item].val; /* _item on <self:Container[nullable Object]> */
 649 if (var2 == NULL) {
 650 var3 = (var_an_item == NULL);
 651 } else {
 652 var3 = ((short int (*)(val*, val*))(var2->class->vft[COLOR_kernel__Object___61d_61d]))(var2, var_an_item) /* == on <var2:nullable Object>*/;
 653 }
 654 var = var3;
 655 goto RET_LABEL;
 656 RET_LABEL:;
 657 return var;
 658 }
 659 /* method abstract_collection#Container#has_only for (self: Object, nullable Object): Bool */
 660 short int VIRTUAL_abstract_collection__Container__has_only(val* self, val* p0) {
 661 short int var /* : Bool */;
 662 short int var1 /* : Bool */;
 663 var1 = abstract_collection__Container__has_only(self, p0);
 664 var = var1;
 665 RET_LABEL:;
 666 return var;
 667 }
 668 /* method abstract_collection#Container#count for (self: Container[nullable Object], nullable Object): Int */
 669 long abstract_collection__Container__count(val* self, val* p0) {
 670 long var /* : Int */;
 671 short int var1 /* : Bool */;
 672 int cltype;
 673 int idtype;
 674 const struct type* type_struct;
 675 short int is_nullable;
 676 const char* var_class_name;
 677 val* var_an_item /* var an_item: nullable Object */;
 678 val* var2 /* : nullable Object */;
 679 short int var3 /* : Bool */;
 680 long var4 /* : Int */;
 681 long var5 /* : Int */;
 682 /* Covariant cast for argument 0 (an_item) <p0:nullable Object> isa Collection#0 */
 683 /* <p0:nullable Object> isa Collection#0 */
 684 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collection_FT0];
 685 cltype = type_struct->color;
 686 idtype = type_struct->id;
 687 is_nullable = type_struct->is_nullable;
 688 if(p0 == NULL) {
 689 var1 = is_nullable;
 690 } else {
 691 if(cltype >= p0->type->table_size) {
 692 var1 = 0;
 693 } else {
 694 var1 = p0->type->type_table[cltype] == idtype;
 695 }
 696 }
 697 if (!var1) {
 698 var_class_name = p0 == NULL ? "null" : p0->type->name;
 699 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection#0", var_class_name);
 700 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 167);
 701 exit(1);
 702 }
 703 var_an_item = p0;
 704 var2 = self->attrs[COLOR_abstract_collection__Container___item].val; /* _item on <self:Container[nullable Object]> */
 705 if (var2 == NULL) {
 706 var3 = (var_an_item == NULL);
 707 } else {
 708 var3 = ((short int (*)(val*, val*))(var2->class->vft[COLOR_kernel__Object___61d_61d]))(var2, var_an_item) /* == on <var2:nullable Object>*/;
 709 }
 710 if (var3){
 711 var4 = 1;
 712 var = var4;
 713 goto RET_LABEL;
 714 } else {
 715 var5 = 0;
 716 var = var5;
 717 goto RET_LABEL;
 718 }
 719 RET_LABEL:;
 720 return var;
 721 }
 722 /* method abstract_collection#Container#count for (self: Object, nullable Object): Int */
 723 long VIRTUAL_abstract_collection__Container__count(val* self, val* p0) {
 724 long var /* : Int */;
 725 long var1 /* : Int */;
 726 var1 = abstract_collection__Container__count(self, p0);
 727 var = var1;
 728 RET_LABEL:;
 729 return var;
 730 }
 731 /* method abstract_collection#Container#iterator for (self: Container[nullable Object]): Iterator[nullable Object] */
 732 val* abstract_collection__Container__iterator(val* self) {
 733 val* var /* : Iterator[nullable Object] */;
 734 val* var1 /* : ContainerIterator[nullable Object] */;
 735 var1 = NEW_abstract_collection__ContainerIterator(self->type->resolution_table->types[COLOR_abstract_collection__ContainerIteratorabstract_collection__Container_FT0]);
 736 ((void (*)(val*, val*))(var1->class->vft[COLOR_abstract_collection__ContainerIterator__init]))(var1, self) /* init on <var1:ContainerIterator[nullable Object]>*/;
 737 CHECK_NEW_abstract_collection__ContainerIterator(var1);
 738 var = var1;
 739 goto RET_LABEL;
 740 RET_LABEL:;
 741 return var;
 742 }
 743 /* method abstract_collection#Container#iterator for (self: Object): Iterator[nullable Object] */
 744 val* VIRTUAL_abstract_collection__Container__iterator(val* self) {
 745 val* var /* : Iterator[nullable Object] */;
 746 val* var1 /* : Iterator[nullable Object] */;
 747 var1 = abstract_collection__Container__iterator(self);
 748 var = var1;
 749 RET_LABEL:;
 750 return var;
 751 }
 752 /* method abstract_collection#Container#init for (self: Container[nullable Object], nullable Object) */
 753 void abstract_collection__Container__init(val* self, val* p0) {
 754 short int var /* : Bool */;
 755 int cltype;
 756 int idtype;
 757 const struct type* type_struct;
 758 short int is_nullable;
 759 const char* var_class_name;
 760 val* var_e /* var e: nullable Object */;
 761 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa Container#0 */
 762 /* <p0:nullable Object> isa Container#0 */
 763 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Container_FT0];
 764 cltype = type_struct->color;
 765 idtype = type_struct->id;
 766 is_nullable = type_struct->is_nullable;
 767 if(p0 == NULL) {
 768 var = is_nullable;
 769 } else {
 770 if(cltype >= p0->type->table_size) {
 771 var = 0;
 772 } else {
 773 var = p0->type->type_table[cltype] == idtype;
 774 }
 775 }
 776 if (!var) {
 777 var_class_name = p0 == NULL ? "null" : p0->type->name;
 778 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Container#0", var_class_name);
 779 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 178);
 780 exit(1);
 781 }
 782 var_e = p0;
 783 self->attrs[COLOR_abstract_collection__Container___item].val = var_e; /* _item on <self:Container[nullable Object]> */
 784 RET_LABEL:;
 785 }
 786 /* method abstract_collection#Container#init for (self: Object, nullable Object) */
 787 void VIRTUAL_abstract_collection__Container__init(val* self, val* p0) {
 788 abstract_collection__Container__init(self, p0);
 789 RET_LABEL:;
 790 }
 791 /* method abstract_collection#Container#item for (self: Container[nullable Object]): nullable Object */
 792 val* abstract_collection__Container__item(val* self) {
 793 val* var /* : nullable Object */;
 794 val* var1 /* : nullable Object */;
 795 var1 = self->attrs[COLOR_abstract_collection__Container___item].val; /* _item on <self:Container[nullable Object]> */
 796 var = var1;
 797 RET_LABEL:;
 798 return var;
 799 }
 800 /* method abstract_collection#Container#item for (self: Object): nullable Object */
 801 val* VIRTUAL_abstract_collection__Container__item(val* self) {
 802 val* var /* : nullable Object */;
 803 val* var1 /* : nullable Object */;
 804 var1 = abstract_collection__Container__item(self);
 805 var = var1;
 806 RET_LABEL:;
 807 return var;
 808 }
 809 /* method abstract_collection#Container#item= for (self: Container[nullable Object], nullable Object) */
 810 void abstract_collection__Container__item_61d(val* self, val* p0) {
 811 short int var /* : Bool */;
 812 int cltype;
 813 int idtype;
 814 const struct type* type_struct;
 815 short int is_nullable;
 816 const char* var_class_name;
 817 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa Container#0 */
 818 /* <p0:nullable Object> isa Container#0 */
 819 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Container_FT0];
 820 cltype = type_struct->color;
 821 idtype = type_struct->id;
 822 is_nullable = type_struct->is_nullable;
 823 if(p0 == NULL) {
 824 var = is_nullable;
 825 } else {
 826 if(cltype >= p0->type->table_size) {
 827 var = 0;
 828 } else {
 829 var = p0->type->type_table[cltype] == idtype;
 830 }
 831 }
 832 if (!var) {
 833 var_class_name = p0 == NULL ? "null" : p0->type->name;
 834 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Container#0", var_class_name);
 835 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 181);
 836 exit(1);
 837 }
 838 self->attrs[COLOR_abstract_collection__Container___item].val = p0; /* _item on <self:Container[nullable Object]> */
 839 RET_LABEL:;
 840 }
 841 /* method abstract_collection#Container#item= for (self: Object, nullable Object) */
 842 void VIRTUAL_abstract_collection__Container__item_61d(val* self, val* p0) {
 843 abstract_collection__Container__item_61d(self, p0);
 844 RET_LABEL:;
 845 }
 846 /* method abstract_collection#ContainerIterator#item for (self: ContainerIterator[nullable Object]): nullable Object */
 847 val* abstract_collection__ContainerIterator__item(val* self) {
 848 val* var /* : nullable Object */;
 849 val* var1 /* : Container[nullable Object] */;
 850 val* var2 /* : nullable Object */;
 851 var1 = self->attrs[COLOR_abstract_collection__ContainerIterator___container].val; /* _container on <self:ContainerIterator[nullable Object]> */
 852 if (var1 == NULL) {
 853 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _container");
 854 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 188);
 855 exit(1);
 856 }
 857 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_abstract_collection__Container__item]))(var1) /* item on <var1:Container[nullable Object]>*/;
 858 var = var2;
 859 goto RET_LABEL;
 860 RET_LABEL:;
 861 return var;
 862 }
 863 /* method abstract_collection#ContainerIterator#item for (self: Object): nullable Object */
 864 val* VIRTUAL_abstract_collection__ContainerIterator__item(val* self) {
 865 val* var /* : nullable Object */;
 866 val* var1 /* : nullable Object */;
 867 var1 = abstract_collection__ContainerIterator__item(self);
 868 var = var1;
 869 RET_LABEL:;
 870 return var;
 871 }
 872 /* method abstract_collection#ContainerIterator#next for (self: ContainerIterator[nullable Object]) */
 873 void abstract_collection__ContainerIterator__next(val* self) {
 874 short int var /* : Bool */;
 875 var = 0;
 876 self->attrs[COLOR_abstract_collection__ContainerIterator___is_ok].s = var; /* _is_ok on <self:ContainerIterator[nullable Object]> */
 877 RET_LABEL:;
 878 }
 879 /* method abstract_collection#ContainerIterator#next for (self: Object) */
 880 void VIRTUAL_abstract_collection__ContainerIterator__next(val* self) {
 881 abstract_collection__ContainerIterator__next(self);
 882 RET_LABEL:;
 883 }
 884 /* method abstract_collection#ContainerIterator#init for (self: ContainerIterator[nullable Object], Container[nullable Object]) */
 885 void abstract_collection__ContainerIterator__init(val* self, val* p0) {
 886 short int var /* : Bool */;
 887 int cltype;
 888 int idtype;
 889 const struct type* type_struct;
 890 const char* var_class_name;
 891 val* var_c /* var c: Container[nullable Object] */;
 892 /* Covariant cast for argument 0 (c) <p0:Container[nullable Object]> isa Container[ContainerIterator#0] */
 893 /* <p0:Container[nullable Object]> isa Container[ContainerIterator#0] */
 894 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Containerabstract_collection__ContainerIterator_FT0];
 895 cltype = type_struct->color;
 896 idtype = type_struct->id;
 897 if(cltype >= p0->type->table_size) {
 898 var = 0;
 899 } else {
 900 var = p0->type->type_table[cltype] == idtype;
 901 }
 902 if (!var) {
 903 var_class_name = p0 == NULL ? "null" : p0->type->name;
 904 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Container[ContainerIterator#0]", var_class_name);
 905 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 192);
 906 exit(1);
 907 }
 908 var_c = p0;
 909 self->attrs[COLOR_abstract_collection__ContainerIterator___container].val = var_c; /* _container on <self:ContainerIterator[nullable Object]> */
 910 RET_LABEL:;
 911 }
 912 /* method abstract_collection#ContainerIterator#init for (self: Object, Container[nullable Object]) */
 913 void VIRTUAL_abstract_collection__ContainerIterator__init(val* self, val* p0) {
 914 abstract_collection__ContainerIterator__init(self, p0);
 915 RET_LABEL:;
 916 }
 917 /* method abstract_collection#ContainerIterator#is_ok for (self: ContainerIterator[nullable Object]): Bool */
 918 short int abstract_collection__ContainerIterator__is_ok(val* self) {
 919 short int var /* : Bool */;
 920 short int var1 /* : Bool */;
 921 var1 = self->attrs[COLOR_abstract_collection__ContainerIterator___is_ok].s; /* _is_ok on <self:ContainerIterator[nullable Object]> */
 922 var = var1;
 923 RET_LABEL:;
 924 return var;
 925 }
 926 /* method abstract_collection#ContainerIterator#is_ok for (self: Object): Bool */
 927 short int VIRTUAL_abstract_collection__ContainerIterator__is_ok(val* self) {
 928 short int var /* : Bool */;
 929 short int var1 /* : Bool */;
 930 var1 = abstract_collection__ContainerIterator__is_ok(self);
 931 var = var1;
 932 RET_LABEL:;
 933 return var;
 934 }
 935 /* method abstract_collection#RemovableCollection#clear for (self: RemovableCollection[nullable Object]) */
 936 void abstract_collection__RemovableCollection__clear(val* self) {
 937 const char* var_class_name;
 938 var_class_name = self == NULL ? "null" : self->type->name;
 939 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "clear", var_class_name);
 940 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 202);
 941 exit(1);
 942 RET_LABEL:;
 943 }
 944 /* method abstract_collection#RemovableCollection#clear for (self: Object) */
 945 void VIRTUAL_abstract_collection__RemovableCollection__clear(val* self) {
 946 abstract_collection__RemovableCollection__clear(self);
 947 RET_LABEL:;
 948 }
 949 /* method abstract_collection#RemovableCollection#remove for (self: RemovableCollection[nullable Object], nullable Object) */
 950 void abstract_collection__RemovableCollection__remove(val* self, val* p0) {
 951 short int var /* : Bool */;
 952 int cltype;
 953 int idtype;
 954 const struct type* type_struct;
 955 short int is_nullable;
 956 const char* var_class_name;
 957 const char* var_class_name1;
 958 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa RemovableCollection#0 */
 959 /* <p0:nullable Object> isa RemovableCollection#0 */
 960 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__RemovableCollection_FT0];
 961 cltype = type_struct->color;
 962 idtype = type_struct->id;
 963 is_nullable = type_struct->is_nullable;
 964 if(p0 == NULL) {
 965 var = is_nullable;
 966 } else {
 967 if(cltype >= p0->type->table_size) {
 968 var = 0;
 969 } else {
 970 var = p0->type->type_table[cltype] == idtype;
 971 }
 972 }
 973 if (!var) {
 974 var_class_name = p0 == NULL ? "null" : p0->type->name;
 975 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "RemovableCollection#0", var_class_name);
 976 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 205);
 977 exit(1);
 978 }
 979 var_class_name1 = self == NULL ? "null" : self->type->name;
 980 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "remove", var_class_name1);
 981 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 205);
 982 exit(1);
 983 RET_LABEL:;
 984 }
 985 /* method abstract_collection#RemovableCollection#remove for (self: Object, nullable Object) */
 986 void VIRTUAL_abstract_collection__RemovableCollection__remove(val* self, val* p0) {
 987 abstract_collection__RemovableCollection__remove(self, p0);
 988 RET_LABEL:;
 989 }
 990 /* method abstract_collection#RemovableCollection#remove_all for (self: RemovableCollection[nullable Object], nullable Object) */
 991 void abstract_collection__RemovableCollection__remove_all(val* self, val* p0) {
 992 short int var /* : Bool */;
 993 int cltype;
 994 int idtype;
 995 const struct type* type_struct;
 996 short int is_nullable;
 997 const char* var_class_name;
 998 val* var_item /* var item: nullable Object */;
 999 short int var1 /* : Bool */;
1000 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa RemovableCollection#0 */
1001 /* <p0:nullable Object> isa RemovableCollection#0 */
1002 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__RemovableCollection_FT0];
1003 cltype = type_struct->color;
1004 idtype = type_struct->id;
1005 is_nullable = type_struct->is_nullable;
1006 if(p0 == NULL) {
1007 var = is_nullable;
1008 } else {
1009 if(cltype >= p0->type->table_size) {
1010 var = 0;
1011 } else {
1012 var = p0->type->type_table[cltype] == idtype;
1013 }
1014 }
1015 if (!var) {
1016 var_class_name = p0 == NULL ? "null" : p0->type->name;
1017 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "RemovableCollection#0", var_class_name);
1018 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 208);
1019 exit(1);
1020 }
1021 var_item = p0;
1022 for(;;) {
1023 var1 = ((short int (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__Collection__has]))(self, var_item) /* has on <self:RemovableCollection[nullable Object]>*/;
1024 if (!var1) break;
1025 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__RemovableCollection__remove]))(self, var_item) /* remove on <self:RemovableCollection[nullable Object]>*/;
1026 CONTINUE_label: (void)0;
1027 }
1028 BREAK_label: (void)0;
1029 RET_LABEL:;
1030 }
1031 /* method abstract_collection#RemovableCollection#remove_all for (self: Object, nullable Object) */
1032 void VIRTUAL_abstract_collection__RemovableCollection__remove_all(val* self, val* p0) {
1033 abstract_collection__RemovableCollection__remove_all(self, p0);
1034 RET_LABEL:;
1035 }
1036 /* method abstract_collection#SimpleCollection#add for (self: SimpleCollection[nullable Object], nullable Object) */
1037 void abstract_collection__SimpleCollection__add(val* self, val* p0) {
1038 short int var /* : Bool */;
1039 int cltype;
1040 int idtype;
1041 const struct type* type_struct;
1042 short int is_nullable;
1043 const char* var_class_name;
1044 const char* var_class_name1;
1045 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa SimpleCollection#0 */
1046 /* <p0:nullable Object> isa SimpleCollection#0 */
1047 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__SimpleCollection_FT0];
1048 cltype = type_struct->color;
1049 idtype = type_struct->id;
1050 is_nullable = type_struct->is_nullable;
1051 if(p0 == NULL) {
1052 var = is_nullable;
1053 } else {
1054 if(cltype >= p0->type->table_size) {
1055 var = 0;
1056 } else {
1057 var = p0->type->type_table[cltype] == idtype;
1058 }
1059 }
1060 if (!var) {
1061 var_class_name = p0 == NULL ? "null" : p0->type->name;
1062 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "SimpleCollection#0", var_class_name);
1063 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 215);
1064 exit(1);
1065 }
1066 var_class_name1 = self == NULL ? "null" : self->type->name;
1067 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "add", var_class_name1);
1068 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 215);
1069 exit(1);
1070 RET_LABEL:;
1071 }
1072 /* method abstract_collection#SimpleCollection#add for (self: Object, nullable Object) */
1073 void VIRTUAL_abstract_collection__SimpleCollection__add(val* self, val* p0) {
1074 abstract_collection__SimpleCollection__add(self, p0);
1075 RET_LABEL:;
1076 }
1077 /* method abstract_collection#SimpleCollection#add_all for (self: SimpleCollection[nullable Object], Collection[nullable Object]) */
1078 void abstract_collection__SimpleCollection__add_all(val* self, val* p0) {
1079 short int var /* : Bool */;
1080 int cltype;
1081 int idtype;
1082 const struct type* type_struct;
1083 const char* var_class_name;
1084 val* var_coll /* var coll: Collection[nullable Object] */;
1085 val* var1 /* : Iterator[nullable Object] */;
1086 short int var2 /* : Bool */;
1087 val* var3 /* : nullable Object */;
1088 val* var_i /* var i: nullable Object */;
1089 /* Covariant cast for argument 0 (coll) <p0:Collection[nullable Object]> isa Collection[SimpleCollection#0] */
1090 /* <p0:Collection[nullable Object]> isa Collection[SimpleCollection#0] */
1091 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collectionabstract_collection__SimpleCollection_FT0];
1092 cltype = type_struct->color;
1093 idtype = type_struct->id;
1094 if(cltype >= p0->type->table_size) {
1095 var = 0;
1096 } else {
1097 var = p0->type->type_table[cltype] == idtype;
1098 }
1099 if (!var) {
1100 var_class_name = p0 == NULL ? "null" : p0->type->name;
1101 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection[SimpleCollection#0]", var_class_name);
1102 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 219);
1103 exit(1);
1104 }
1105 var_coll = p0;
1106 var1 = ((val* (*)(val*))(var_coll->class->vft[COLOR_abstract_collection__Collection__iterator]))(var_coll) /* iterator on <var_coll:Collection[nullable Object]>*/;
1107 for(;;) {
1108 var2 = ((short int (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var1) /* is_ok on <var1:Iterator[nullable Object]>*/;
1109 if(!var2) break;
1110 var3 = ((val* (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__item]))(var1) /* item on <var1:Iterator[nullable Object]>*/;
1111 var_i = var3;
1112 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__SimpleCollection__add]))(self, var_i) /* add on <self:SimpleCollection[nullable Object]>*/;
1113 CONTINUE_label: (void)0;
1114 ((void (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__next]))(var1) /* next on <var1:Iterator[nullable Object]>*/;
1115 }
1116 BREAK_label: (void)0;
1117 RET_LABEL:;
1118 }
1119 /* method abstract_collection#SimpleCollection#add_all for (self: Object, Collection[nullable Object]) */
1120 void VIRTUAL_abstract_collection__SimpleCollection__add_all(val* self, val* p0) {
1121 abstract_collection__SimpleCollection__add_all(self, p0);
1122 RET_LABEL:;
1123 }
1124 /* method abstract_collection#Set#has_only for (self: Set[Object], Object): Bool */
1125 short int abstract_collection__Set__has_only(val* self, val* p0) {
1126 short int var /* : Bool */;
1127 short int var1 /* : Bool */;
1128 int cltype;
1129 int idtype;
1130 const struct type* type_struct;
1131 const char* var_class_name;
1132 val* var_item /* var item: Object */;
1133 long var2 /* : Int */;
1134 long var_l /* var l: Int */;
1135 long var3 /* : Int */;
1136 short int var4 /* : Bool */;
1137 short int var6 /* : Bool */;
1138 short int var7 /* : Bool */;
1139 long var8 /* : Int */;
1140 short int var9 /* : Bool */;
1141 short int var11 /* : Bool */;
1142 short int var12 /* : Bool */;
1143 short int var13 /* : Bool */;
1144 /* Covariant cast for argument 0 (item) <p0:Object> isa Collection#0 */
1145 /* <p0:Object> isa Collection#0 */
1146 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collection_FT0];
1147 cltype = type_struct->color;
1148 idtype = type_struct->id;
1149 if(cltype >= p0->type->table_size) {
1150 var1 = 0;
1151 } else {
1152 var1 = p0->type->type_table[cltype] == idtype;
1153 }
1154 if (!var1) {
1155 var_class_name = p0 == NULL ? "null" : p0->type->name;
1156 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection#0", var_class_name);
1157 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 235);
1158 exit(1);
1159 }
1160 var_item = p0;
1161 var2 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:Set[Object]>*/;
1162 var_l = var2;
1163 var3 = 1;
1164 { /* Inline kernel#Int#== (var_l,var3) */
1165 var6 = var_l == var3;
1166 var4 = var6;
1167 goto RET_LABEL5;
1168 RET_LABEL5:(void)0;
1169 }
1170 if (var4){
1171 var7 = ((short int (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__Collection__has]))(self, var_item) /* has on <self:Set[Object]>*/;
1172 var = var7;
1173 goto RET_LABEL;
1174 } else {
1175 var8 = 0;
1176 { /* Inline kernel#Int#== (var_l,var8) */
1177 var11 = var_l == var8;
1178 var9 = var11;
1179 goto RET_LABEL10;
1180 RET_LABEL10:(void)0;
1181 }
1182 if (var9){
1183 var12 = 1;
1184 var = var12;
1185 goto RET_LABEL;
1186 } else {
1187 var13 = 0;
1188 var = var13;
1189 goto RET_LABEL;
1190 }
1191 }
1192 RET_LABEL:;
1193 return var;
1194 }
1195 /* method abstract_collection#Set#has_only for (self: Object, nullable Object): Bool */
1196 short int VIRTUAL_abstract_collection__Set__has_only(val* self, val* p0) {
1197 short int var /* : Bool */;
1198 short int var1 /* : Bool */;
1199 var1 = abstract_collection__Set__has_only(self, p0);
1200 var = var1;
1201 RET_LABEL:;
1202 return var;
1203 }
1204 /* method abstract_collection#Set#count for (self: Set[Object], Object): Int */
1205 long abstract_collection__Set__count(val* self, val* p0) {
1206 long var /* : Int */;
1207 short int var1 /* : Bool */;
1208 int cltype;
1209 int idtype;
1210 const struct type* type_struct;
1211 const char* var_class_name;
1212 val* var_item /* var item: Object */;
1213 short int var2 /* : Bool */;
1214 long var3 /* : Int */;
1215 long var4 /* : Int */;
1216 /* Covariant cast for argument 0 (item) <p0:Object> isa Collection#0 */
1217 /* <p0:Object> isa Collection#0 */
1218 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collection_FT0];
1219 cltype = type_struct->color;
1220 idtype = type_struct->id;
1221 if(cltype >= p0->type->table_size) {
1222 var1 = 0;
1223 } else {
1224 var1 = p0->type->type_table[cltype] == idtype;
1225 }
1226 if (!var1) {
1227 var_class_name = p0 == NULL ? "null" : p0->type->name;
1228 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection#0", var_class_name);
1229 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 247);
1230 exit(1);
1231 }
1232 var_item = p0;
1233 var2 = ((short int (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__Collection__has]))(self, var_item) /* has on <self:Set[Object]>*/;
1234 if (var2){
1235 var3 = 1;
1236 var = var3;
1237 goto RET_LABEL;
1238 } else {
1239 var4 = 0;
1240 var = var4;
1241 goto RET_LABEL;
1242 }
1243 RET_LABEL:;
1244 return var;
1245 }
1246 /* method abstract_collection#Set#count for (self: Object, nullable Object): Int */
1247 long VIRTUAL_abstract_collection__Set__count(val* self, val* p0) {
1248 long var /* : Int */;
1249 long var1 /* : Int */;
1250 var1 = abstract_collection__Set__count(self, p0);
1251 var = var1;
1252 RET_LABEL:;
1253 return var;
1254 }
1255 /* method abstract_collection#Set#remove_all for (self: Set[Object], Object) */
1256 void abstract_collection__Set__remove_all(val* self, val* p0) {
1257 short int var /* : Bool */;
1258 int cltype;
1259 int idtype;
1260 const struct type* type_struct;
1261 const char* var_class_name;
1262 val* var_item /* var item: Object */;
1263 /* Covariant cast for argument 0 (item) <p0:Object> isa RemovableCollection#0 */
1264 /* <p0:Object> isa RemovableCollection#0 */
1265 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__RemovableCollection_FT0];
1266 cltype = type_struct->color;
1267 idtype = type_struct->id;
1268 if(cltype >= p0->type->table_size) {
1269 var = 0;
1270 } else {
1271 var = p0->type->type_table[cltype] == idtype;
1272 }
1273 if (!var) {
1274 var_class_name = p0 == NULL ? "null" : p0->type->name;
1275 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "RemovableCollection#0", var_class_name);
1276 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 257);
1277 exit(1);
1278 }
1279 var_item = p0;
1280 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__RemovableCollection__remove]))(self, var_item) /* remove on <self:Set[Object]>*/;
1281 RET_LABEL:;
1282 }
1283 /* method abstract_collection#Set#remove_all for (self: Object, nullable Object) */
1284 void VIRTUAL_abstract_collection__Set__remove_all(val* self, val* p0) {
1285 abstract_collection__Set__remove_all(self, p0);
1286 RET_LABEL:;
1287 }
1288 /* method abstract_collection#Set#== for (self: Set[Object], nullable Object): Bool */
1289 short int abstract_collection__Set___61d_61d(val* self, val* p0) {
1290 short int var /* : Bool */;
1291 val* var_other /* var other: nullable Object */;
1292 short int var1 /* : Bool */;
1293 int cltype;
1294 int idtype;
1295 short int var2 /* : Bool */;
1296 short int var3 /* : Bool */;
1297 long var4 /* : Int */;
1298 long var5 /* : Int */;
1299 short int var6 /* : Bool */;
1300 short int var8 /* : Bool */;
1301 short int var9 /* : Bool */;
1302 short int var10 /* : Bool */;
1303 short int var11 /* : Bool */;
1304 int cltype12;
1305 int idtype13;
1306 const struct type* type_struct;
1307 const char* var_class_name;
1308 short int var14 /* : Bool */;
1309 var_other = p0;
1310 /* <var_other:nullable Object> isa Set[Object] */
1311 cltype = type_abstract_collection__Setkernel__Object.color;
1312 idtype = type_abstract_collection__Setkernel__Object.id;
1313 if(var_other == NULL) {
1314 var1 = 0;
1315 } else {
1316 if(cltype >= var_other->type->table_size) {
1317 var1 = 0;
1318 } else {
1319 var1 = var_other->type->type_table[cltype] == idtype;
1320 }
1321 }
1322 var2 = !var1;
1323 if (var2){
1324 var3 = 0;
1325 var = var3;
1326 goto RET_LABEL;
1327 } else {
1328 }
1329 var4 = ((long (*)(val*))(var_other->class->vft[COLOR_abstract_collection__Collection__length]))(var_other) /* length on <var_other:nullable Object(Set[Object])>*/;
1330 var5 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:Set[Object]>*/;
1331 { /* Inline kernel#Int#!= (var4,var5) */
1332 var8 = var4 == var5;
1333 var9 = !var8;
1334 var6 = var9;
1335 goto RET_LABEL7;
1336 RET_LABEL7:(void)0;
1337 }
1338 if (var6){
1339 var10 = 0;
1340 var = var10;
1341 goto RET_LABEL;
1342 } else {
1343 }
1344 /* <var_other:nullable Object(Set[Object])> isa Collection[Set#0] */
1345 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collectionabstract_collection__Set_FT0];
1346 cltype12 = type_struct->color;
1347 idtype13 = type_struct->id;
1348 if(cltype12 >= var_other->type->table_size) {
1349 var11 = 0;
1350 } else {
1351 var11 = var_other->type->type_table[cltype12] == idtype13;
1352 }
1353 if (!var11) {
1354 var_class_name = var_other == NULL ? "null" : var_other->type->name;
1355 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection[Set#0]", var_class_name);
1356 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 265);
1357 exit(1);
1358 }
1359 var14 = ((short int (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__Collection__has_all]))(self, var_other) /* has_all on <self:Set[Object]>*/;
1360 var = var14;
1361 goto RET_LABEL;
1362 RET_LABEL:;
1363 return var;
1364 }
1365 /* method abstract_collection#Set#== for (self: Object, nullable Object): Bool */
1366 short int VIRTUAL_abstract_collection__Set___61d_61d(val* self, val* p0) {
1367 short int var /* : Bool */;
1368 short int var1 /* : Bool */;
1369 var1 = abstract_collection__Set___61d_61d(self, p0);
1370 var = var1;
1371 RET_LABEL:;
1372 return var;
1373 }
1374 /* method abstract_collection#Set#hash for (self: Set[Object]): Int */
1375 long abstract_collection__Set__hash(val* self) {
1376 long var /* : Int */;
1377 long var1 /* : Int */;
1378 long var_res /* var res: Int */;
1379 val* var2 /* : Iterator[nullable Object] */;
1380 short int var3 /* : Bool */;
1381 val* var4 /* : nullable Object */;
1382 val* var_e /* var e: Object */;
1383 long var5 /* : Int */;
1384 long var6 /* : Int */;
1385 long var8 /* : Int */;
1386 var1 = 0;
1387 var_res = var1;
1388 var2 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__iterator]))(self) /* iterator on <self:Set[Object]>*/;
1389 for(;;) {
1390 var3 = ((short int (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var2) /* is_ok on <var2:Iterator[nullable Object]>*/;
1391 if(!var3) break;
1392 var4 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__item]))(var2) /* item on <var2:Iterator[nullable Object]>*/;
1393 var_e = var4;
1394 var5 = kernel__Int__hash(var_res);
1395 { /* Inline kernel#Int#+ (var_res,var5) */
1396 var8 = var_res + var5;
1397 var6 = var8;
1398 goto RET_LABEL7;
1399 RET_LABEL7:(void)0;
1400 }
1401 var_res = var6;
1402 CONTINUE_label: (void)0;
1403 ((void (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__next]))(var2) /* next on <var2:Iterator[nullable Object]>*/;
1404 }
1405 BREAK_label: (void)0;
1406 var = var_res;
1407 goto RET_LABEL;
1408 RET_LABEL:;
1409 return var;
1410 }
1411 /* method abstract_collection#Set#hash for (self: Object): Int */
1412 long VIRTUAL_abstract_collection__Set__hash(val* self) {
1413 long var /* : Int */;
1414 long var1 /* : Int */;
1415 var1 = abstract_collection__Set__hash(self);
1416 var = var1;
1417 RET_LABEL:;
1418 return var;
1419 }
1420 /* method abstract_collection#MapRead#[] for (self: MapRead[Object, nullable Object], Object): nullable Object */
1421 val* abstract_collection__MapRead___91d_93d(val* self, val* p0) {
1422 val* var /* : nullable Object */;
1423 short int var1 /* : Bool */;
1424 int cltype;
1425 int idtype;
1426 const struct type* type_struct;
1427 const char* var_class_name;
1428 const char* var_class_name2;
1429 /* Covariant cast for argument 0 (key) <p0:Object> isa MapRead#0 */
1430 /* <p0:Object> isa MapRead#0 */
1431 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__MapRead_FT0];
1432 cltype = type_struct->color;
1433 idtype = type_struct->id;
1434 if(cltype >= p0->type->table_size) {
1435 var1 = 0;
1436 } else {
1437 var1 = p0->type->type_table[cltype] == idtype;
1438 }
1439 if (!var1) {
1440 var_class_name = p0 == NULL ? "null" : p0->type->name;
1441 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapRead#0", var_class_name);
1442 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 279);
1443 exit(1);
1444 }
1445 var_class_name2 = self == NULL ? "null" : self->type->name;
1446 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "[]", var_class_name2);
1447 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 279);
1448 exit(1);
1449 RET_LABEL:;
1450 return var;
1451 }
1452 /* method abstract_collection#MapRead#[] for (self: Object, Object): nullable Object */
1453 val* VIRTUAL_abstract_collection__MapRead___91d_93d(val* self, val* p0) {
1454 val* var /* : nullable Object */;
1455 val* var1 /* : nullable Object */;
1456 var1 = abstract_collection__MapRead___91d_93d(self, p0);
1457 var = var1;
1458 RET_LABEL:;
1459 return var;
1460 }
1461 /* method abstract_collection#MapRead#get_or_default for (self: MapRead[Object, nullable Object], Object, nullable Object): nullable Object */
1462 val* abstract_collection__MapRead__get_or_default(val* self, val* p0, val* p1) {
1463 val* var /* : nullable Object */;
1464 short int var1 /* : Bool */;
1465 int cltype;
1466 int idtype;
1467 const struct type* type_struct;
1468 const char* var_class_name;
1469 short int var2 /* : Bool */;
1470 int cltype3;
1471 int idtype4;
1472 const struct type* type_struct5;
1473 short int is_nullable;
1474 const char* var_class_name6;
1475 val* var_key /* var key: Object */;
1476 val* var_default /* var default: nullable Object */;
1477 short int var7 /* : Bool */;
1478 val* var8 /* : nullable Object */;
1479 /* Covariant cast for argument 0 (key) <p0:Object> isa MapRead#0 */
1480 /* <p0:Object> isa MapRead#0 */
1481 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__MapRead_FT0];
1482 cltype = type_struct->color;
1483 idtype = type_struct->id;
1484 if(cltype >= p0->type->table_size) {
1485 var1 = 0;
1486 } else {
1487 var1 = p0->type->type_table[cltype] == idtype;
1488 }
1489 if (!var1) {
1490 var_class_name = p0 == NULL ? "null" : p0->type->name;
1491 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapRead#0", var_class_name);
1492 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 282);
1493 exit(1);
1494 }
1495 /* Covariant cast for argument 1 (default) <p1:nullable Object> isa MapRead#1 */
1496 /* <p1:nullable Object> isa MapRead#1 */
1497 type_struct5 = self->type->resolution_table->types[COLOR_abstract_collection__MapRead_FT1];
1498 cltype3 = type_struct5->color;
1499 idtype4 = type_struct5->id;
1500 is_nullable = type_struct5->is_nullable;
1501 if(p1 == NULL) {
1502 var2 = is_nullable;
1503 } else {
1504 if(cltype3 >= p1->type->table_size) {
1505 var2 = 0;
1506 } else {
1507 var2 = p1->type->type_table[cltype3] == idtype4;
1508 }
1509 }
1510 if (!var2) {
1511 var_class_name6 = p1 == NULL ? "null" : p1->type->name;
1512 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapRead#1", var_class_name6);
1513 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 282);
1514 exit(1);
1515 }
1516 var_key = p0;
1517 var_default = p1;
1518 var7 = ((short int (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__MapRead__has_key]))(self, var_key) /* has_key on <self:MapRead[Object, nullable Object]>*/;
1519 if (var7){
1520 var8 = ((val* (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__MapRead___91d_93d]))(self, var_key) /* [] on <self:MapRead[Object, nullable Object]>*/;
1521 var = var8;
1522 goto RET_LABEL;
1523 } else {
1524 }
1525 var = var_default;
1526 goto RET_LABEL;
1527 RET_LABEL:;
1528 return var;
1529 }
1530 /* method abstract_collection#MapRead#get_or_default for (self: Object, Object, nullable Object): nullable Object */
1531 val* VIRTUAL_abstract_collection__MapRead__get_or_default(val* self, val* p0, val* p1) {
1532 val* var /* : nullable Object */;
1533 val* var1 /* : nullable Object */;
1534 var1 = abstract_collection__MapRead__get_or_default(self, p0, p1);
1535 var = var1;
1536 RET_LABEL:;
1537 return var;
1538 }
1539 /* method abstract_collection#MapRead#has_key for (self: MapRead[Object, nullable Object], Object): Bool */
1540 short int abstract_collection__MapRead__has_key(val* self, val* p0) {
1541 short int var /* : Bool */;
1542 short int var1 /* : Bool */;
1543 int cltype;
1544 int idtype;
1545 const struct type* type_struct;
1546 const char* var_class_name;
1547 val* var_key /* var key: Object */;
1548 val* var2 /* : Collection[Object] */;
1549 short int var3 /* : Bool */;
1550 /* Covariant cast for argument 0 (key) <p0:Object> isa MapRead#0 */
1551 /* <p0:Object> isa MapRead#0 */
1552 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__MapRead_FT0];
1553 cltype = type_struct->color;
1554 idtype = type_struct->id;
1555 if(cltype >= p0->type->table_size) {
1556 var1 = 0;
1557 } else {
1558 var1 = p0->type->type_table[cltype] == idtype;
1559 }
1560 if (!var1) {
1561 var_class_name = p0 == NULL ? "null" : p0->type->name;
1562 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapRead#0", var_class_name);
1563 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 289);
1564 exit(1);
1565 }
1566 var_key = p0;
1567 var2 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__MapRead__keys]))(self) /* keys on <self:MapRead[Object, nullable Object]>*/;
1568 var3 = ((short int (*)(val*, val*))(var2->class->vft[COLOR_abstract_collection__Collection__has]))(var2, var_key) /* has on <var2:Collection[Object]>*/;
1569 var = var3;
1570 goto RET_LABEL;
1571 RET_LABEL:;
1572 return var;
1573 }
1574 /* method abstract_collection#MapRead#has_key for (self: Object, Object): Bool */
1575 short int VIRTUAL_abstract_collection__MapRead__has_key(val* self, val* p0) {
1576 short int var /* : Bool */;
1577 short int var1 /* : Bool */;
1578 var1 = abstract_collection__MapRead__has_key(self, p0);
1579 var = var1;
1580 RET_LABEL:;
1581 return var;
1582 }
1583 /* method abstract_collection#MapRead#iterator for (self: MapRead[Object, nullable Object]): MapIterator[Object, nullable Object] */
1584 val* abstract_collection__MapRead__iterator(val* self) {
1585 val* var /* : MapIterator[Object, nullable Object] */;
1586 const char* var_class_name;
1587 var_class_name = self == NULL ? "null" : self->type->name;
1588 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "iterator", var_class_name);
1589 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 292);
1590 exit(1);
1591 RET_LABEL:;
1592 return var;
1593 }
1594 /* method abstract_collection#MapRead#iterator for (self: Object): MapIterator[Object, nullable Object] */
1595 val* VIRTUAL_abstract_collection__MapRead__iterator(val* self) {
1596 val* var /* : MapIterator[Object, nullable Object] */;
1597 val* var1 /* : MapIterator[Object, nullable Object] */;
1598 var1 = abstract_collection__MapRead__iterator(self);
1599 var = var1;
1600 RET_LABEL:;
1601 return var;
1602 }
1603 /* method abstract_collection#MapRead#values for (self: MapRead[Object, nullable Object]): Collection[nullable Object] */
1604 val* abstract_collection__MapRead__values(val* self) {
1605 val* var /* : Collection[nullable Object] */;
1606 const char* var_class_name;
1607 var_class_name = self == NULL ? "null" : self->type->name;
1608 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "values", var_class_name);
1609 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 295);
1610 exit(1);
1611 RET_LABEL:;
1612 return var;
1613 }
1614 /* method abstract_collection#MapRead#values for (self: Object): Collection[nullable Object] */
1615 val* VIRTUAL_abstract_collection__MapRead__values(val* self) {
1616 val* var /* : Collection[nullable Object] */;
1617 val* var1 /* : Collection[nullable Object] */;
1618 var1 = abstract_collection__MapRead__values(self);
1619 var = var1;
1620 RET_LABEL:;
1621 return var;
1622 }
1623 /* method abstract_collection#MapRead#keys for (self: MapRead[Object, nullable Object]): Collection[Object] */
1624 val* abstract_collection__MapRead__keys(val* self) {
1625 val* var /* : Collection[Object] */;
1626 const char* var_class_name;
1627 var_class_name = self == NULL ? "null" : self->type->name;
1628 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "keys", var_class_name);
1629 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 300);
1630 exit(1);
1631 RET_LABEL:;
1632 return var;
1633 }
1634 /* method abstract_collection#MapRead#keys for (self: Object): Collection[Object] */
1635 val* VIRTUAL_abstract_collection__MapRead__keys(val* self) {
1636 val* var /* : Collection[Object] */;
1637 val* var1 /* : Collection[Object] */;
1638 var1 = abstract_collection__MapRead__keys(self);
1639 var = var1;
1640 RET_LABEL:;
1641 return var;
1642 }
1643 /* method abstract_collection#MapRead#is_empty for (self: MapRead[Object, nullable Object]): Bool */
1644 short int abstract_collection__MapRead__is_empty(val* self) {
1645 short int var /* : Bool */;
1646 const char* var_class_name;
1647 var_class_name = self == NULL ? "null" : self->type->name;
1648 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "is_empty", var_class_name);
1649 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 305);
1650 exit(1);
1651 RET_LABEL:;
1652 return var;
1653 }
1654 /* method abstract_collection#MapRead#is_empty for (self: Object): Bool */
1655 short int VIRTUAL_abstract_collection__MapRead__is_empty(val* self) {
1656 short int var /* : Bool */;
1657 short int var1 /* : Bool */;
1658 var1 = abstract_collection__MapRead__is_empty(self);
1659 var = var1;
1660 RET_LABEL:;
1661 return var;
1662 }
1663 /* method abstract_collection#MapRead#length for (self: MapRead[Object, nullable Object]): Int */
1664 long abstract_collection__MapRead__length(val* self) {
1665 long var /* : Int */;
1666 const char* var_class_name;
1667 var_class_name = self == NULL ? "null" : self->type->name;
1668 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "length", var_class_name);
1669 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 308);
1670 exit(1);
1671 RET_LABEL:;
1672 return var;
1673 }
1674 /* method abstract_collection#MapRead#length for (self: Object): Int */
1675 long VIRTUAL_abstract_collection__MapRead__length(val* self) {
1676 long var /* : Int */;
1677 long var1 /* : Int */;
1678 var1 = abstract_collection__MapRead__length(self);
1679 var = var1;
1680 RET_LABEL:;
1681 return var;
1682 }
1683 /* method abstract_collection#Map#[]= for (self: Map[Object, nullable Object], Object, nullable Object) */
1684 void abstract_collection__Map___91d_93d_61d(val* self, val* p0, val* p1) {
1685 short int var /* : Bool */;
1686 int cltype;
1687 int idtype;
1688 const struct type* type_struct;
1689 const char* var_class_name;
1690 short int var1 /* : Bool */;
1691 int cltype2;
1692 int idtype3;
1693 const struct type* type_struct4;
1694 short int is_nullable;
1695 const char* var_class_name5;
1696 const char* var_class_name6;
1697 /* Covariant cast for argument 0 (key) <p0:Object> isa Map#0 */
1698 /* <p0:Object> isa Map#0 */
1699 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Map_FT0];
1700 cltype = type_struct->color;
1701 idtype = type_struct->id;
1702 if(cltype >= p0->type->table_size) {
1703 var = 0;
1704 } else {
1705 var = p0->type->type_table[cltype] == idtype;
1706 }
1707 if (!var) {
1708 var_class_name = p0 == NULL ? "null" : p0->type->name;
1709 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Map#0", var_class_name);
1710 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 338);
1711 exit(1);
1712 }
1713 /* Covariant cast for argument 1 (item) <p1:nullable Object> isa Map#1 */
1714 /* <p1:nullable Object> isa Map#1 */
1715 type_struct4 = self->type->resolution_table->types[COLOR_abstract_collection__Map_FT1];
1716 cltype2 = type_struct4->color;
1717 idtype3 = type_struct4->id;
1718 is_nullable = type_struct4->is_nullable;
1719 if(p1 == NULL) {
1720 var1 = is_nullable;
1721 } else {
1722 if(cltype2 >= p1->type->table_size) {
1723 var1 = 0;
1724 } else {
1725 var1 = p1->type->type_table[cltype2] == idtype3;
1726 }
1727 }
1728 if (!var1) {
1729 var_class_name5 = p1 == NULL ? "null" : p1->type->name;
1730 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Map#1", var_class_name5);
1731 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 338);
1732 exit(1);
1733 }
1734 var_class_name6 = self == NULL ? "null" : self->type->name;
1735 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "[]=", var_class_name6);
1736 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 338);
1737 exit(1);
1738 RET_LABEL:;
1739 }
1740 /* method abstract_collection#Map#[]= for (self: Object, Object, nullable Object) */
1741 void VIRTUAL_abstract_collection__Map___91d_93d_61d(val* self, val* p0, val* p1) {
1742 abstract_collection__Map___91d_93d_61d(self, p0, p1);
1743 RET_LABEL:;
1744 }
1745 /* method abstract_collection#Map#recover_with for (self: Map[Object, nullable Object], Map[Object, nullable Object]) */
1746 void abstract_collection__Map__recover_with(val* self, val* p0) {
1747 short int var /* : Bool */;
1748 int cltype;
1749 int idtype;
1750 const struct type* type_struct;
1751 const char* var_class_name;
1752 val* var_map /* var map: Map[Object, nullable Object] */;
1753 val* var1 /* : MapIterator[Object, nullable Object] */;
1754 val* var_i /* var i: MapIterator[Object, nullable Object] */;
1755 short int var2 /* : Bool */;
1756 val* var3 /* : Object */;
1757 val* var4 /* : nullable Object */;
1758 /* Covariant cast for argument 0 (map) <p0:Map[Object, nullable Object]> isa Map[Map#0, Map#1] */
1759 /* <p0:Map[Object, nullable Object]> isa Map[Map#0, Map#1] */
1760 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Mapabstract_collection__Map_FT0abstract_collection__Map_FT1];
1761 cltype = type_struct->color;
1762 idtype = type_struct->id;
1763 if(cltype >= p0->type->table_size) {
1764 var = 0;
1765 } else {
1766 var = p0->type->type_table[cltype] == idtype;
1767 }
1768 if (!var) {
1769 var_class_name = p0 == NULL ? "null" : p0->type->name;
1770 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Map[Map#0, Map#1]", var_class_name);
1771 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 341);
1772 exit(1);
1773 }
1774 var_map = p0;
1775 var1 = ((val* (*)(val*))(var_map->class->vft[COLOR_abstract_collection__MapRead__iterator]))(var_map) /* iterator on <var_map:Map[Object, nullable Object]>*/;
1776 var_i = var1;
1777 for(;;) {
1778 var2 = ((short int (*)(val*))(var_i->class->vft[COLOR_abstract_collection__MapIterator__is_ok]))(var_i) /* is_ok on <var_i:MapIterator[Object, nullable Object]>*/;
1779 if (!var2) break;
1780 var3 = ((val* (*)(val*))(var_i->class->vft[COLOR_abstract_collection__MapIterator__key]))(var_i) /* key on <var_i:MapIterator[Object, nullable Object]>*/;
1781 var4 = ((val* (*)(val*))(var_i->class->vft[COLOR_abstract_collection__MapIterator__item]))(var_i) /* item on <var_i:MapIterator[Object, nullable Object]>*/;
1782 ((void (*)(val*, val*, val*))(self->class->vft[COLOR_abstract_collection__Map___91d_93d_61d]))(self, var3, var4) /* []= on <self:Map[Object, nullable Object]>*/;
1783 ((void (*)(val*))(var_i->class->vft[COLOR_abstract_collection__MapIterator__next]))(var_i) /* next on <var_i:MapIterator[Object, nullable Object]>*/;
1784 CONTINUE_label: (void)0;
1785 }
1786 BREAK_label: (void)0;
1787 RET_LABEL:;
1788 }
1789 /* method abstract_collection#Map#recover_with for (self: Object, Map[Object, nullable Object]) */
1790 void VIRTUAL_abstract_collection__Map__recover_with(val* self, val* p0) {
1791 abstract_collection__Map__recover_with(self, p0);
1792 RET_LABEL:;
1793 }
1794 /* method abstract_collection#Map#clear for (self: Map[Object, nullable Object]) */
1795 void abstract_collection__Map__clear(val* self) {
1796 const char* var_class_name;
1797 var_class_name = self == NULL ? "null" : self->type->name;
1798 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "clear", var_class_name);
1799 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 352);
1800 exit(1);
1801 RET_LABEL:;
1802 }
1803 /* method abstract_collection#Map#clear for (self: Object) */
1804 void VIRTUAL_abstract_collection__Map__clear(val* self) {
1805 abstract_collection__Map__clear(self);
1806 RET_LABEL:;
1807 }
1808 /* method abstract_collection#Map#values for (self: Map[Object, nullable Object]): RemovableCollection[nullable Object] */
1809 val* abstract_collection__Map__values(val* self) {
1810 val* var /* : RemovableCollection[nullable Object] */;
1811 const char* var_class_name;
1812 var_class_name = self == NULL ? "null" : self->type->name;
1813 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "values", var_class_name);
1814 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 355);
1815 exit(1);
1816 RET_LABEL:;
1817 return var;
1818 }
1819 /* method abstract_collection#Map#values for (self: Object): Collection[nullable Object] */
1820 val* VIRTUAL_abstract_collection__Map__values(val* self) {
1821 val* var /* : Collection[nullable Object] */;
1822 val* var1 /* : RemovableCollection[nullable Object] */;
1823 var1 = abstract_collection__Map__values(self);
1824 var = var1;
1825 RET_LABEL:;
1826 return var;
1827 }
1828 /* method abstract_collection#Map#keys for (self: Map[Object, nullable Object]): RemovableCollection[Object] */
1829 val* abstract_collection__Map__keys(val* self) {
1830 val* var /* : RemovableCollection[Object] */;
1831 const char* var_class_name;
1832 var_class_name = self == NULL ? "null" : self->type->name;
1833 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "keys", var_class_name);
1834 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 357);
1835 exit(1);
1836 RET_LABEL:;
1837 return var;
1838 }
1839 /* method abstract_collection#Map#keys for (self: Object): Collection[Object] */
1840 val* VIRTUAL_abstract_collection__Map__keys(val* self) {
1841 val* var /* : Collection[Object] */;
1842 val* var1 /* : RemovableCollection[Object] */;
1843 var1 = abstract_collection__Map__keys(self);
1844 var = var1;
1845 RET_LABEL:;
1846 return var;
1847 }
1848 /* method abstract_collection#MapIterator#item for (self: MapIterator[Object, nullable Object]): nullable Object */
1849 val* abstract_collection__MapIterator__item(val* self) {
1850 val* var /* : nullable Object */;
1851 const char* var_class_name;
1852 var_class_name = self == NULL ? "null" : self->type->name;
1853 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "item", var_class_name);
1854 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 362);
1855 exit(1);
1856 RET_LABEL:;
1857 return var;
1858 }
1859 /* method abstract_collection#MapIterator#item for (self: Object): nullable Object */
1860 val* VIRTUAL_abstract_collection__MapIterator__item(val* self) {
1861 val* var /* : nullable Object */;
1862 val* var1 /* : nullable Object */;
1863 var1 = abstract_collection__MapIterator__item(self);
1864 var = var1;
1865 RET_LABEL:;
1866 return var;
1867 }
1868 /* method abstract_collection#MapIterator#key for (self: MapIterator[Object, nullable Object]): Object */
1869 val* abstract_collection__MapIterator__key(val* self) {
1870 val* var /* : Object */;
1871 const char* var_class_name;
1872 var_class_name = self == NULL ? "null" : self->type->name;
1873 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "key", var_class_name);
1874 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 366);
1875 exit(1);
1876 RET_LABEL:;
1877 return var;
1878 }
1879 /* method abstract_collection#MapIterator#key for (self: Object): Object */
1880 val* VIRTUAL_abstract_collection__MapIterator__key(val* self) {
1881 val* var /* : Object */;
1882 val* var1 /* : Object */;
1883 var1 = abstract_collection__MapIterator__key(self);
1884 var = var1;
1885 RET_LABEL:;
1886 return var;
1887 }
1888 /* method abstract_collection#MapIterator#next for (self: MapIterator[Object, nullable Object]) */
1889 void abstract_collection__MapIterator__next(val* self) {
1890 const char* var_class_name;
1891 var_class_name = self == NULL ? "null" : self->type->name;
1892 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "next", var_class_name);
1893 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 370);
1894 exit(1);
1895 RET_LABEL:;
1896 }
1897 /* method abstract_collection#MapIterator#next for (self: Object) */
1898 void VIRTUAL_abstract_collection__MapIterator__next(val* self) {
1899 abstract_collection__MapIterator__next(self);
1900 RET_LABEL:;
1901 }
1902 /* method abstract_collection#MapIterator#is_ok for (self: MapIterator[Object, nullable Object]): Bool */
1903 short int abstract_collection__MapIterator__is_ok(val* self) {
1904 short int var /* : Bool */;
1905 const char* var_class_name;
1906 var_class_name = self == NULL ? "null" : self->type->name;
1907 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "is_ok", var_class_name);
1908 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 374);
1909 exit(1);
1910 RET_LABEL:;
1911 return var;
1912 }
1913 /* method abstract_collection#MapIterator#is_ok for (self: Object): Bool */
1914 short int VIRTUAL_abstract_collection__MapIterator__is_ok(val* self) {
1915 short int var /* : Bool */;
1916 short int var1 /* : Bool */;
1917 var1 = abstract_collection__MapIterator__is_ok(self);
1918 var = var1;
1919 RET_LABEL:;
1920 return var;
1921 }
1922 /* method abstract_collection#MapKeysIterator#iterator for (self: MapKeysIterator[Object, nullable Object]): MapIterator[Object, nullable Object] */
1923 val* abstract_collection__MapKeysIterator__iterator(val* self) {
1924 val* var /* : MapIterator[Object, nullable Object] */;
1925 val* var1 /* : MapIterator[Object, nullable Object] */;
1926 var1 = self->attrs[COLOR_abstract_collection__MapKeysIterator___64diterator].val; /* @iterator on <self:MapKeysIterator[Object, nullable Object]> */
1927 if (var1 == NULL) {
1928 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @iterator");
1929 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 384);
1930 exit(1);
1931 }
1932 var = var1;
1933 RET_LABEL:;
1934 return var;
1935 }
1936 /* method abstract_collection#MapKeysIterator#iterator for (self: Object): MapIterator[Object, nullable Object] */
1937 val* VIRTUAL_abstract_collection__MapKeysIterator__iterator(val* self) {
1938 val* var /* : MapIterator[Object, nullable Object] */;
1939 val* var1 /* : MapIterator[Object, nullable Object] */;
1940 var1 = abstract_collection__MapKeysIterator__iterator(self);
1941 var = var1;
1942 RET_LABEL:;
1943 return var;
1944 }
1945 /* method abstract_collection#MapKeysIterator#iterator= for (self: MapKeysIterator[Object, nullable Object], MapIterator[Object, nullable Object]) */
1946 void abstract_collection__MapKeysIterator__iterator_61d(val* self, val* p0) {
1947 short int var /* : Bool */;
1948 int cltype;
1949 int idtype;
1950 const struct type* type_struct;
1951 const char* var_class_name;
1952 /* Covariant cast for argument 0 (iterator) <p0:MapIterator[Object, nullable Object]> isa MapIterator[MapKeysIterator#0, MapKeysIterator#1] */
1953 /* <p0:MapIterator[Object, nullable Object]> isa MapIterator[MapKeysIterator#0, MapKeysIterator#1] */
1954 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__MapIteratorabstract_collection__MapKeysIterator_FT0abstract_collection__MapKeysIterator_FT1];
1955 cltype = type_struct->color;
1956 idtype = type_struct->id;
1957 if(cltype >= p0->type->table_size) {
1958 var = 0;
1959 } else {
1960 var = p0->type->type_table[cltype] == idtype;
1961 }
1962 if (!var) {
1963 var_class_name = p0 == NULL ? "null" : p0->type->name;
1964 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapIterator[MapKeysIterator#0, MapKeysIterator#1]", var_class_name);
1965 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 384);
1966 exit(1);
1967 }
1968 self->attrs[COLOR_abstract_collection__MapKeysIterator___64diterator].val = p0; /* @iterator on <self:MapKeysIterator[Object, nullable Object]> */
1969 RET_LABEL:;
1970 }
1971 /* method abstract_collection#MapKeysIterator#iterator= for (self: Object, MapIterator[Object, nullable Object]) */
1972 void VIRTUAL_abstract_collection__MapKeysIterator__iterator_61d(val* self, val* p0) {
1973 abstract_collection__MapKeysIterator__iterator_61d(self, p0);
1974 RET_LABEL:;
1975 }
1976 /* method abstract_collection#MapKeysIterator#is_ok for (self: MapKeysIterator[Object, nullable Object]): Bool */
1977 short int abstract_collection__MapKeysIterator__is_ok(val* self) {
1978 short int var /* : Bool */;
1979 val* var1 /* : MapIterator[Object, nullable Object] */;
1980 short int var2 /* : Bool */;
1981 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__MapKeysIterator__iterator]))(self) /* iterator on <self:MapKeysIterator[Object, nullable Object]>*/;
1982 var2 = ((short int (*)(val*))(var1->class->vft[COLOR_abstract_collection__MapIterator__is_ok]))(var1) /* is_ok on <var1:MapIterator[Object, nullable Object]>*/;
1983 var = var2;
1984 goto RET_LABEL;
1985 RET_LABEL:;
1986 return var;
1987 }
1988 /* method abstract_collection#MapKeysIterator#is_ok for (self: Object): Bool */
1989 short int VIRTUAL_abstract_collection__MapKeysIterator__is_ok(val* self) {
1990 short int var /* : Bool */;
1991 short int var1 /* : Bool */;
1992 var1 = abstract_collection__MapKeysIterator__is_ok(self);
1993 var = var1;
1994 RET_LABEL:;
1995 return var;
1996 }
1997 /* method abstract_collection#MapKeysIterator#next for (self: MapKeysIterator[Object, nullable Object]) */
1998 void abstract_collection__MapKeysIterator__next(val* self) {
1999 val* var /* : MapIterator[Object, nullable Object] */;
2000 var = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__MapKeysIterator__iterator]))(self) /* iterator on <self:MapKeysIterator[Object, nullable Object]>*/;
2001 ((void (*)(val*))(var->class->vft[COLOR_abstract_collection__MapIterator__next]))(var) /* next on <var:MapIterator[Object, nullable Object]>*/;
2002 RET_LABEL:;
2003 }
2004 /* method abstract_collection#MapKeysIterator#next for (self: Object) */
2005 void VIRTUAL_abstract_collection__MapKeysIterator__next(val* self) {
2006 abstract_collection__MapKeysIterator__next(self);
2007 RET_LABEL:;
2008 }
2009 /* method abstract_collection#MapKeysIterator#item for (self: MapKeysIterator[Object, nullable Object]): Object */
2010 val* abstract_collection__MapKeysIterator__item(val* self) {
2011 val* var /* : Object */;
2012 val* var1 /* : MapIterator[Object, nullable Object] */;
2013 val* var2 /* : Object */;
2014 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__MapKeysIterator__iterator]))(self) /* iterator on <self:MapKeysIterator[Object, nullable Object]>*/;
2015 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_abstract_collection__MapIterator__key]))(var1) /* key on <var1:MapIterator[Object, nullable Object]>*/;
2016 var = var2;
2017 goto RET_LABEL;
2018 RET_LABEL:;
2019 return var;
2020 }
2021 /* method abstract_collection#MapKeysIterator#item for (self: Object): nullable Object */
2022 val* VIRTUAL_abstract_collection__MapKeysIterator__item(val* self) {
2023 val* var /* : nullable Object */;
2024 val* var1 /* : Object */;
2025 var1 = abstract_collection__MapKeysIterator__item(self);
2026 var = var1;
2027 RET_LABEL:;
2028 return var;
2029 }
2030 /* method abstract_collection#MapKeysIterator#init for (self: MapKeysIterator[Object, nullable Object], MapIterator[Object, nullable Object]) */
2031 void abstract_collection__MapKeysIterator__init(val* self, val* p0) {
2032 short int var /* : Bool */;
2033 int cltype;
2034 int idtype;
2035 const struct type* type_struct;
2036 const char* var_class_name;
2037 /* Covariant cast for argument 0 (iterator) <p0:MapIterator[Object, nullable Object]> isa MapIterator[MapKeysIterator#0, MapKeysIterator#1] */
2038 /* <p0:MapIterator[Object, nullable Object]> isa MapIterator[MapKeysIterator#0, MapKeysIterator#1] */
2039 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__MapIteratorabstract_collection__MapKeysIterator_FT0abstract_collection__MapKeysIterator_FT1];
2040 cltype = type_struct->color;
2041 idtype = type_struct->id;
2042 if(cltype >= p0->type->table_size) {
2043 var = 0;
2044 } else {
2045 var = p0->type->type_table[cltype] == idtype;
2046 }
2047 if (!var) {
2048 var_class_name = p0 == NULL ? "null" : p0->type->name;
2049 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapIterator[MapKeysIterator#0, MapKeysIterator#1]", var_class_name);
2050 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 381);
2051 exit(1);
2052 }
2053 self->attrs[COLOR_abstract_collection__MapKeysIterator___64diterator].val = p0; /* @iterator on <self:MapKeysIterator[Object, nullable Object]> */
2054 RET_LABEL:;
2055 }
2056 /* method abstract_collection#MapKeysIterator#init for (self: Object, MapIterator[Object, nullable Object]) */
2057 void VIRTUAL_abstract_collection__MapKeysIterator__init(val* self, val* p0) {
2058 abstract_collection__MapKeysIterator__init(self, p0);
2059 RET_LABEL:;
2060 }
2061 /* method abstract_collection#MapValuesIterator#iterator for (self: MapValuesIterator[Object, nullable Object]): MapIterator[Object, nullable Object] */
2062 val* abstract_collection__MapValuesIterator__iterator(val* self) {
2063 val* var /* : MapIterator[Object, nullable Object] */;
2064 val* var1 /* : MapIterator[Object, nullable Object] */;
2065 var1 = self->attrs[COLOR_abstract_collection__MapValuesIterator___64diterator].val; /* @iterator on <self:MapValuesIterator[Object, nullable Object]> */
2066 if (var1 == NULL) {
2067 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @iterator");
2068 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 395);
2069 exit(1);
2070 }
2071 var = var1;
2072 RET_LABEL:;
2073 return var;
2074 }
2075 /* method abstract_collection#MapValuesIterator#iterator for (self: Object): MapIterator[Object, nullable Object] */
2076 val* VIRTUAL_abstract_collection__MapValuesIterator__iterator(val* self) {
2077 val* var /* : MapIterator[Object, nullable Object] */;
2078 val* var1 /* : MapIterator[Object, nullable Object] */;
2079 var1 = abstract_collection__MapValuesIterator__iterator(self);
2080 var = var1;
2081 RET_LABEL:;
2082 return var;
2083 }
2084 /* method abstract_collection#MapValuesIterator#iterator= for (self: MapValuesIterator[Object, nullable Object], MapIterator[Object, nullable Object]) */
2085 void abstract_collection__MapValuesIterator__iterator_61d(val* self, val* p0) {
2086 short int var /* : Bool */;
2087 int cltype;
2088 int idtype;
2089 const struct type* type_struct;
2090 const char* var_class_name;
2091 /* Covariant cast for argument 0 (iterator) <p0:MapIterator[Object, nullable Object]> isa MapIterator[MapValuesIterator#0, MapValuesIterator#1] */
2092 /* <p0:MapIterator[Object, nullable Object]> isa MapIterator[MapValuesIterator#0, MapValuesIterator#1] */
2093 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__MapIteratorabstract_collection__MapValuesIterator_FT0abstract_collection__MapValuesIterator_FT1];
2094 cltype = type_struct->color;
2095 idtype = type_struct->id;
2096 if(cltype >= p0->type->table_size) {
2097 var = 0;
2098 } else {
2099 var = p0->type->type_table[cltype] == idtype;
2100 }
2101 if (!var) {
2102 var_class_name = p0 == NULL ? "null" : p0->type->name;
2103 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapIterator[MapValuesIterator#0, MapValuesIterator#1]", var_class_name);
2104 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 395);
2105 exit(1);
2106 }
2107 self->attrs[COLOR_abstract_collection__MapValuesIterator___64diterator].val = p0; /* @iterator on <self:MapValuesIterator[Object, nullable Object]> */
2108 RET_LABEL:;
2109 }
2110 /* method abstract_collection#MapValuesIterator#iterator= for (self: Object, MapIterator[Object, nullable Object]) */
2111 void VIRTUAL_abstract_collection__MapValuesIterator__iterator_61d(val* self, val* p0) {
2112 abstract_collection__MapValuesIterator__iterator_61d(self, p0);
2113 RET_LABEL:;
2114 }
2115 /* method abstract_collection#MapValuesIterator#is_ok for (self: MapValuesIterator[Object, nullable Object]): Bool */
2116 short int abstract_collection__MapValuesIterator__is_ok(val* self) {
2117 short int var /* : Bool */;
2118 val* var1 /* : MapIterator[Object, nullable Object] */;
2119 short int var2 /* : Bool */;
2120 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__MapValuesIterator__iterator]))(self) /* iterator on <self:MapValuesIterator[Object, nullable Object]>*/;
2121 var2 = ((short int (*)(val*))(var1->class->vft[COLOR_abstract_collection__MapIterator__is_ok]))(var1) /* is_ok on <var1:MapIterator[Object, nullable Object]>*/;
2122 var = var2;
2123 goto RET_LABEL;
2124 RET_LABEL:;
2125 return var;
2126 }
2127 /* method abstract_collection#MapValuesIterator#is_ok for (self: Object): Bool */
2128 short int VIRTUAL_abstract_collection__MapValuesIterator__is_ok(val* self) {
2129 short int var /* : Bool */;
2130 short int var1 /* : Bool */;
2131 var1 = abstract_collection__MapValuesIterator__is_ok(self);
2132 var = var1;
2133 RET_LABEL:;
2134 return var;
2135 }
2136 /* method abstract_collection#MapValuesIterator#next for (self: MapValuesIterator[Object, nullable Object]) */
2137 void abstract_collection__MapValuesIterator__next(val* self) {
2138 val* var /* : MapIterator[Object, nullable Object] */;
2139 var = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__MapValuesIterator__iterator]))(self) /* iterator on <self:MapValuesIterator[Object, nullable Object]>*/;
2140 ((void (*)(val*))(var->class->vft[COLOR_abstract_collection__MapIterator__next]))(var) /* next on <var:MapIterator[Object, nullable Object]>*/;
2141 RET_LABEL:;
2142 }
2143 /* method abstract_collection#MapValuesIterator#next for (self: Object) */
2144 void VIRTUAL_abstract_collection__MapValuesIterator__next(val* self) {
2145 abstract_collection__MapValuesIterator__next(self);
2146 RET_LABEL:;
2147 }
2148 /* method abstract_collection#MapValuesIterator#item for (self: MapValuesIterator[Object, nullable Object]): nullable Object */
2149 val* abstract_collection__MapValuesIterator__item(val* self) {
2150 val* var /* : nullable Object */;
2151 val* var1 /* : MapIterator[Object, nullable Object] */;
2152 val* var2 /* : nullable Object */;
2153 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__MapValuesIterator__iterator]))(self) /* iterator on <self:MapValuesIterator[Object, nullable Object]>*/;
2154 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_abstract_collection__MapIterator__item]))(var1) /* item on <var1:MapIterator[Object, nullable Object]>*/;
2155 var = var2;
2156 goto RET_LABEL;
2157 RET_LABEL:;
2158 return var;
2159 }
2160 /* method abstract_collection#MapValuesIterator#item for (self: Object): nullable Object */
2161 val* VIRTUAL_abstract_collection__MapValuesIterator__item(val* self) {
2162 val* var /* : nullable Object */;
2163 val* var1 /* : nullable Object */;
2164 var1 = abstract_collection__MapValuesIterator__item(self);
2165 var = var1;
2166 RET_LABEL:;
2167 return var;
2168 }
2169 /* method abstract_collection#MapValuesIterator#init for (self: MapValuesIterator[Object, nullable Object], MapIterator[Object, nullable Object]) */
2170 void abstract_collection__MapValuesIterator__init(val* self, val* p0) {
2171 short int var /* : Bool */;
2172 int cltype;
2173 int idtype;
2174 const struct type* type_struct;
2175 const char* var_class_name;
2176 /* Covariant cast for argument 0 (iterator) <p0:MapIterator[Object, nullable Object]> isa MapIterator[MapValuesIterator#0, MapValuesIterator#1] */
2177 /* <p0:MapIterator[Object, nullable Object]> isa MapIterator[MapValuesIterator#0, MapValuesIterator#1] */
2178 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__MapIteratorabstract_collection__MapValuesIterator_FT0abstract_collection__MapValuesIterator_FT1];
2179 cltype = type_struct->color;
2180 idtype = type_struct->id;
2181 if(cltype >= p0->type->table_size) {
2182 var = 0;
2183 } else {
2184 var = p0->type->type_table[cltype] == idtype;
2185 }
2186 if (!var) {
2187 var_class_name = p0 == NULL ? "null" : p0->type->name;
2188 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapIterator[MapValuesIterator#0, MapValuesIterator#1]", var_class_name);
2189 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 392);
2190 exit(1);
2191 }
2192 self->attrs[COLOR_abstract_collection__MapValuesIterator___64diterator].val = p0; /* @iterator on <self:MapValuesIterator[Object, nullable Object]> */
2193 RET_LABEL:;
2194 }
2195 /* method abstract_collection#MapValuesIterator#init for (self: Object, MapIterator[Object, nullable Object]) */
2196 void VIRTUAL_abstract_collection__MapValuesIterator__init(val* self, val* p0) {
2197 abstract_collection__MapValuesIterator__init(self, p0);
2198 RET_LABEL:;
2199 }
2200 /* method abstract_collection#SequenceRead#first for (self: SequenceRead[nullable Object]): nullable Object */
2201 val* abstract_collection__SequenceRead__first(val* self) {
2202 val* var /* : nullable Object */;
2203 short int var1 /* : Bool */;
2204 short int var2 /* : Bool */;
2205 long var3 /* : Int */;
2206 val* var4 /* : nullable Object */;
2207 var1 = ((short int (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__is_empty]))(self) /* is_empty on <self:SequenceRead[nullable Object]>*/;
2208 var2 = !var1;
2209 if (!var2) {
2210 fprintf(stderr, "Runtime error: %s", "Assert \'not_empty\' failed");
2211 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 411);
2212 exit(1);
2213 }
2214 var3 = 0;
2215 var4 = ((val* (*)(val*, long))(self->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(self, var3) /* [] on <self:SequenceRead[nullable Object]>*/;
2216 var = var4;
2217 goto RET_LABEL;
2218 RET_LABEL:;
2219 return var;
2220 }
2221 /* method abstract_collection#SequenceRead#first for (self: Object): nullable Object */
2222 val* VIRTUAL_abstract_collection__SequenceRead__first(val* self) {
2223 val* var /* : nullable Object */;
2224 val* var1 /* : nullable Object */;
2225 var1 = abstract_collection__SequenceRead__first(self);
2226 var = var1;
2227 RET_LABEL:;
2228 return var;
2229 }
2230 /* method abstract_collection#SequenceRead#[] for (self: SequenceRead[nullable Object], Int): nullable Object */
2231 val* abstract_collection__SequenceRead___91d_93d(val* self, long p0) {
2232 val* var /* : nullable Object */;
2233 const char* var_class_name;
2234 var_class_name = self == NULL ? "null" : self->type->name;
2235 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "[]", var_class_name);
2236 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 415);
2237 exit(1);
2238 RET_LABEL:;
2239 return var;
2240 }
2241 /* method abstract_collection#SequenceRead#[] for (self: Object, Int): nullable Object */
2242 val* VIRTUAL_abstract_collection__SequenceRead___91d_93d(val* self, long p0) {
2243 val* var /* : nullable Object */;
2244 val* var1 /* : nullable Object */;
2245 var1 = abstract_collection__SequenceRead___91d_93d(self, p0);
2246 var = var1;
2247 RET_LABEL:;
2248 return var;
2249 }
2250 /* method abstract_collection#SequenceRead#last for (self: SequenceRead[nullable Object]): nullable Object */
2251 val* abstract_collection__SequenceRead__last(val* self) {
2252 val* var /* : nullable Object */;
2253 short int var1 /* : Bool */;
2254 short int var2 /* : Bool */;
2255 long var3 /* : Int */;
2256 long var4 /* : Int */;
2257 long var5 /* : Int */;
2258 long var7 /* : Int */;
2259 val* var8 /* : nullable Object */;
2260 var1 = ((short int (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__is_empty]))(self) /* is_empty on <self:SequenceRead[nullable Object]>*/;
2261 var2 = !var1;
2262 if (!var2) {
2263 fprintf(stderr, "Runtime error: %s", "Assert \'not_empty\' failed");
2264 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 424);
2265 exit(1);
2266 }
2267 var3 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:SequenceRead[nullable Object]>*/;
2268 var4 = 1;
2269 { /* Inline kernel#Int#- (var3,var4) */
2270 var7 = var3 - var4;
2271 var5 = var7;
2272 goto RET_LABEL6;
2273 RET_LABEL6:(void)0;
2274 }
2275 var8 = ((val* (*)(val*, long))(self->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(self, var5) /* [] on <self:SequenceRead[nullable Object]>*/;
2276 var = var8;
2277 goto RET_LABEL;
2278 RET_LABEL:;
2279 return var;
2280 }
2281 /* method abstract_collection#SequenceRead#last for (self: Object): nullable Object */
2282 val* VIRTUAL_abstract_collection__SequenceRead__last(val* self) {
2283 val* var /* : nullable Object */;
2284 val* var1 /* : nullable Object */;
2285 var1 = abstract_collection__SequenceRead__last(self);
2286 var = var1;
2287 RET_LABEL:;
2288 return var;
2289 }
2290 /* method abstract_collection#SequenceRead#index_of for (self: SequenceRead[nullable Object], nullable Object): Int */
2291 long abstract_collection__SequenceRead__index_of(val* self, val* p0) {
2292 long var /* : Int */;
2293 short int var1 /* : Bool */;
2294 int cltype;
2295 int idtype;
2296 const struct type* type_struct;
2297 short int is_nullable;
2298 const char* var_class_name;
2299 val* var_item /* var item: nullable Object */;
2300 val* var2 /* : Iterator[nullable Object] */;
2301 val* var_i /* var i: IndexedIterator[nullable Object] */;
2302 short int var3 /* : Bool */;
2303 val* var4 /* : nullable Object */;
2304 short int var5 /* : Bool */;
2305 long var6 /* : Int */;
2306 long var7 /* : Int */;
2307 long var8 /* : Int */;
2308 long var10 /* : Int */;
2309 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa SequenceRead#0 */
2310 /* <p0:nullable Object> isa SequenceRead#0 */
2311 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__SequenceRead_FT0];
2312 cltype = type_struct->color;
2313 idtype = type_struct->id;
2314 is_nullable = type_struct->is_nullable;
2315 if(p0 == NULL) {
2316 var1 = is_nullable;
2317 } else {
2318 if(cltype >= p0->type->table_size) {
2319 var1 = 0;
2320 } else {
2321 var1 = p0->type->type_table[cltype] == idtype;
2322 }
2323 }
2324 if (!var1) {
2325 var_class_name = p0 == NULL ? "null" : p0->type->name;
2326 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "SequenceRead#0", var_class_name);
2327 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 428);
2328 exit(1);
2329 }
2330 var_item = p0;
2331 var2 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__iterator]))(self) /* iterator on <self:SequenceRead[nullable Object]>*/;
2332 var_i = var2;
2333 for(;;) {
2334 var3 = ((short int (*)(val*))(var_i->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var_i) /* is_ok on <var_i:IndexedIterator[nullable Object]>*/;
2335 if (!var3) break;
2336 var4 = ((val* (*)(val*))(var_i->class->vft[COLOR_abstract_collection__Iterator__item]))(var_i) /* item on <var_i:IndexedIterator[nullable Object]>*/;
2337 if (var4 == NULL) {
2338 var5 = (var_item == NULL);
2339 } else {
2340 var5 = ((short int (*)(val*, val*))(var4->class->vft[COLOR_kernel__Object___61d_61d]))(var4, var_item) /* == on <var4:nullable Object>*/;
2341 }
2342 if (var5){
2343 var6 = ((long (*)(val*))(var_i->class->vft[COLOR_abstract_collection__IndexedIterator__index]))(var_i) /* index on <var_i:IndexedIterator[nullable Object]>*/;
2344 var = var6;
2345 goto RET_LABEL;
2346 } else {
2347 }
2348 ((void (*)(val*))(var_i->class->vft[COLOR_abstract_collection__Iterator__next]))(var_i) /* next on <var_i:IndexedIterator[nullable Object]>*/;
2349 CONTINUE_label: (void)0;
2350 }
2351 BREAK_label: (void)0;
2352 var7 = 1;
2353 { /* Inline kernel#Int#unary - (var7) */
2354 var10 = -var7;
2355 var8 = var10;
2356 goto RET_LABEL9;
2357 RET_LABEL9:(void)0;
2358 }
2359 var = var8;
2360 goto RET_LABEL;
2361 RET_LABEL:;
2362 return var;
2363 }
2364 /* method abstract_collection#SequenceRead#index_of for (self: Object, nullable Object): Int */
2365 long VIRTUAL_abstract_collection__SequenceRead__index_of(val* self, val* p0) {
2366 long var /* : Int */;
2367 long var1 /* : Int */;
2368 var1 = abstract_collection__SequenceRead__index_of(self, p0);
2369 var = var1;
2370 RET_LABEL:;
2371 return var;
2372 }
2373 /* method abstract_collection#SequenceRead#iterator for (self: SequenceRead[nullable Object]): IndexedIterator[nullable Object] */
2374 val* abstract_collection__SequenceRead__iterator(val* self) {
2375 val* var /* : IndexedIterator[nullable Object] */;
2376 const char* var_class_name;
2377 var_class_name = self == NULL ? "null" : self->type->name;
2378 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "iterator", var_class_name);
2379 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 441);
2380 exit(1);
2381 RET_LABEL:;
2382 return var;
2383 }
2384 /* method abstract_collection#SequenceRead#iterator for (self: Object): Iterator[nullable Object] */
2385 val* VIRTUAL_abstract_collection__SequenceRead__iterator(val* self) {
2386 val* var /* : Iterator[nullable Object] */;
2387 val* var1 /* : IndexedIterator[nullable Object] */;
2388 var1 = abstract_collection__SequenceRead__iterator(self);
2389 var = var1;
2390 RET_LABEL:;
2391 return var;
2392 }
2393 /* method abstract_collection#SequenceRead#== for (self: SequenceRead[nullable Object], nullable Object): Bool */
2394 short int abstract_collection__SequenceRead___61d_61d(val* self, val* p0) {
2395 short int var /* : Bool */;
2396 val* var_o /* var o: nullable Object */;
2397 short int var1 /* : Bool */;
2398 int cltype;
2399 int idtype;
2400 short int var2 /* : Bool */;
2401 short int var3 /* : Bool */;
2402 long var4 /* : Int */;
2403 long var_l /* var l: Int */;
2404 long var5 /* : Int */;
2405 short int var6 /* : Bool */;
2406 short int var8 /* : Bool */;
2407 short int var9 /* : Bool */;
2408 short int var10 /* : Bool */;
2409 long var11 /* : Int */;
2410 long var_i /* var i: Int */;
2411 short int var12 /* : Bool */;
2412 short int var14 /* : Bool */;
2413 int cltype15;
2414 int idtype16;
2415 const char* var_class_name;
2416 short int var17 /* : Bool */;
2417 val* var18 /* : nullable Object */;
2418 val* var19 /* : nullable Object */;
2419 short int var20 /* : Bool */;
2420 short int var21 /* : Bool */;
2421 long var22 /* : Int */;
2422 long var23 /* : Int */;
2423 long var25 /* : Int */;
2424 short int var26 /* : Bool */;
2425 var_o = p0;
2426 /* <var_o:nullable Object> isa SequenceRead[nullable Object] */
2427 cltype = type_abstract_collection__SequenceReadnullable_kernel__Object.color;
2428 idtype = type_abstract_collection__SequenceReadnullable_kernel__Object.id;
2429 if(var_o == NULL) {
2430 var1 = 0;
2431 } else {
2432 if(cltype >= var_o->type->table_size) {
2433 var1 = 0;
2434 } else {
2435 var1 = var_o->type->type_table[cltype] == idtype;
2436 }
2437 }
2438 var2 = !var1;
2439 if (var2){
2440 var3 = 0;
2441 var = var3;
2442 goto RET_LABEL;
2443 } else {
2444 }
2445 var4 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:SequenceRead[nullable Object]>*/;
2446 var_l = var4;
2447 var5 = ((long (*)(val*))(var_o->class->vft[COLOR_abstract_collection__Collection__length]))(var_o) /* length on <var_o:nullable Object(SequenceRead[nullable Object])>*/;
2448 { /* Inline kernel#Int#!= (var5,var_l) */
2449 var8 = var5 == var_l;
2450 var9 = !var8;
2451 var6 = var9;
2452 goto RET_LABEL7;
2453 RET_LABEL7:(void)0;
2454 }
2455 if (var6){
2456 var10 = 0;
2457 var = var10;
2458 goto RET_LABEL;
2459 } else {
2460 }
2461 var11 = 0;
2462 var_i = var11;
2463 for(;;) {
2464 { /* Inline kernel#Int#< (var_i,var_l) */
2465 /* Covariant cast for argument 0 (i) <var_l:Int> isa OTHER */
2466 /* <var_l:Int> isa OTHER */
2467 var14 = 1; /* easy <var_l:Int> isa OTHER*/
2468 if (!var14) {
2469 var_class_name = type_kernel__Int.name;
2470 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
2471 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 261);
2472 exit(1);
2473 }
2474 var17 = var_i < var_l;
2475 var12 = var17;
2476 goto RET_LABEL13;
2477 RET_LABEL13:(void)0;
2478 }
2479 if (!var12) break;
2480 var18 = ((val* (*)(val*, long))(self->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(self, var_i) /* [] on <self:SequenceRead[nullable Object]>*/;
2481 var19 = ((val* (*)(val*, long))(var_o->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(var_o, var_i) /* [] on <var_o:nullable Object(SequenceRead[nullable Object])>*/;
2482 if (var18 == NULL) {
2483 var20 = (var19 != NULL);
2484 } else {
2485 var20 = ((short int (*)(val*, val*))(var18->class->vft[COLOR_kernel__Object___33d_61d]))(var18, var19) /* != on <var18:nullable Object>*/;
2486 }
2487 if (var20){
2488 var21 = 0;
2489 var = var21;
2490 goto RET_LABEL;
2491 } else {
2492 }
2493 var22 = 1;
2494 { /* Inline kernel#Int#+ (var_i,var22) */
2495 var25 = var_i + var22;
2496 var23 = var25;
2497 goto RET_LABEL24;
2498 RET_LABEL24:(void)0;
2499 }
2500 var_i = var23;
2501 CONTINUE_label: (void)0;
2502 }
2503 BREAK_label: (void)0;
2504 var26 = 1;
2505 var = var26;
2506 goto RET_LABEL;
2507 RET_LABEL:;
2508 return var;
2509 }
2510 /* method abstract_collection#SequenceRead#== for (self: Object, nullable Object): Bool */
2511 short int VIRTUAL_abstract_collection__SequenceRead___61d_61d(val* self, val* p0) {
2512 short int var /* : Bool */;
2513 short int var1 /* : Bool */;
2514 var1 = abstract_collection__SequenceRead___61d_61d(self, p0);
2515 var = var1;
2516 RET_LABEL:;
2517 return var;
2518 }
2519 /* method abstract_collection#SequenceRead#hash for (self: SequenceRead[nullable Object]): Int */
2520 long abstract_collection__SequenceRead__hash(val* self) {
2521 long var /* : Int */;
2522 long var1 /* : Int */;
2523 long var_res /* var res: Int */;
2524 val* var2 /* : Iterator[nullable Object] */;
2525 short int var3 /* : Bool */;
2526 val* var4 /* : nullable Object */;
2527 val* var_e /* var e: nullable Object */;
2528 long var5 /* : Int */;
2529 long var6 /* : Int */;
2530 long var8 /* : Int */;
2531 var1 = 0;
2532 var_res = var1;
2533 var2 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__iterator]))(self) /* iterator on <self:SequenceRead[nullable Object]>*/;
2534 for(;;) {
2535 var3 = ((short int (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var2) /* is_ok on <var2:Iterator[nullable Object]>*/;
2536 if(!var3) break;
2537 var4 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__item]))(var2) /* item on <var2:Iterator[nullable Object]>*/;
2538 var_e = var4;
2539 var5 = kernel__Int__hash(var_res);
2540 { /* Inline kernel#Int#+ (var_res,var5) */
2541 var8 = var_res + var5;
2542 var6 = var8;
2543 goto RET_LABEL7;
2544 RET_LABEL7:(void)0;
2545 }
2546 var_res = var6;
2547 CONTINUE_label: (void)0;
2548 ((void (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__next]))(var2) /* next on <var2:Iterator[nullable Object]>*/;
2549 }
2550 BREAK_label: (void)0;
2551 var = var_res;
2552 goto RET_LABEL;
2553 RET_LABEL:;
2554 return var;
2555 }
2556 /* method abstract_collection#SequenceRead#hash for (self: Object): Int */
2557 long VIRTUAL_abstract_collection__SequenceRead__hash(val* self) {
2558 long var /* : Int */;
2559 long var1 /* : Int */;
2560 var1 = abstract_collection__SequenceRead__hash(self);
2561 var = var1;
2562 RET_LABEL:;
2563 return var;
2564 }
2565 /* method abstract_collection#Sequence#first= for (self: Sequence[nullable Object], nullable Object) */
2566 void abstract_collection__Sequence__first_61d(val* self, val* p0) {
2567 short int var /* : Bool */;
2568 int cltype;
2569 int idtype;
2570 const struct type* type_struct;
2571 short int is_nullable;
2572 const char* var_class_name;
2573 val* var_item /* var item: nullable Object */;
2574 long var1 /* : Int */;
2575 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa Sequence#0 */
2576 /* <p0:nullable Object> isa Sequence#0 */
2577 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Sequence_FT0];
2578 cltype = type_struct->color;
2579 idtype = type_struct->id;
2580 is_nullable = type_struct->is_nullable;
2581 if(p0 == NULL) {
2582 var = is_nullable;
2583 } else {
2584 if(cltype >= p0->type->table_size) {
2585 var = 0;
2586 } else {
2587 var = p0->type->type_table[cltype] == idtype;
2588 }
2589 }
2590 if (!var) {
2591 var_class_name = p0 == NULL ? "null" : p0->type->name;
2592 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Sequence#0", var_class_name);
2593 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 472);
2594 exit(1);
2595 }
2596 var_item = p0;
2597 var1 = 0;
2598 ((void (*)(val*, long, val*))(self->class->vft[COLOR_abstract_collection__Sequence___91d_93d_61d]))(self, var1, var_item) /* []= on <self:Sequence[nullable Object]>*/;
2599 RET_LABEL:;
2600 }
2601 /* method abstract_collection#Sequence#first= for (self: Object, nullable Object) */
2602 void VIRTUAL_abstract_collection__Sequence__first_61d(val* self, val* p0) {
2603 abstract_collection__Sequence__first_61d(self, p0);
2604 RET_LABEL:;
2605 }
2606 /* method abstract_collection#Sequence#last= for (self: Sequence[nullable Object], nullable Object) */
2607 void abstract_collection__Sequence__last_61d(val* self, val* p0) {
2608 short int var /* : Bool */;
2609 int cltype;
2610 int idtype;
2611 const struct type* type_struct;
2612 short int is_nullable;
2613 const char* var_class_name;
2614 val* var_item /* var item: nullable Object */;
2615 long var1 /* : Int */;
2616 long var_l /* var l: Int */;
2617 long var2 /* : Int */;
2618 short int var3 /* : Bool */;
2619 short int var5 /* : Bool */;
2620 int cltype6;
2621 int idtype7;
2622 const char* var_class_name8;
2623 short int var9 /* : Bool */;
2624 long var10 /* : Int */;
2625 long var11 /* : Int */;
2626 long var13 /* : Int */;
2627 long var14 /* : Int */;
2628 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa Sequence#0 */
2629 /* <p0:nullable Object> isa Sequence#0 */
2630 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Sequence_FT0];
2631 cltype = type_struct->color;
2632 idtype = type_struct->id;
2633 is_nullable = type_struct->is_nullable;
2634 if(p0 == NULL) {
2635 var = is_nullable;
2636 } else {
2637 if(cltype >= p0->type->table_size) {
2638 var = 0;
2639 } else {
2640 var = p0->type->type_table[cltype] == idtype;
2641 }
2642 }
2643 if (!var) {
2644 var_class_name = p0 == NULL ? "null" : p0->type->name;
2645 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Sequence#0", var_class_name);
2646 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 477);
2647 exit(1);
2648 }
2649 var_item = p0;
2650 var1 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:Sequence[nullable Object]>*/;
2651 var_l = var1;
2652 var2 = 0;
2653 { /* Inline kernel#Int#> (var_l,var2) */
2654 /* Covariant cast for argument 0 (i) <var2:Int> isa OTHER */
2655 /* <var2:Int> isa OTHER */
2656 var5 = 1; /* easy <var2:Int> isa OTHER*/
2657 if (!var5) {
2658 var_class_name8 = type_kernel__Int.name;
2659 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name8);
2660 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 263);
2661 exit(1);
2662 }
2663 var9 = var_l > var2;
2664 var3 = var9;
2665 goto RET_LABEL4;
2666 RET_LABEL4:(void)0;
2667 }
2668 if (var3){
2669 var10 = 1;
2670 { /* Inline kernel#Int#- (var_l,var10) */
2671 var13 = var_l - var10;
2672 var11 = var13;
2673 goto RET_LABEL12;
2674 RET_LABEL12:(void)0;
2675 }
2676 ((void (*)(val*, long, val*))(self->class->vft[COLOR_abstract_collection__Sequence___91d_93d_61d]))(self, var11, var_item) /* []= on <self:Sequence[nullable Object]>*/;
2677 } else {
2678 var14 = 0;
2679 ((void (*)(val*, long, val*))(self->class->vft[COLOR_abstract_collection__Sequence___91d_93d_61d]))(self, var14, var_item) /* []= on <self:Sequence[nullable Object]>*/;
2680 }
2681 RET_LABEL:;
2682 }
2683 /* method abstract_collection#Sequence#last= for (self: Object, nullable Object) */
2684 void VIRTUAL_abstract_collection__Sequence__last_61d(val* self, val* p0) {
2685 abstract_collection__Sequence__last_61d(self, p0);
2686 RET_LABEL:;
2687 }
2688 /* method abstract_collection#Sequence#add for (self: Sequence[nullable Object], nullable Object) */
2689 void abstract_collection__Sequence__add(val* self, val* p0) {
2690 short int var /* : Bool */;
2691 int cltype;
2692 int idtype;
2693 const struct type* type_struct;
2694 short int is_nullable;
2695 const char* var_class_name;
2696 val* var_e /* var e: nullable Object */;
2697 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa SimpleCollection#0 */
2698 /* <p0:nullable Object> isa SimpleCollection#0 */
2699 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__SimpleCollection_FT0];
2700 cltype = type_struct->color;
2701 idtype = type_struct->id;
2702 is_nullable = type_struct->is_nullable;
2703 if(p0 == NULL) {
2704 var = is_nullable;
2705 } else {
2706 if(cltype >= p0->type->table_size) {
2707 var = 0;
2708 } else {
2709 var = p0->type->type_table[cltype] == idtype;
2710 }
2711 }
2712 if (!var) {
2713 var_class_name = p0 == NULL ? "null" : p0->type->name;
2714 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "SimpleCollection#0", var_class_name);
2715 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 489);
2716 exit(1);
2717 }
2718 var_e = p0;
2719 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__Sequence__push]))(self, var_e) /* push on <self:Sequence[nullable Object]>*/;
2720 RET_LABEL:;
2721 }
2722 /* method abstract_collection#Sequence#add for (self: Object, nullable Object) */
2723 void VIRTUAL_abstract_collection__Sequence__add(val* self, val* p0) {
2724 abstract_collection__Sequence__add(self, p0);
2725 RET_LABEL:;
2726 }
2727 /* method abstract_collection#Sequence#push for (self: Sequence[nullable Object], nullable Object) */
2728 void abstract_collection__Sequence__push(val* self, val* p0) {
2729 short int var /* : Bool */;
2730 int cltype;
2731 int idtype;
2732 const struct type* type_struct;
2733 short int is_nullable;
2734 const char* var_class_name;
2735 const char* var_class_name1;
2736 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa Sequence#0 */
2737 /* <p0:nullable Object> isa Sequence#0 */
2738 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Sequence_FT0];
2739 cltype = type_struct->color;
2740 idtype = type_struct->id;
2741 is_nullable = type_struct->is_nullable;
2742 if(p0 == NULL) {
2743 var = is_nullable;
2744 } else {
2745 if(cltype >= p0->type->table_size) {
2746 var = 0;
2747 } else {
2748 var = p0->type->type_table[cltype] == idtype;
2749 }
2750 }
2751 if (!var) {
2752 var_class_name = p0 == NULL ? "null" : p0->type->name;
2753 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Sequence#0", var_class_name);
2754 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 492);
2755 exit(1);
2756 }
2757 var_class_name1 = self == NULL ? "null" : self->type->name;
2758 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "push", var_class_name1);
2759 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 492);
2760 exit(1);
2761 RET_LABEL:;
2762 }
2763 /* method abstract_collection#Sequence#push for (self: Object, nullable Object) */
2764 void VIRTUAL_abstract_collection__Sequence__push(val* self, val* p0) {
2765 abstract_collection__Sequence__push(self, p0);
2766 RET_LABEL:;
2767 }
2768 /* method abstract_collection#Sequence#append for (self: Sequence[nullable Object], Collection[nullable Object]) */
2769 void abstract_collection__Sequence__append(val* self, val* p0) {
2770 short int var /* : Bool */;
2771 int cltype;
2772 int idtype;
2773 const struct type* type_struct;
2774 const char* var_class_name;
2775 val* var_coll /* var coll: Collection[nullable Object] */;
2776 val* var1 /* : Iterator[nullable Object] */;
2777 short int var2 /* : Bool */;
2778 val* var3 /* : nullable Object */;
2779 val* var_i /* var i: nullable Object */;
2780 /* Covariant cast for argument 0 (coll) <p0:Collection[nullable Object]> isa Collection[Sequence#0] */
2781 /* <p0:Collection[nullable Object]> isa Collection[Sequence#0] */
2782 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collectionabstract_collection__Sequence_FT0];
2783 cltype = type_struct->color;
2784 idtype = type_struct->id;
2785 if(cltype >= p0->type->table_size) {
2786 var = 0;
2787 } else {
2788 var = p0->type->type_table[cltype] == idtype;
2789 }
2790 if (!var) {
2791 var_class_name = p0 == NULL ? "null" : p0->type->name;
2792 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection[Sequence#0]", var_class_name);
2793 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 495);
2794 exit(1);
2795 }
2796 var_coll = p0;
2797 var1 = ((val* (*)(val*))(var_coll->class->vft[COLOR_abstract_collection__Collection__iterator]))(var_coll) /* iterator on <var_coll:Collection[nullable Object]>*/;
2798 for(;;) {
2799 var2 = ((short int (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var1) /* is_ok on <var1:Iterator[nullable Object]>*/;
2800 if(!var2) break;
2801 var3 = ((val* (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__item]))(var1) /* item on <var1:Iterator[nullable Object]>*/;
2802 var_i = var3;
2803 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__Sequence__push]))(self, var_i) /* push on <self:Sequence[nullable Object]>*/;
2804 CONTINUE_label: (void)0;
2805 ((void (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__next]))(var1) /* next on <var1:Iterator[nullable Object]>*/;
2806 }
2807 BREAK_label: (void)0;
2808 RET_LABEL:;
2809 }
2810 /* method abstract_collection#Sequence#append for (self: Object, Collection[nullable Object]) */
2811 void VIRTUAL_abstract_collection__Sequence__append(val* self, val* p0) {
2812 abstract_collection__Sequence__append(self, p0);
2813 RET_LABEL:;
2814 }
2815 /* method abstract_collection#Sequence#pop for (self: Sequence[nullable Object]): nullable Object */
2816 val* abstract_collection__Sequence__pop(val* self) {
2817 val* var /* : nullable Object */;
2818 const char* var_class_name;
2819 var_class_name = self == NULL ? "null" : self->type->name;
2820 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "pop", var_class_name);
2821 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 498);
2822 exit(1);
2823 RET_LABEL:;
2824 return var;
2825 }
2826 /* method abstract_collection#Sequence#pop for (self: Object): nullable Object */
2827 val* VIRTUAL_abstract_collection__Sequence__pop(val* self) {
2828 val* var /* : nullable Object */;
2829 val* var1 /* : nullable Object */;
2830 var1 = abstract_collection__Sequence__pop(self);
2831 var = var1;
2832 RET_LABEL:;
2833 return var;
2834 }
2835 /* method abstract_collection#Sequence#unshift for (self: Sequence[nullable Object], nullable Object) */
2836 void abstract_collection__Sequence__unshift(val* self, val* p0) {
2837 short int var /* : Bool */;
2838 int cltype;
2839 int idtype;
2840 const struct type* type_struct;
2841 short int is_nullable;
2842 const char* var_class_name;
2843 const char* var_class_name1;
2844 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa Sequence#0 */
2845 /* <p0:nullable Object> isa Sequence#0 */
2846 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Sequence_FT0];
2847 cltype = type_struct->color;
2848 idtype = type_struct->id;
2849 is_nullable = type_struct->is_nullable;
2850 if(p0 == NULL) {
2851 var = is_nullable;
2852 } else {
2853 if(cltype >= p0->type->table_size) {
2854 var = 0;
2855 } else {
2856 var = p0->type->type_table[cltype] == idtype;
2857 }
2858 }
2859 if (!var) {
2860 var_class_name = p0 == NULL ? "null" : p0->type->name;
2861 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Sequence#0", var_class_name);
2862 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 501);
2863 exit(1);
2864 }
2865 var_class_name1 = self == NULL ? "null" : self->type->name;
2866 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "unshift", var_class_name1);
2867 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 501);
2868 exit(1);
2869 RET_LABEL:;
2870 }
2871 /* method abstract_collection#Sequence#unshift for (self: Object, nullable Object) */
2872 void VIRTUAL_abstract_collection__Sequence__unshift(val* self, val* p0) {
2873 abstract_collection__Sequence__unshift(self, p0);
2874 RET_LABEL:;
2875 }
2876 /* method abstract_collection#Sequence#shift for (self: Sequence[nullable Object]): nullable Object */
2877 val* abstract_collection__Sequence__shift(val* self) {
2878 val* var /* : nullable Object */;
2879 const char* var_class_name;
2880 var_class_name = self == NULL ? "null" : self->type->name;
2881 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "shift", var_class_name);
2882 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 504);
2883 exit(1);
2884 RET_LABEL:;
2885 return var;
2886 }
2887 /* method abstract_collection#Sequence#shift for (self: Object): nullable Object */
2888 val* VIRTUAL_abstract_collection__Sequence__shift(val* self) {
2889 val* var /* : nullable Object */;
2890 val* var1 /* : nullable Object */;
2891 var1 = abstract_collection__Sequence__shift(self);
2892 var = var1;
2893 RET_LABEL:;
2894 return var;
2895 }
2896 /* method abstract_collection#Sequence#[]= for (self: Sequence[nullable Object], Int, nullable Object) */
2897 void abstract_collection__Sequence___91d_93d_61d(val* self, long p0, val* p1) {
2898 short int var /* : Bool */;
2899 int cltype;
2900 int idtype;
2901 const struct type* type_struct;
2902 short int is_nullable;
2903 const char* var_class_name;
2904 const char* var_class_name1;
2905 /* Covariant cast for argument 1 (item) <p1:nullable Object> isa Sequence#0 */
2906 /* <p1:nullable Object> isa Sequence#0 */
2907 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Sequence_FT0];
2908 cltype = type_struct->color;
2909 idtype = type_struct->id;
2910 is_nullable = type_struct->is_nullable;
2911 if(p1 == NULL) {
2912 var = is_nullable;
2913 } else {
2914 if(cltype >= p1->type->table_size) {
2915 var = 0;
2916 } else {
2917 var = p1->type->type_table[cltype] == idtype;
2918 }
2919 }
2920 if (!var) {
2921 var_class_name = p1 == NULL ? "null" : p1->type->name;
2922 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Sequence#0", var_class_name);
2923 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 508);
2924 exit(1);
2925 }
2926 var_class_name1 = self == NULL ? "null" : self->type->name;
2927 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "[]=", var_class_name1);
2928 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 508);
2929 exit(1);
2930 RET_LABEL:;
2931 }
2932 /* method abstract_collection#Sequence#[]= for (self: Object, Int, nullable Object) */
2933 void VIRTUAL_abstract_collection__Sequence___91d_93d_61d(val* self, long p0, val* p1) {
2934 abstract_collection__Sequence___91d_93d_61d(self, p0, p1);
2935 RET_LABEL:;
2936 }
2937 /* method abstract_collection#Sequence#remove_at for (self: Sequence[nullable Object], Int) */
2938 void abstract_collection__Sequence__remove_at(val* self, long p0) {
2939 const char* var_class_name;
2940 var_class_name = self == NULL ? "null" : self->type->name;
2941 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "remove_at", var_class_name);
2942 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 511);
2943 exit(1);
2944 RET_LABEL:;
2945 }
2946 /* method abstract_collection#Sequence#remove_at for (self: Object, Int) */
2947 void VIRTUAL_abstract_collection__Sequence__remove_at(val* self, long p0) {
2948 abstract_collection__Sequence__remove_at(self, p0);
2949 RET_LABEL:;
2950 }
2951 /* method abstract_collection#IndexedIterator#index for (self: IndexedIterator[nullable Object]): Int */
2952 long abstract_collection__IndexedIterator__index(val* self) {
2953 long var /* : Int */;
2954 const char* var_class_name;
2955 var_class_name = self == NULL ? "null" : self->type->name;
2956 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "index", var_class_name);
2957 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 518);
2958 exit(1);
2959 RET_LABEL:;
2960 return var;
2961 }
2962 /* method abstract_collection#IndexedIterator#index for (self: Object): Int */
2963 long VIRTUAL_abstract_collection__IndexedIterator__index(val* self) {
2964 long var /* : Int */;
2965 long var1 /* : Int */;
2966 var1 = abstract_collection__IndexedIterator__index(self);
2967 var = var1;
2968 RET_LABEL:;
2969 return var;
2970 }
2971 /* method abstract_collection#CoupleMap#couple_at for (self: CoupleMap[Object, nullable Object], Object): nullable Couple[Object, nullable Object] */
2972 val* abstract_collection__CoupleMap__couple_at(val* self, val* p0) {
2973 val* var /* : nullable Couple[Object, nullable Object] */;
2974 short int var1 /* : Bool */;
2975 int cltype;
2976 int idtype;
2977 const struct type* type_struct;
2978 const char* var_class_name;
2979 const char* var_class_name2;
2980 /* Covariant cast for argument 0 (key) <p0:Object> isa CoupleMap#0 */
2981 /* <p0:Object> isa CoupleMap#0 */
2982 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__CoupleMap_FT0];
2983 cltype = type_struct->color;
2984 idtype = type_struct->id;
2985 if(cltype >= p0->type->table_size) {
2986 var1 = 0;
2987 } else {
2988 var1 = p0->type->type_table[cltype] == idtype;
2989 }
2990 if (!var1) {
2991 var_class_name = p0 == NULL ? "null" : p0->type->name;
2992 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "CoupleMap#0", var_class_name);
2993 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 525);
2994 exit(1);
2995 }
2996 var_class_name2 = self == NULL ? "null" : self->type->name;
2997 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "couple_at", var_class_name2);
2998 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 525);
2999 exit(1);
3000 RET_LABEL:;
3001 return var;
3002 }
3003 /* method abstract_collection#CoupleMap#couple_at for (self: Object, Object): nullable Couple[Object, nullable Object] */
3004 val* VIRTUAL_abstract_collection__CoupleMap__couple_at(val* self, val* p0) {
3005 val* var /* : nullable Couple[Object, nullable Object] */;
3006 val* var1 /* : nullable Couple[Object, nullable Object] */;
3007 var1 = abstract_collection__CoupleMap__couple_at(self, p0);
3008 var = var1;
3009 RET_LABEL:;
3010 return var;
3011 }
3012 /* method abstract_collection#CoupleMap#[] for (self: CoupleMap[Object, nullable Object], Object): nullable Object */
3013 val* abstract_collection__CoupleMap___91d_93d(val* self, val* p0) {
3014 val* var /* : nullable Object */;
3015 short int var1 /* : Bool */;
3016 int cltype;
3017 int idtype;
3018 const struct type* type_struct;
3019 const char* var_class_name;
3020 val* var_key /* var key: Object */;
3021 val* var2 /* : nullable Couple[Object, nullable Object] */;
3022 val* var_c /* var c: nullable Couple[Object, nullable Object] */;
3023 val* var3 /* : null */;
3024 short int var4 /* : Bool */;
3025 val* var5 /* : nullable Object */;
3026 /* Covariant cast for argument 0 (key) <p0:Object> isa MapRead#0 */
3027 /* <p0:Object> isa MapRead#0 */
3028 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__MapRead_FT0];
3029 cltype = type_struct->color;
3030 idtype = type_struct->id;
3031 if(cltype >= p0->type->table_size) {
3032 var1 = 0;
3033 } else {
3034 var1 = p0->type->type_table[cltype] == idtype;
3035 }
3036 if (!var1) {
3037 var_class_name = p0 == NULL ? "null" : p0->type->name;
3038 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapRead#0", var_class_name);
3039 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 529);
3040 exit(1);
3041 }
3042 var_key = p0;
3043 var2 = ((val* (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__CoupleMap__couple_at]))(self, var_key) /* couple_at on <self:CoupleMap[Object, nullable Object]>*/;
3044 var_c = var2;
3045 var3 = NULL;
3046 if (var_c == NULL) {
3047 var4 = 1; /* is null */
3048 } else {
3049 var4 = 0; /* arg is null but recv is not */
3050 }
3051 if (var4){
3052 fprintf(stderr, "Runtime error: %s", "Aborted");
3053 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 533);
3054 exit(1);
3055 } else {
3056 var5 = ((val* (*)(val*))(var_c->class->vft[COLOR_abstract_collection__Couple__second]))(var_c) /* second on <var_c:nullable Couple[Object, nullable Object](Couple[Object, nullable Object])>*/;
3057 var = var5;
3058 goto RET_LABEL;
3059 }
3060 RET_LABEL:;
3061 return var;
3062 }
3063 /* method abstract_collection#CoupleMap#[] for (self: Object, Object): nullable Object */
3064 val* VIRTUAL_abstract_collection__CoupleMap___91d_93d(val* self, val* p0) {
3065 val* var /* : nullable Object */;
3066 val* var1 /* : nullable Object */;
3067 var1 = abstract_collection__CoupleMap___91d_93d(self, p0);
3068 var = var1;
3069 RET_LABEL:;
3070 return var;
3071 }
3072 /* method abstract_collection#CoupleMapIterator#item for (self: CoupleMapIterator[Object, nullable Object]): nullable Object */
3073 val* abstract_collection__CoupleMapIterator__item(val* self) {
3074 val* var /* : nullable Object */;
3075 val* var1 /* : Iterator[Couple[Object, nullable Object]] */;
3076 val* var2 /* : nullable Object */;
3077 val* var3 /* : nullable Object */;
3078 var1 = self->attrs[COLOR_abstract_collection__CoupleMapIterator___iter].val; /* _iter on <self:CoupleMapIterator[Object, nullable Object]> */
3079 if (var1 == NULL) {
3080 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _iter");
3081 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 545);
3082 exit(1);
3083 }
3084 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__item]))(var1) /* item on <var1:Iterator[Couple[Object, nullable Object]]>*/;
3085 var3 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_collection__Couple__second]))(var2) /* second on <var2:nullable Object(Couple[Object, nullable Object])>*/;
3086 var = var3;
3087 goto RET_LABEL;
3088 RET_LABEL:;
3089 return var;
3090 }
3091 /* method abstract_collection#CoupleMapIterator#item for (self: Object): nullable Object */
3092 val* VIRTUAL_abstract_collection__CoupleMapIterator__item(val* self) {
3093 val* var /* : nullable Object */;
3094 val* var1 /* : nullable Object */;
3095 var1 = abstract_collection__CoupleMapIterator__item(self);
3096 var = var1;
3097 RET_LABEL:;
3098 return var;
3099 }
3100 /* method abstract_collection#CoupleMapIterator#key for (self: CoupleMapIterator[Object, nullable Object]): Object */
3101 val* abstract_collection__CoupleMapIterator__key(val* self) {
3102 val* var /* : Object */;
3103 val* var1 /* : Iterator[Couple[Object, nullable Object]] */;
3104 val* var2 /* : nullable Object */;
3105 val* var3 /* : nullable Object */;
3106 var1 = self->attrs[COLOR_abstract_collection__CoupleMapIterator___iter].val; /* _iter on <self:CoupleMapIterator[Object, nullable Object]> */
3107 if (var1 == NULL) {
3108 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _iter");
3109 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 549);
3110 exit(1);
3111 }
3112 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__item]))(var1) /* item on <var1:Iterator[Couple[Object, nullable Object]]>*/;
3113 var3 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_collection__Couple__first]))(var2) /* first on <var2:nullable Object(Couple[Object, nullable Object])>*/;
3114 var = var3;
3115 goto RET_LABEL;
3116 RET_LABEL:;
3117 return var;
3118 }
3119 /* method abstract_collection#CoupleMapIterator#key for (self: Object): Object */
3120 val* VIRTUAL_abstract_collection__CoupleMapIterator__key(val* self) {
3121 val* var /* : Object */;
3122 val* var1 /* : Object */;
3123 var1 = abstract_collection__CoupleMapIterator__key(self);
3124 var = var1;
3125 RET_LABEL:;
3126 return var;
3127 }
3128 /* method abstract_collection#CoupleMapIterator#is_ok for (self: CoupleMapIterator[Object, nullable Object]): Bool */
3129 short int abstract_collection__CoupleMapIterator__is_ok(val* self) {
3130 short int var /* : Bool */;
3131 val* var1 /* : Iterator[Couple[Object, nullable Object]] */;
3132 short int var2 /* : Bool */;
3133 var1 = self->attrs[COLOR_abstract_collection__CoupleMapIterator___iter].val; /* _iter on <self:CoupleMapIterator[Object, nullable Object]> */
3134 if (var1 == NULL) {
3135 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _iter");
3136 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 551);
3137 exit(1);
3138 }
3139 var2 = ((short int (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var1) /* is_ok on <var1:Iterator[Couple[Object, nullable Object]]>*/;
3140 var = var2;
3141 goto RET_LABEL;
3142 RET_LABEL:;
3143 return var;
3144 }
3145 /* method abstract_collection#CoupleMapIterator#is_ok for (self: Object): Bool */
3146 short int VIRTUAL_abstract_collection__CoupleMapIterator__is_ok(val* self) {
3147 short int var /* : Bool */;
3148 short int var1 /* : Bool */;
3149 var1 = abstract_collection__CoupleMapIterator__is_ok(self);
3150 var = var1;
3151 RET_LABEL:;
3152 return var;
3153 }
3154 /* method abstract_collection#CoupleMapIterator#next for (self: CoupleMapIterator[Object, nullable Object]) */
3155 void abstract_collection__CoupleMapIterator__next(val* self) {
3156 val* var /* : Iterator[Couple[Object, nullable Object]] */;
3157 var = self->attrs[COLOR_abstract_collection__CoupleMapIterator___iter].val; /* _iter on <self:CoupleMapIterator[Object, nullable Object]> */
3158 if (var == NULL) {
3159 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _iter");
3160 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 555);
3161 exit(1);
3162 }
3163 ((void (*)(val*))(var->class->vft[COLOR_abstract_collection__Iterator__next]))(var) /* next on <var:Iterator[Couple[Object, nullable Object]]>*/;
3164 RET_LABEL:;
3165 }
3166 /* method abstract_collection#CoupleMapIterator#next for (self: Object) */
3167 void VIRTUAL_abstract_collection__CoupleMapIterator__next(val* self) {
3168 abstract_collection__CoupleMapIterator__next(self);
3169 RET_LABEL:;
3170 }
3171 /* method abstract_collection#CoupleMapIterator#init for (self: CoupleMapIterator[Object, nullable Object], Iterator[Couple[Object, nullable Object]]) */
3172 void abstract_collection__CoupleMapIterator__init(val* self, val* p0) {
3173 short int var /* : Bool */;
3174 int cltype;
3175 int idtype;
3176 const struct type* type_struct;
3177 const char* var_class_name;
3178 val* var_i /* var i: Iterator[Couple[Object, nullable Object]] */;
3179 /* Covariant cast for argument 0 (i) <p0:Iterator[Couple[Object, nullable Object]]> isa Iterator[Couple[CoupleMapIterator#0, CoupleMapIterator#1]] */
3180 /* <p0:Iterator[Couple[Object, nullable Object]]> isa Iterator[Couple[CoupleMapIterator#0, CoupleMapIterator#1]] */
3181 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Iteratorabstract_collection__Coupleabstract_collection__CoupleMapIterator_FT0abstract_collection__CoupleMapIterator_FT1];
3182 cltype = type_struct->color;
3183 idtype = type_struct->id;
3184 if(cltype >= p0->type->table_size) {
3185 var = 0;
3186 } else {
3187 var = p0->type->type_table[cltype] == idtype;
3188 }
3189 if (!var) {
3190 var_class_name = p0 == NULL ? "null" : p0->type->name;
3191 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Iterator[Couple[CoupleMapIterator#0, CoupleMapIterator#1]]", var_class_name);
3192 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 560);
3193 exit(1);
3194 }
3195 var_i = p0;
3196 self->attrs[COLOR_abstract_collection__CoupleMapIterator___iter].val = var_i; /* _iter on <self:CoupleMapIterator[Object, nullable Object]> */
3197 RET_LABEL:;
3198 }
3199 /* method abstract_collection#CoupleMapIterator#init for (self: Object, Iterator[Couple[Object, nullable Object]]) */
3200 void VIRTUAL_abstract_collection__CoupleMapIterator__init(val* self, val* p0) {
3201 abstract_collection__CoupleMapIterator__init(self, p0);
3202 RET_LABEL:;
3203 }
3204 /* method abstract_collection#Couple#first for (self: Couple[nullable Object, nullable Object]): nullable Object */
3205 val* abstract_collection__Couple__first(val* self) {
3206 val* var /* : nullable Object */;
3207 val* var1 /* : nullable Object */;
3208 var1 = self->attrs[COLOR_abstract_collection__Couple___first].val; /* _first on <self:Couple[nullable Object, nullable Object]> */
3209 var = var1;
3210 RET_LABEL:;
3211 return var;
3212 }
3213 /* method abstract_collection#Couple#first for (self: Object): nullable Object */
3214 val* VIRTUAL_abstract_collection__Couple__first(val* self) {
3215 val* var /* : nullable Object */;
3216 val* var1 /* : nullable Object */;
3217 var1 = abstract_collection__Couple__first(self);
3218 var = var1;
3219 RET_LABEL:;
3220 return var;
3221 }
3222 /* method abstract_collection#Couple#first= for (self: Couple[nullable Object, nullable Object], nullable Object) */
3223 void abstract_collection__Couple__first_61d(val* self, val* p0) {
3224 short int var /* : Bool */;
3225 int cltype;
3226 int idtype;
3227 const struct type* type_struct;
3228 short int is_nullable;
3229 const char* var_class_name;
3230 /* Covariant cast for argument 0 (first) <p0:nullable Object> isa Couple#0 */
3231 /* <p0:nullable Object> isa Couple#0 */
3232 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Couple_FT0];
3233 cltype = type_struct->color;
3234 idtype = type_struct->id;
3235 is_nullable = type_struct->is_nullable;
3236 if(p0 == NULL) {
3237 var = is_nullable;
3238 } else {
3239 if(cltype >= p0->type->table_size) {
3240 var = 0;
3241 } else {
3242 var = p0->type->type_table[cltype] == idtype;
3243 }
3244 }
3245 if (!var) {
3246 var_class_name = p0 == NULL ? "null" : p0->type->name;
3247 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Couple#0", var_class_name);
3248 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 568);
3249 exit(1);
3250 }
3251 self->attrs[COLOR_abstract_collection__Couple___first].val = p0; /* _first on <self:Couple[nullable Object, nullable Object]> */
3252 RET_LABEL:;
3253 }
3254 /* method abstract_collection#Couple#first= for (self: Object, nullable Object) */
3255 void VIRTUAL_abstract_collection__Couple__first_61d(val* self, val* p0) {
3256 abstract_collection__Couple__first_61d(self, p0);
3257 RET_LABEL:;
3258 }
3259 /* method abstract_collection#Couple#second for (self: Couple[nullable Object, nullable Object]): nullable Object */
3260 val* abstract_collection__Couple__second(val* self) {
3261 val* var /* : nullable Object */;
3262 val* var1 /* : nullable Object */;
3263 var1 = self->attrs[COLOR_abstract_collection__Couple___second].val; /* _second on <self:Couple[nullable Object, nullable Object]> */
3264 var = var1;
3265 RET_LABEL:;
3266 return var;
3267 }
3268 /* method abstract_collection#Couple#second for (self: Object): nullable Object */
3269 val* VIRTUAL_abstract_collection__Couple__second(val* self) {
3270 val* var /* : nullable Object */;
3271 val* var1 /* : nullable Object */;
3272 var1 = abstract_collection__Couple__second(self);
3273 var = var1;
3274 RET_LABEL:;
3275 return var;
3276 }
3277 /* method abstract_collection#Couple#second= for (self: Couple[nullable Object, nullable Object], nullable Object) */
3278 void abstract_collection__Couple__second_61d(val* self, val* p0) {
3279 short int var /* : Bool */;
3280 int cltype;
3281 int idtype;
3282 const struct type* type_struct;
3283 short int is_nullable;
3284 const char* var_class_name;
3285 /* Covariant cast for argument 0 (second) <p0:nullable Object> isa Couple#1 */
3286 /* <p0:nullable Object> isa Couple#1 */
3287 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Couple_FT1];
3288 cltype = type_struct->color;
3289 idtype = type_struct->id;
3290 is_nullable = type_struct->is_nullable;
3291 if(p0 == NULL) {
3292 var = is_nullable;
3293 } else {
3294 if(cltype >= p0->type->table_size) {
3295 var = 0;
3296 } else {
3297 var = p0->type->type_table[cltype] == idtype;
3298 }
3299 }
3300 if (!var) {
3301 var_class_name = p0 == NULL ? "null" : p0->type->name;
3302 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Couple#1", var_class_name);
3303 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 571);
3304 exit(1);
3305 }
3306 self->attrs[COLOR_abstract_collection__Couple___second].val = p0; /* _second on <self:Couple[nullable Object, nullable Object]> */
3307 RET_LABEL:;
3308 }
3309 /* method abstract_collection#Couple#second= for (self: Object, nullable Object) */
3310 void VIRTUAL_abstract_collection__Couple__second_61d(val* self, val* p0) {
3311 abstract_collection__Couple__second_61d(self, p0);
3312 RET_LABEL:;
3313 }
3314 /* method abstract_collection#Couple#init for (self: Couple[nullable Object, nullable Object], nullable Object, nullable Object) */
3315 void abstract_collection__Couple__init(val* self, val* p0, val* p1) {
3316 short int var /* : Bool */;
3317 int cltype;
3318 int idtype;
3319 const struct type* type_struct;
3320 short int is_nullable;
3321 const char* var_class_name;
3322 short int var1 /* : Bool */;
3323 int cltype2;
3324 int idtype3;
3325 const struct type* type_struct4;
3326 short int is_nullable5;
3327 const char* var_class_name6;
3328 val* var_f /* var f: nullable Object */;
3329 val* var_s /* var s: nullable Object */;
3330 /* Covariant cast for argument 0 (f) <p0:nullable Object> isa Couple#0 */
3331 /* <p0:nullable Object> isa Couple#0 */
3332 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Couple_FT0];
3333 cltype = type_struct->color;
3334 idtype = type_struct->id;
3335 is_nullable = type_struct->is_nullable;
3336 if(p0 == NULL) {
3337 var = is_nullable;
3338 } else {
3339 if(cltype >= p0->type->table_size) {
3340 var = 0;
3341 } else {
3342 var = p0->type->type_table[cltype] == idtype;
3343 }
3344 }
3345 if (!var) {
3346 var_class_name = p0 == NULL ? "null" : p0->type->name;
3347 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Couple#0", var_class_name);
3348 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 574);
3349 exit(1);
3350 }
3351 /* Covariant cast for argument 1 (s) <p1:nullable Object> isa Couple#1 */
3352 /* <p1:nullable Object> isa Couple#1 */
3353 type_struct4 = self->type->resolution_table->types[COLOR_abstract_collection__Couple_FT1];
3354 cltype2 = type_struct4->color;
3355 idtype3 = type_struct4->id;
3356 is_nullable5 = type_struct4->is_nullable;
3357 if(p1 == NULL) {
3358 var1 = is_nullable5;
3359 } else {
3360 if(cltype2 >= p1->type->table_size) {
3361 var1 = 0;
3362 } else {
3363 var1 = p1->type->type_table[cltype2] == idtype3;
3364 }
3365 }
3366 if (!var1) {
3367 var_class_name6 = p1 == NULL ? "null" : p1->type->name;
3368 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Couple#1", var_class_name6);
3369 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 574);
3370 exit(1);
3371 }
3372 var_f = p0;
3373 var_s = p1;
3374 self->attrs[COLOR_abstract_collection__Couple___first].val = var_f; /* _first on <self:Couple[nullable Object, nullable Object]> */
3375 self->attrs[COLOR_abstract_collection__Couple___second].val = var_s; /* _second on <self:Couple[nullable Object, nullable Object]> */
3376 RET_LABEL:;
3377 }
3378 /* method abstract_collection#Couple#init for (self: Object, nullable Object, nullable Object) */
3379 void VIRTUAL_abstract_collection__Couple__init(val* self, val* p0, val* p1) {
3380 abstract_collection__Couple__init(self, p0, p1);
3381 RET_LABEL:;
3382 }