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