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", 267);
 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_null for (self: MapRead[Object, nullable Object], Object): nullable Object */
1461 val* abstract_collection__MapRead__get_or_null(val* self, val* p0) {
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 val* var_key /* var key: Object */;
1469 short int var2 /* : Bool */;
1470 val* var3 /* : nullable Object */;
1471 val* var4 /* : null */;
1472 /* Covariant cast for argument 0 (key) <p0:Object> isa MapRead#0 */
1473 /* <p0:Object> isa MapRead#0 */
1474 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__MapRead_FT0];
1475 cltype = type_struct->color;
1476 idtype = type_struct->id;
1477 if(cltype >= p0->type->table_size) {
1478 var1 = 0;
1479 } else {
1480 var1 = p0->type->type_table[cltype] == idtype;
1481 }
1482 if (!var1) {
1483 var_class_name = p0 == NULL ? "null" : p0->type->name;
1484 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapRead#0", var_class_name);
1485 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 283);
1486 show_backtrace(1);
1487 }
1488 var_key = p0;
1489 var2 = ((short int (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__MapRead__has_key]))(self, var_key) /* has_key on <self:MapRead[Object, nullable Object]>*/;
1490 if (var2){
1491 var3 = ((val* (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__MapRead___91d_93d]))(self, var_key) /* [] on <self:MapRead[Object, nullable Object]>*/;
1492 var = var3;
1493 goto RET_LABEL;
1494 } else {
1495 }
1496 var4 = NULL;
1497 var = var4;
1498 goto RET_LABEL;
1499 RET_LABEL:;
1500 return var;
1501 }
1502 /* method abstract_collection#MapRead#get_or_null for (self: Object, Object): nullable Object */
1503 val* VIRTUAL_abstract_collection__MapRead__get_or_null(val* self, val* p0) {
1504 val* var /* : nullable Object */;
1505 val* var1 /* : nullable Object */;
1506 var1 = abstract_collection__MapRead__get_or_null(self, p0);
1507 var = var1;
1508 RET_LABEL:;
1509 return var;
1510 }
1511 /* method abstract_collection#MapRead#get_or_default for (self: MapRead[Object, nullable Object], Object, nullable Object): nullable Object */
1512 val* abstract_collection__MapRead__get_or_default(val* self, val* p0, val* p1) {
1513 val* var /* : nullable Object */;
1514 short int var1 /* : Bool */;
1515 int cltype;
1516 int idtype;
1517 const struct type* type_struct;
1518 const char* var_class_name;
1519 short int var2 /* : Bool */;
1520 int cltype3;
1521 int idtype4;
1522 const struct type* type_struct5;
1523 short int is_nullable;
1524 const char* var_class_name6;
1525 val* var_key /* var key: Object */;
1526 val* var_default /* var default: nullable Object */;
1527 short int var7 /* : Bool */;
1528 val* var8 /* : nullable Object */;
1529 /* Covariant cast for argument 0 (key) <p0:Object> isa MapRead#0 */
1530 /* <p0:Object> isa MapRead#0 */
1531 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__MapRead_FT0];
1532 cltype = type_struct->color;
1533 idtype = type_struct->id;
1534 if(cltype >= p0->type->table_size) {
1535 var1 = 0;
1536 } else {
1537 var1 = p0->type->type_table[cltype] == idtype;
1538 }
1539 if (!var1) {
1540 var_class_name = p0 == NULL ? "null" : p0->type->name;
1541 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapRead#0", var_class_name);
1542 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 297);
1543 show_backtrace(1);
1544 }
1545 /* Covariant cast for argument 1 (default) <p1:nullable Object> isa MapRead#1 */
1546 /* <p1:nullable Object> isa MapRead#1 */
1547 type_struct5 = self->type->resolution_table->types[COLOR_abstract_collection__MapRead_FT1];
1548 cltype3 = type_struct5->color;
1549 idtype4 = type_struct5->id;
1550 is_nullable = type_struct5->is_nullable;
1551 if(p1 == NULL) {
1552 var2 = is_nullable;
1553 } else {
1554 if(cltype3 >= p1->type->table_size) {
1555 var2 = 0;
1556 } else {
1557 var2 = p1->type->type_table[cltype3] == idtype4;
1558 }
1559 }
1560 if (!var2) {
1561 var_class_name6 = p1 == NULL ? "null" : p1->type->name;
1562 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapRead#1", var_class_name6);
1563 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 297);
1564 show_backtrace(1);
1565 }
1566 var_key = p0;
1567 var_default = p1;
1568 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]>*/;
1569 if (var7){
1570 var8 = ((val* (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__MapRead___91d_93d]))(self, var_key) /* [] on <self:MapRead[Object, nullable Object]>*/;
1571 var = var8;
1572 goto RET_LABEL;
1573 } else {
1574 }
1575 var = var_default;
1576 goto RET_LABEL;
1577 RET_LABEL:;
1578 return var;
1579 }
1580 /* method abstract_collection#MapRead#get_or_default for (self: Object, Object, nullable Object): nullable Object */
1581 val* VIRTUAL_abstract_collection__MapRead__get_or_default(val* self, val* p0, val* p1) {
1582 val* var /* : nullable Object */;
1583 val* var1 /* : nullable Object */;
1584 var1 = abstract_collection__MapRead__get_or_default(self, p0, p1);
1585 var = var1;
1586 RET_LABEL:;
1587 return var;
1588 }
1589 /* method abstract_collection#MapRead#has_key for (self: MapRead[Object, nullable Object], Object): Bool */
1590 short int abstract_collection__MapRead__has_key(val* self, val* p0) {
1591 short int var /* : Bool */;
1592 short int var1 /* : Bool */;
1593 int cltype;
1594 int idtype;
1595 const struct type* type_struct;
1596 const char* var_class_name;
1597 val* var_key /* var key: Object */;
1598 val* var2 /* : Collection[Object] */;
1599 short int var3 /* : Bool */;
1600 /* Covariant cast for argument 0 (key) <p0:Object> isa MapRead#0 */
1601 /* <p0:Object> isa MapRead#0 */
1602 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__MapRead_FT0];
1603 cltype = type_struct->color;
1604 idtype = type_struct->id;
1605 if(cltype >= p0->type->table_size) {
1606 var1 = 0;
1607 } else {
1608 var1 = p0->type->type_table[cltype] == idtype;
1609 }
1610 if (!var1) {
1611 var_class_name = p0 == NULL ? "null" : p0->type->name;
1612 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapRead#0", var_class_name);
1613 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 304);
1614 show_backtrace(1);
1615 }
1616 var_key = p0;
1617 var2 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__MapRead__keys]))(self) /* keys on <self:MapRead[Object, nullable Object]>*/;
1618 var3 = ((short int (*)(val*, val*))(var2->class->vft[COLOR_abstract_collection__Collection__has]))(var2, var_key) /* has on <var2:Collection[Object]>*/;
1619 var = var3;
1620 goto RET_LABEL;
1621 RET_LABEL:;
1622 return var;
1623 }
1624 /* method abstract_collection#MapRead#has_key for (self: Object, Object): Bool */
1625 short int VIRTUAL_abstract_collection__MapRead__has_key(val* self, val* p0) {
1626 short int var /* : Bool */;
1627 short int var1 /* : Bool */;
1628 var1 = abstract_collection__MapRead__has_key(self, p0);
1629 var = var1;
1630 RET_LABEL:;
1631 return var;
1632 }
1633 /* method abstract_collection#MapRead#iterator for (self: MapRead[Object, nullable Object]): MapIterator[Object, nullable Object] */
1634 val* abstract_collection__MapRead__iterator(val* self) {
1635 val* var /* : MapIterator[Object, nullable Object] */;
1636 const char* var_class_name;
1637 var_class_name = self == NULL ? "null" : self->type->name;
1638 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "iterator", var_class_name);
1639 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 307);
1640 show_backtrace(1);
1641 RET_LABEL:;
1642 return var;
1643 }
1644 /* method abstract_collection#MapRead#iterator for (self: Object): MapIterator[Object, nullable Object] */
1645 val* VIRTUAL_abstract_collection__MapRead__iterator(val* self) {
1646 val* var /* : MapIterator[Object, nullable Object] */;
1647 val* var1 /* : MapIterator[Object, nullable Object] */;
1648 var1 = abstract_collection__MapRead__iterator(self);
1649 var = var1;
1650 RET_LABEL:;
1651 return var;
1652 }
1653 /* method abstract_collection#MapRead#values for (self: MapRead[Object, nullable Object]): Collection[nullable Object] */
1654 val* abstract_collection__MapRead__values(val* self) {
1655 val* var /* : Collection[nullable Object] */;
1656 const char* var_class_name;
1657 var_class_name = self == NULL ? "null" : self->type->name;
1658 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "values", var_class_name);
1659 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 310);
1660 show_backtrace(1);
1661 RET_LABEL:;
1662 return var;
1663 }
1664 /* method abstract_collection#MapRead#values for (self: Object): Collection[nullable Object] */
1665 val* VIRTUAL_abstract_collection__MapRead__values(val* self) {
1666 val* var /* : Collection[nullable Object] */;
1667 val* var1 /* : Collection[nullable Object] */;
1668 var1 = abstract_collection__MapRead__values(self);
1669 var = var1;
1670 RET_LABEL:;
1671 return var;
1672 }
1673 /* method abstract_collection#MapRead#keys for (self: MapRead[Object, nullable Object]): Collection[Object] */
1674 val* abstract_collection__MapRead__keys(val* self) {
1675 val* var /* : Collection[Object] */;
1676 const char* var_class_name;
1677 var_class_name = self == NULL ? "null" : self->type->name;
1678 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "keys", var_class_name);
1679 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 315);
1680 show_backtrace(1);
1681 RET_LABEL:;
1682 return var;
1683 }
1684 /* method abstract_collection#MapRead#keys for (self: Object): Collection[Object] */
1685 val* VIRTUAL_abstract_collection__MapRead__keys(val* self) {
1686 val* var /* : Collection[Object] */;
1687 val* var1 /* : Collection[Object] */;
1688 var1 = abstract_collection__MapRead__keys(self);
1689 var = var1;
1690 RET_LABEL:;
1691 return var;
1692 }
1693 /* method abstract_collection#MapRead#is_empty for (self: MapRead[Object, nullable Object]): Bool */
1694 short int abstract_collection__MapRead__is_empty(val* self) {
1695 short int var /* : Bool */;
1696 const char* var_class_name;
1697 var_class_name = self == NULL ? "null" : self->type->name;
1698 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "is_empty", var_class_name);
1699 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 320);
1700 show_backtrace(1);
1701 RET_LABEL:;
1702 return var;
1703 }
1704 /* method abstract_collection#MapRead#is_empty for (self: Object): Bool */
1705 short int VIRTUAL_abstract_collection__MapRead__is_empty(val* self) {
1706 short int var /* : Bool */;
1707 short int var1 /* : Bool */;
1708 var1 = abstract_collection__MapRead__is_empty(self);
1709 var = var1;
1710 RET_LABEL:;
1711 return var;
1712 }
1713 /* method abstract_collection#MapRead#length for (self: MapRead[Object, nullable Object]): Int */
1714 long abstract_collection__MapRead__length(val* self) {
1715 long var /* : Int */;
1716 const char* var_class_name;
1717 var_class_name = self == NULL ? "null" : self->type->name;
1718 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "length", var_class_name);
1719 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 323);
1720 show_backtrace(1);
1721 RET_LABEL:;
1722 return var;
1723 }
1724 /* method abstract_collection#MapRead#length for (self: Object): Int */
1725 long VIRTUAL_abstract_collection__MapRead__length(val* self) {
1726 long var /* : Int */;
1727 long var1 /* : Int */;
1728 var1 = abstract_collection__MapRead__length(self);
1729 var = var1;
1730 RET_LABEL:;
1731 return var;
1732 }
1733 /* method abstract_collection#MapRead#provide_default_value for (self: MapRead[Object, nullable Object], Object): nullable Object */
1734 val* abstract_collection__MapRead__provide_default_value(val* self, val* p0) {
1735 val* var /* : nullable Object */;
1736 short int var1 /* : Bool */;
1737 int cltype;
1738 int idtype;
1739 const struct type* type_struct;
1740 const char* var_class_name;
1741 val* var_key /* var key: Object */;
1742 /* Covariant cast for argument 0 (key) <p0:Object> isa MapRead#0 */
1743 /* <p0:Object> isa MapRead#0 */
1744 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__MapRead_FT0];
1745 cltype = type_struct->color;
1746 idtype = type_struct->id;
1747 if(cltype >= p0->type->table_size) {
1748 var1 = 0;
1749 } else {
1750 var1 = p0->type->type_table[cltype] == idtype;
1751 }
1752 if (!var1) {
1753 var_class_name = p0 == NULL ? "null" : p0->type->name;
1754 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapRead#0", var_class_name);
1755 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 326);
1756 show_backtrace(1);
1757 }
1758 var_key = p0;
1759 fprintf(stderr, "Runtime error: %s", "Aborted");
1760 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 331);
1761 show_backtrace(1);
1762 RET_LABEL:;
1763 return var;
1764 }
1765 /* method abstract_collection#MapRead#provide_default_value for (self: Object, Object): nullable Object */
1766 val* VIRTUAL_abstract_collection__MapRead__provide_default_value(val* self, val* p0) {
1767 val* var /* : nullable Object */;
1768 val* var1 /* : nullable Object */;
1769 var1 = abstract_collection__MapRead__provide_default_value(self, p0);
1770 var = var1;
1771 RET_LABEL:;
1772 return var;
1773 }
1774 /* method abstract_collection#Map#[]= for (self: Map[Object, nullable Object], Object, nullable Object) */
1775 void abstract_collection__Map___91d_93d_61d(val* self, val* p0, val* p1) {
1776 short int var /* : Bool */;
1777 int cltype;
1778 int idtype;
1779 const struct type* type_struct;
1780 const char* var_class_name;
1781 short int var1 /* : Bool */;
1782 int cltype2;
1783 int idtype3;
1784 const struct type* type_struct4;
1785 short int is_nullable;
1786 const char* var_class_name5;
1787 const char* var_class_name6;
1788 /* Covariant cast for argument 0 (key) <p0:Object> isa Map#0 */
1789 /* <p0:Object> isa Map#0 */
1790 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Map_FT0];
1791 cltype = type_struct->color;
1792 idtype = type_struct->id;
1793 if(cltype >= p0->type->table_size) {
1794 var = 0;
1795 } else {
1796 var = p0->type->type_table[cltype] == idtype;
1797 }
1798 if (!var) {
1799 var_class_name = p0 == NULL ? "null" : p0->type->name;
1800 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Map#0", var_class_name);
1801 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 360);
1802 show_backtrace(1);
1803 }
1804 /* Covariant cast for argument 1 (item) <p1:nullable Object> isa Map#1 */
1805 /* <p1:nullable Object> isa Map#1 */
1806 type_struct4 = self->type->resolution_table->types[COLOR_abstract_collection__Map_FT1];
1807 cltype2 = type_struct4->color;
1808 idtype3 = type_struct4->id;
1809 is_nullable = type_struct4->is_nullable;
1810 if(p1 == NULL) {
1811 var1 = is_nullable;
1812 } else {
1813 if(cltype2 >= p1->type->table_size) {
1814 var1 = 0;
1815 } else {
1816 var1 = p1->type->type_table[cltype2] == idtype3;
1817 }
1818 }
1819 if (!var1) {
1820 var_class_name5 = p1 == NULL ? "null" : p1->type->name;
1821 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Map#1", var_class_name5);
1822 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 360);
1823 show_backtrace(1);
1824 }
1825 var_class_name6 = self == NULL ? "null" : self->type->name;
1826 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "[]=", var_class_name6);
1827 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 360);
1828 show_backtrace(1);
1829 RET_LABEL:;
1830 }
1831 /* method abstract_collection#Map#[]= for (self: Object, Object, nullable Object) */
1832 void VIRTUAL_abstract_collection__Map___91d_93d_61d(val* self, val* p0, val* p1) {
1833 abstract_collection__Map___91d_93d_61d(self, p0, p1);
1834 RET_LABEL:;
1835 }
1836 /* method abstract_collection#Map#recover_with for (self: Map[Object, nullable Object], Map[Object, nullable Object]) */
1837 void abstract_collection__Map__recover_with(val* self, val* p0) {
1838 short int var /* : Bool */;
1839 int cltype;
1840 int idtype;
1841 const struct type* type_struct;
1842 const char* var_class_name;
1843 val* var_map /* var map: Map[Object, nullable Object] */;
1844 val* var1 /* : MapIterator[Object, nullable Object] */;
1845 val* var_i /* var i: MapIterator[Object, nullable Object] */;
1846 short int var2 /* : Bool */;
1847 val* var3 /* : Object */;
1848 val* var4 /* : nullable Object */;
1849 /* Covariant cast for argument 0 (map) <p0:Map[Object, nullable Object]> isa Map[Map#0, Map#1] */
1850 /* <p0:Map[Object, nullable Object]> isa Map[Map#0, Map#1] */
1851 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Mapabstract_collection__Map_FT0abstract_collection__Map_FT1];
1852 cltype = type_struct->color;
1853 idtype = type_struct->id;
1854 if(cltype >= p0->type->table_size) {
1855 var = 0;
1856 } else {
1857 var = p0->type->type_table[cltype] == idtype;
1858 }
1859 if (!var) {
1860 var_class_name = p0 == NULL ? "null" : p0->type->name;
1861 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Map[Map#0, Map#1]", var_class_name);
1862 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 363);
1863 show_backtrace(1);
1864 }
1865 var_map = p0;
1866 var1 = ((val* (*)(val*))(var_map->class->vft[COLOR_abstract_collection__MapRead__iterator]))(var_map) /* iterator on <var_map:Map[Object, nullable Object]>*/;
1867 var_i = var1;
1868 for(;;) {
1869 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]>*/;
1870 if (!var2) break;
1871 var3 = ((val* (*)(val*))(var_i->class->vft[COLOR_abstract_collection__MapIterator__key]))(var_i) /* key on <var_i:MapIterator[Object, nullable Object]>*/;
1872 var4 = ((val* (*)(val*))(var_i->class->vft[COLOR_abstract_collection__MapIterator__item]))(var_i) /* item on <var_i:MapIterator[Object, nullable Object]>*/;
1873 ((void (*)(val*, val*, val*))(self->class->vft[COLOR_abstract_collection__Map___91d_93d_61d]))(self, var3, var4) /* []= on <self:Map[Object, nullable Object]>*/;
1874 ((void (*)(val*))(var_i->class->vft[COLOR_abstract_collection__MapIterator__next]))(var_i) /* next on <var_i:MapIterator[Object, nullable Object]>*/;
1875 CONTINUE_label: (void)0;
1876 }
1877 BREAK_label: (void)0;
1878 RET_LABEL:;
1879 }
1880 /* method abstract_collection#Map#recover_with for (self: Object, Map[Object, nullable Object]) */
1881 void VIRTUAL_abstract_collection__Map__recover_with(val* self, val* p0) {
1882 abstract_collection__Map__recover_with(self, p0);
1883 RET_LABEL:;
1884 }
1885 /* method abstract_collection#Map#clear for (self: Map[Object, nullable Object]) */
1886 void abstract_collection__Map__clear(val* self) {
1887 const char* var_class_name;
1888 var_class_name = self == NULL ? "null" : self->type->name;
1889 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "clear", var_class_name);
1890 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 374);
1891 show_backtrace(1);
1892 RET_LABEL:;
1893 }
1894 /* method abstract_collection#Map#clear for (self: Object) */
1895 void VIRTUAL_abstract_collection__Map__clear(val* self) {
1896 abstract_collection__Map__clear(self);
1897 RET_LABEL:;
1898 }
1899 /* method abstract_collection#Map#values for (self: Map[Object, nullable Object]): RemovableCollection[nullable Object] */
1900 val* abstract_collection__Map__values(val* self) {
1901 val* var /* : RemovableCollection[nullable Object] */;
1902 const char* var_class_name;
1903 var_class_name = self == NULL ? "null" : self->type->name;
1904 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "values", var_class_name);
1905 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 377);
1906 show_backtrace(1);
1907 RET_LABEL:;
1908 return var;
1909 }
1910 /* method abstract_collection#Map#values for (self: Object): Collection[nullable Object] */
1911 val* VIRTUAL_abstract_collection__Map__values(val* self) {
1912 val* var /* : Collection[nullable Object] */;
1913 val* var1 /* : RemovableCollection[nullable Object] */;
1914 var1 = abstract_collection__Map__values(self);
1915 var = var1;
1916 RET_LABEL:;
1917 return var;
1918 }
1919 /* method abstract_collection#Map#keys for (self: Map[Object, nullable Object]): RemovableCollection[Object] */
1920 val* abstract_collection__Map__keys(val* self) {
1921 val* var /* : RemovableCollection[Object] */;
1922 const char* var_class_name;
1923 var_class_name = self == NULL ? "null" : self->type->name;
1924 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "keys", var_class_name);
1925 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 379);
1926 show_backtrace(1);
1927 RET_LABEL:;
1928 return var;
1929 }
1930 /* method abstract_collection#Map#keys for (self: Object): Collection[Object] */
1931 val* VIRTUAL_abstract_collection__Map__keys(val* self) {
1932 val* var /* : Collection[Object] */;
1933 val* var1 /* : RemovableCollection[Object] */;
1934 var1 = abstract_collection__Map__keys(self);
1935 var = var1;
1936 RET_LABEL:;
1937 return var;
1938 }
1939 /* method abstract_collection#MapIterator#item for (self: MapIterator[Object, nullable Object]): nullable Object */
1940 val* abstract_collection__MapIterator__item(val* self) {
1941 val* var /* : nullable Object */;
1942 const char* var_class_name;
1943 var_class_name = self == NULL ? "null" : self->type->name;
1944 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "item", var_class_name);
1945 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 384);
1946 show_backtrace(1);
1947 RET_LABEL:;
1948 return var;
1949 }
1950 /* method abstract_collection#MapIterator#item for (self: Object): nullable Object */
1951 val* VIRTUAL_abstract_collection__MapIterator__item(val* self) {
1952 val* var /* : nullable Object */;
1953 val* var1 /* : nullable Object */;
1954 var1 = abstract_collection__MapIterator__item(self);
1955 var = var1;
1956 RET_LABEL:;
1957 return var;
1958 }
1959 /* method abstract_collection#MapIterator#key for (self: MapIterator[Object, nullable Object]): Object */
1960 val* abstract_collection__MapIterator__key(val* self) {
1961 val* var /* : Object */;
1962 const char* var_class_name;
1963 var_class_name = self == NULL ? "null" : self->type->name;
1964 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "key", var_class_name);
1965 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 388);
1966 show_backtrace(1);
1967 RET_LABEL:;
1968 return var;
1969 }
1970 /* method abstract_collection#MapIterator#key for (self: Object): Object */
1971 val* VIRTUAL_abstract_collection__MapIterator__key(val* self) {
1972 val* var /* : Object */;
1973 val* var1 /* : Object */;
1974 var1 = abstract_collection__MapIterator__key(self);
1975 var = var1;
1976 RET_LABEL:;
1977 return var;
1978 }
1979 /* method abstract_collection#MapIterator#next for (self: MapIterator[Object, nullable Object]) */
1980 void abstract_collection__MapIterator__next(val* self) {
1981 const char* var_class_name;
1982 var_class_name = self == NULL ? "null" : self->type->name;
1983 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "next", var_class_name);
1984 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 392);
1985 show_backtrace(1);
1986 RET_LABEL:;
1987 }
1988 /* method abstract_collection#MapIterator#next for (self: Object) */
1989 void VIRTUAL_abstract_collection__MapIterator__next(val* self) {
1990 abstract_collection__MapIterator__next(self);
1991 RET_LABEL:;
1992 }
1993 /* method abstract_collection#MapIterator#is_ok for (self: MapIterator[Object, nullable Object]): Bool */
1994 short int abstract_collection__MapIterator__is_ok(val* self) {
1995 short int var /* : Bool */;
1996 const char* var_class_name;
1997 var_class_name = self == NULL ? "null" : self->type->name;
1998 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "is_ok", var_class_name);
1999 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 396);
2000 show_backtrace(1);
2001 RET_LABEL:;
2002 return var;
2003 }
2004 /* method abstract_collection#MapIterator#is_ok for (self: Object): Bool */
2005 short int VIRTUAL_abstract_collection__MapIterator__is_ok(val* self) {
2006 short int var /* : Bool */;
2007 short int var1 /* : Bool */;
2008 var1 = abstract_collection__MapIterator__is_ok(self);
2009 var = var1;
2010 RET_LABEL:;
2011 return var;
2012 }
2013 /* method abstract_collection#MapKeysIterator#iterator for (self: MapKeysIterator[Object, nullable Object]): MapIterator[Object, nullable Object] */
2014 val* abstract_collection__MapKeysIterator__iterator(val* self) {
2015 val* var /* : MapIterator[Object, nullable Object] */;
2016 val* var1 /* : MapIterator[Object, nullable Object] */;
2017 var1 = self->attrs[COLOR_abstract_collection__MapKeysIterator___64diterator].val; /* @iterator on <self:MapKeysIterator[Object, nullable Object]> */
2018 if (var1 == NULL) {
2019 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @iterator");
2020 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 406);
2021 show_backtrace(1);
2022 }
2023 var = var1;
2024 RET_LABEL:;
2025 return var;
2026 }
2027 /* method abstract_collection#MapKeysIterator#iterator for (self: Object): MapIterator[Object, nullable Object] */
2028 val* VIRTUAL_abstract_collection__MapKeysIterator__iterator(val* self) {
2029 val* var /* : MapIterator[Object, nullable Object] */;
2030 val* var1 /* : MapIterator[Object, nullable Object] */;
2031 var1 = abstract_collection__MapKeysIterator__iterator(self);
2032 var = var1;
2033 RET_LABEL:;
2034 return var;
2035 }
2036 /* method abstract_collection#MapKeysIterator#iterator= for (self: MapKeysIterator[Object, nullable Object], MapIterator[Object, nullable Object]) */
2037 void abstract_collection__MapKeysIterator__iterator_61d(val* self, val* p0) {
2038 short int var /* : Bool */;
2039 int cltype;
2040 int idtype;
2041 const struct type* type_struct;
2042 const char* var_class_name;
2043 /* Covariant cast for argument 0 (iterator) <p0:MapIterator[Object, nullable Object]> isa MapIterator[MapKeysIterator#0, MapKeysIterator#1] */
2044 /* <p0:MapIterator[Object, nullable Object]> isa MapIterator[MapKeysIterator#0, MapKeysIterator#1] */
2045 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__MapIteratorabstract_collection__MapKeysIterator_FT0abstract_collection__MapKeysIterator_FT1];
2046 cltype = type_struct->color;
2047 idtype = type_struct->id;
2048 if(cltype >= p0->type->table_size) {
2049 var = 0;
2050 } else {
2051 var = p0->type->type_table[cltype] == idtype;
2052 }
2053 if (!var) {
2054 var_class_name = p0 == NULL ? "null" : p0->type->name;
2055 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapIterator[MapKeysIterator#0, MapKeysIterator#1]", var_class_name);
2056 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 406);
2057 show_backtrace(1);
2058 }
2059 self->attrs[COLOR_abstract_collection__MapKeysIterator___64diterator].val = p0; /* @iterator on <self:MapKeysIterator[Object, nullable Object]> */
2060 RET_LABEL:;
2061 }
2062 /* method abstract_collection#MapKeysIterator#iterator= for (self: Object, MapIterator[Object, nullable Object]) */
2063 void VIRTUAL_abstract_collection__MapKeysIterator__iterator_61d(val* self, val* p0) {
2064 abstract_collection__MapKeysIterator__iterator_61d(self, p0);
2065 RET_LABEL:;
2066 }
2067 /* method abstract_collection#MapKeysIterator#is_ok for (self: MapKeysIterator[Object, nullable Object]): Bool */
2068 short int abstract_collection__MapKeysIterator__is_ok(val* self) {
2069 short int var /* : Bool */;
2070 val* var1 /* : MapIterator[Object, nullable Object] */;
2071 short int var2 /* : Bool */;
2072 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__MapKeysIterator__iterator]))(self) /* iterator on <self:MapKeysIterator[Object, nullable Object]>*/;
2073 var2 = ((short int (*)(val*))(var1->class->vft[COLOR_abstract_collection__MapIterator__is_ok]))(var1) /* is_ok on <var1:MapIterator[Object, nullable Object]>*/;
2074 var = var2;
2075 goto RET_LABEL;
2076 RET_LABEL:;
2077 return var;
2078 }
2079 /* method abstract_collection#MapKeysIterator#is_ok for (self: Object): Bool */
2080 short int VIRTUAL_abstract_collection__MapKeysIterator__is_ok(val* self) {
2081 short int var /* : Bool */;
2082 short int var1 /* : Bool */;
2083 var1 = abstract_collection__MapKeysIterator__is_ok(self);
2084 var = var1;
2085 RET_LABEL:;
2086 return var;
2087 }
2088 /* method abstract_collection#MapKeysIterator#next for (self: MapKeysIterator[Object, nullable Object]) */
2089 void abstract_collection__MapKeysIterator__next(val* self) {
2090 val* var /* : MapIterator[Object, nullable Object] */;
2091 var = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__MapKeysIterator__iterator]))(self) /* iterator on <self:MapKeysIterator[Object, nullable Object]>*/;
2092 ((void (*)(val*))(var->class->vft[COLOR_abstract_collection__MapIterator__next]))(var) /* next on <var:MapIterator[Object, nullable Object]>*/;
2093 RET_LABEL:;
2094 }
2095 /* method abstract_collection#MapKeysIterator#next for (self: Object) */
2096 void VIRTUAL_abstract_collection__MapKeysIterator__next(val* self) {
2097 abstract_collection__MapKeysIterator__next(self);
2098 RET_LABEL:;
2099 }
2100 /* method abstract_collection#MapKeysIterator#item for (self: MapKeysIterator[Object, nullable Object]): Object */
2101 val* abstract_collection__MapKeysIterator__item(val* self) {
2102 val* var /* : Object */;
2103 val* var1 /* : MapIterator[Object, nullable Object] */;
2104 val* var2 /* : Object */;
2105 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__MapKeysIterator__iterator]))(self) /* iterator on <self:MapKeysIterator[Object, nullable Object]>*/;
2106 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_abstract_collection__MapIterator__key]))(var1) /* key on <var1:MapIterator[Object, nullable Object]>*/;
2107 var = var2;
2108 goto RET_LABEL;
2109 RET_LABEL:;
2110 return var;
2111 }
2112 /* method abstract_collection#MapKeysIterator#item for (self: Object): nullable Object */
2113 val* VIRTUAL_abstract_collection__MapKeysIterator__item(val* self) {
2114 val* var /* : nullable Object */;
2115 val* var1 /* : Object */;
2116 var1 = abstract_collection__MapKeysIterator__item(self);
2117 var = var1;
2118 RET_LABEL:;
2119 return var;
2120 }
2121 /* method abstract_collection#MapKeysIterator#init for (self: MapKeysIterator[Object, nullable Object], MapIterator[Object, nullable Object]) */
2122 void abstract_collection__MapKeysIterator__init(val* self, val* p0) {
2123 short int var /* : Bool */;
2124 int cltype;
2125 int idtype;
2126 const struct type* type_struct;
2127 const char* var_class_name;
2128 /* Covariant cast for argument 0 (iterator) <p0:MapIterator[Object, nullable Object]> isa MapIterator[MapKeysIterator#0, MapKeysIterator#1] */
2129 /* <p0:MapIterator[Object, nullable Object]> isa MapIterator[MapKeysIterator#0, MapKeysIterator#1] */
2130 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__MapIteratorabstract_collection__MapKeysIterator_FT0abstract_collection__MapKeysIterator_FT1];
2131 cltype = type_struct->color;
2132 idtype = type_struct->id;
2133 if(cltype >= p0->type->table_size) {
2134 var = 0;
2135 } else {
2136 var = p0->type->type_table[cltype] == idtype;
2137 }
2138 if (!var) {
2139 var_class_name = p0 == NULL ? "null" : p0->type->name;
2140 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapIterator[MapKeysIterator#0, MapKeysIterator#1]", var_class_name);
2141 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 403);
2142 show_backtrace(1);
2143 }
2144 self->attrs[COLOR_abstract_collection__MapKeysIterator___64diterator].val = p0; /* @iterator on <self:MapKeysIterator[Object, nullable Object]> */
2145 RET_LABEL:;
2146 }
2147 /* method abstract_collection#MapKeysIterator#init for (self: Object, MapIterator[Object, nullable Object]) */
2148 void VIRTUAL_abstract_collection__MapKeysIterator__init(val* self, val* p0) {
2149 abstract_collection__MapKeysIterator__init(self, p0);
2150 RET_LABEL:;
2151 }
2152 /* method abstract_collection#MapValuesIterator#iterator for (self: MapValuesIterator[Object, nullable Object]): MapIterator[Object, nullable Object] */
2153 val* abstract_collection__MapValuesIterator__iterator(val* self) {
2154 val* var /* : MapIterator[Object, nullable Object] */;
2155 val* var1 /* : MapIterator[Object, nullable Object] */;
2156 var1 = self->attrs[COLOR_abstract_collection__MapValuesIterator___64diterator].val; /* @iterator on <self:MapValuesIterator[Object, nullable Object]> */
2157 if (var1 == NULL) {
2158 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @iterator");
2159 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 417);
2160 show_backtrace(1);
2161 }
2162 var = var1;
2163 RET_LABEL:;
2164 return var;
2165 }
2166 /* method abstract_collection#MapValuesIterator#iterator for (self: Object): MapIterator[Object, nullable Object] */
2167 val* VIRTUAL_abstract_collection__MapValuesIterator__iterator(val* self) {
2168 val* var /* : MapIterator[Object, nullable Object] */;
2169 val* var1 /* : MapIterator[Object, nullable Object] */;
2170 var1 = abstract_collection__MapValuesIterator__iterator(self);
2171 var = var1;
2172 RET_LABEL:;
2173 return var;
2174 }
2175 /* method abstract_collection#MapValuesIterator#iterator= for (self: MapValuesIterator[Object, nullable Object], MapIterator[Object, nullable Object]) */
2176 void abstract_collection__MapValuesIterator__iterator_61d(val* self, val* p0) {
2177 short int var /* : Bool */;
2178 int cltype;
2179 int idtype;
2180 const struct type* type_struct;
2181 const char* var_class_name;
2182 /* Covariant cast for argument 0 (iterator) <p0:MapIterator[Object, nullable Object]> isa MapIterator[MapValuesIterator#0, MapValuesIterator#1] */
2183 /* <p0:MapIterator[Object, nullable Object]> isa MapIterator[MapValuesIterator#0, MapValuesIterator#1] */
2184 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__MapIteratorabstract_collection__MapValuesIterator_FT0abstract_collection__MapValuesIterator_FT1];
2185 cltype = type_struct->color;
2186 idtype = type_struct->id;
2187 if(cltype >= p0->type->table_size) {
2188 var = 0;
2189 } else {
2190 var = p0->type->type_table[cltype] == idtype;
2191 }
2192 if (!var) {
2193 var_class_name = p0 == NULL ? "null" : p0->type->name;
2194 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapIterator[MapValuesIterator#0, MapValuesIterator#1]", var_class_name);
2195 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 417);
2196 show_backtrace(1);
2197 }
2198 self->attrs[COLOR_abstract_collection__MapValuesIterator___64diterator].val = p0; /* @iterator on <self:MapValuesIterator[Object, nullable Object]> */
2199 RET_LABEL:;
2200 }
2201 /* method abstract_collection#MapValuesIterator#iterator= for (self: Object, MapIterator[Object, nullable Object]) */
2202 void VIRTUAL_abstract_collection__MapValuesIterator__iterator_61d(val* self, val* p0) {
2203 abstract_collection__MapValuesIterator__iterator_61d(self, p0);
2204 RET_LABEL:;
2205 }
2206 /* method abstract_collection#MapValuesIterator#is_ok for (self: MapValuesIterator[Object, nullable Object]): Bool */
2207 short int abstract_collection__MapValuesIterator__is_ok(val* self) {
2208 short int var /* : Bool */;
2209 val* var1 /* : MapIterator[Object, nullable Object] */;
2210 short int var2 /* : Bool */;
2211 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__MapValuesIterator__iterator]))(self) /* iterator on <self:MapValuesIterator[Object, nullable Object]>*/;
2212 var2 = ((short int (*)(val*))(var1->class->vft[COLOR_abstract_collection__MapIterator__is_ok]))(var1) /* is_ok on <var1:MapIterator[Object, nullable Object]>*/;
2213 var = var2;
2214 goto RET_LABEL;
2215 RET_LABEL:;
2216 return var;
2217 }
2218 /* method abstract_collection#MapValuesIterator#is_ok for (self: Object): Bool */
2219 short int VIRTUAL_abstract_collection__MapValuesIterator__is_ok(val* self) {
2220 short int var /* : Bool */;
2221 short int var1 /* : Bool */;
2222 var1 = abstract_collection__MapValuesIterator__is_ok(self);
2223 var = var1;
2224 RET_LABEL:;
2225 return var;
2226 }
2227 /* method abstract_collection#MapValuesIterator#next for (self: MapValuesIterator[Object, nullable Object]) */
2228 void abstract_collection__MapValuesIterator__next(val* self) {
2229 val* var /* : MapIterator[Object, nullable Object] */;
2230 var = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__MapValuesIterator__iterator]))(self) /* iterator on <self:MapValuesIterator[Object, nullable Object]>*/;
2231 ((void (*)(val*))(var->class->vft[COLOR_abstract_collection__MapIterator__next]))(var) /* next on <var:MapIterator[Object, nullable Object]>*/;
2232 RET_LABEL:;
2233 }
2234 /* method abstract_collection#MapValuesIterator#next for (self: Object) */
2235 void VIRTUAL_abstract_collection__MapValuesIterator__next(val* self) {
2236 abstract_collection__MapValuesIterator__next(self);
2237 RET_LABEL:;
2238 }
2239 /* method abstract_collection#MapValuesIterator#item for (self: MapValuesIterator[Object, nullable Object]): nullable Object */
2240 val* abstract_collection__MapValuesIterator__item(val* self) {
2241 val* var /* : nullable Object */;
2242 val* var1 /* : MapIterator[Object, nullable Object] */;
2243 val* var2 /* : nullable Object */;
2244 var1 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__MapValuesIterator__iterator]))(self) /* iterator on <self:MapValuesIterator[Object, nullable Object]>*/;
2245 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_abstract_collection__MapIterator__item]))(var1) /* item on <var1:MapIterator[Object, nullable Object]>*/;
2246 var = var2;
2247 goto RET_LABEL;
2248 RET_LABEL:;
2249 return var;
2250 }
2251 /* method abstract_collection#MapValuesIterator#item for (self: Object): nullable Object */
2252 val* VIRTUAL_abstract_collection__MapValuesIterator__item(val* self) {
2253 val* var /* : nullable Object */;
2254 val* var1 /* : nullable Object */;
2255 var1 = abstract_collection__MapValuesIterator__item(self);
2256 var = var1;
2257 RET_LABEL:;
2258 return var;
2259 }
2260 /* method abstract_collection#MapValuesIterator#init for (self: MapValuesIterator[Object, nullable Object], MapIterator[Object, nullable Object]) */
2261 void abstract_collection__MapValuesIterator__init(val* self, val* p0) {
2262 short int var /* : Bool */;
2263 int cltype;
2264 int idtype;
2265 const struct type* type_struct;
2266 const char* var_class_name;
2267 /* Covariant cast for argument 0 (iterator) <p0:MapIterator[Object, nullable Object]> isa MapIterator[MapValuesIterator#0, MapValuesIterator#1] */
2268 /* <p0:MapIterator[Object, nullable Object]> isa MapIterator[MapValuesIterator#0, MapValuesIterator#1] */
2269 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__MapIteratorabstract_collection__MapValuesIterator_FT0abstract_collection__MapValuesIterator_FT1];
2270 cltype = type_struct->color;
2271 idtype = type_struct->id;
2272 if(cltype >= p0->type->table_size) {
2273 var = 0;
2274 } else {
2275 var = p0->type->type_table[cltype] == idtype;
2276 }
2277 if (!var) {
2278 var_class_name = p0 == NULL ? "null" : p0->type->name;
2279 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapIterator[MapValuesIterator#0, MapValuesIterator#1]", var_class_name);
2280 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 414);
2281 show_backtrace(1);
2282 }
2283 self->attrs[COLOR_abstract_collection__MapValuesIterator___64diterator].val = p0; /* @iterator on <self:MapValuesIterator[Object, nullable Object]> */
2284 RET_LABEL:;
2285 }
2286 /* method abstract_collection#MapValuesIterator#init for (self: Object, MapIterator[Object, nullable Object]) */
2287 void VIRTUAL_abstract_collection__MapValuesIterator__init(val* self, val* p0) {
2288 abstract_collection__MapValuesIterator__init(self, p0);
2289 RET_LABEL:;
2290 }
2291 /* method abstract_collection#SequenceRead#first for (self: SequenceRead[nullable Object]): nullable Object */
2292 val* abstract_collection__SequenceRead__first(val* self) {
2293 val* var /* : nullable Object */;
2294 short int var1 /* : Bool */;
2295 short int var2 /* : Bool */;
2296 long var3 /* : Int */;
2297 val* var4 /* : nullable Object */;
2298 var1 = ((short int (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__is_empty]))(self) /* is_empty on <self:SequenceRead[nullable Object]>*/;
2299 var2 = !var1;
2300 if (!var2) {
2301 fprintf(stderr, "Runtime error: %s", "Assert \'not_empty\' failed");
2302 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 433);
2303 show_backtrace(1);
2304 }
2305 var3 = 0;
2306 var4 = ((val* (*)(val*, long))(self->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(self, var3) /* [] on <self:SequenceRead[nullable Object]>*/;
2307 var = var4;
2308 goto RET_LABEL;
2309 RET_LABEL:;
2310 return var;
2311 }
2312 /* method abstract_collection#SequenceRead#first for (self: Object): nullable Object */
2313 val* VIRTUAL_abstract_collection__SequenceRead__first(val* self) {
2314 val* var /* : nullable Object */;
2315 val* var1 /* : nullable Object */;
2316 var1 = abstract_collection__SequenceRead__first(self);
2317 var = var1;
2318 RET_LABEL:;
2319 return var;
2320 }
2321 /* method abstract_collection#SequenceRead#[] for (self: SequenceRead[nullable Object], Int): nullable Object */
2322 val* abstract_collection__SequenceRead___91d_93d(val* self, long p0) {
2323 val* var /* : nullable Object */;
2324 const char* var_class_name;
2325 var_class_name = self == NULL ? "null" : self->type->name;
2326 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "[]", var_class_name);
2327 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 437);
2328 show_backtrace(1);
2329 RET_LABEL:;
2330 return var;
2331 }
2332 /* method abstract_collection#SequenceRead#[] for (self: Object, Int): nullable Object */
2333 val* VIRTUAL_abstract_collection__SequenceRead___91d_93d(val* self, long p0) {
2334 val* var /* : nullable Object */;
2335 val* var1 /* : nullable Object */;
2336 var1 = abstract_collection__SequenceRead___91d_93d(self, p0);
2337 var = var1;
2338 RET_LABEL:;
2339 return var;
2340 }
2341 /* method abstract_collection#SequenceRead#last for (self: SequenceRead[nullable Object]): nullable Object */
2342 val* abstract_collection__SequenceRead__last(val* self) {
2343 val* var /* : nullable Object */;
2344 short int var1 /* : Bool */;
2345 short int var2 /* : Bool */;
2346 long var3 /* : Int */;
2347 long var4 /* : Int */;
2348 long var5 /* : Int */;
2349 long var7 /* : Int */;
2350 val* var8 /* : nullable Object */;
2351 var1 = ((short int (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__is_empty]))(self) /* is_empty on <self:SequenceRead[nullable Object]>*/;
2352 var2 = !var1;
2353 if (!var2) {
2354 fprintf(stderr, "Runtime error: %s", "Assert \'not_empty\' failed");
2355 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 446);
2356 show_backtrace(1);
2357 }
2358 var3 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:SequenceRead[nullable Object]>*/;
2359 var4 = 1;
2360 { /* Inline kernel#Int#- (var3,var4) */
2361 var7 = var3 - var4;
2362 var5 = var7;
2363 goto RET_LABEL6;
2364 RET_LABEL6:(void)0;
2365 }
2366 var8 = ((val* (*)(val*, long))(self->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(self, var5) /* [] on <self:SequenceRead[nullable Object]>*/;
2367 var = var8;
2368 goto RET_LABEL;
2369 RET_LABEL:;
2370 return var;
2371 }
2372 /* method abstract_collection#SequenceRead#last for (self: Object): nullable Object */
2373 val* VIRTUAL_abstract_collection__SequenceRead__last(val* self) {
2374 val* var /* : nullable Object */;
2375 val* var1 /* : nullable Object */;
2376 var1 = abstract_collection__SequenceRead__last(self);
2377 var = var1;
2378 RET_LABEL:;
2379 return var;
2380 }
2381 /* method abstract_collection#SequenceRead#index_of for (self: SequenceRead[nullable Object], nullable Object): Int */
2382 long abstract_collection__SequenceRead__index_of(val* self, val* p0) {
2383 long var /* : Int */;
2384 short int var1 /* : Bool */;
2385 int cltype;
2386 int idtype;
2387 const struct type* type_struct;
2388 short int is_nullable;
2389 const char* var_class_name;
2390 val* var_item /* var item: nullable Object */;
2391 val* var2 /* : Iterator[nullable Object] */;
2392 val* var_i /* var i: IndexedIterator[nullable Object] */;
2393 short int var3 /* : Bool */;
2394 val* var4 /* : nullable Object */;
2395 short int var5 /* : Bool */;
2396 long var6 /* : Int */;
2397 long var7 /* : Int */;
2398 long var8 /* : Int */;
2399 long var10 /* : Int */;
2400 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa SequenceRead#0 */
2401 /* <p0:nullable Object> isa SequenceRead#0 */
2402 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__SequenceRead_FT0];
2403 cltype = type_struct->color;
2404 idtype = type_struct->id;
2405 is_nullable = type_struct->is_nullable;
2406 if(p0 == NULL) {
2407 var1 = is_nullable;
2408 } else {
2409 if(cltype >= p0->type->table_size) {
2410 var1 = 0;
2411 } else {
2412 var1 = p0->type->type_table[cltype] == idtype;
2413 }
2414 }
2415 if (!var1) {
2416 var_class_name = p0 == NULL ? "null" : p0->type->name;
2417 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "SequenceRead#0", var_class_name);
2418 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 450);
2419 show_backtrace(1);
2420 }
2421 var_item = p0;
2422 var2 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__iterator]))(self) /* iterator on <self:SequenceRead[nullable Object]>*/;
2423 var_i = var2;
2424 for(;;) {
2425 var3 = ((short int (*)(val*))(var_i->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var_i) /* is_ok on <var_i:IndexedIterator[nullable Object]>*/;
2426 if (!var3) break;
2427 var4 = ((val* (*)(val*))(var_i->class->vft[COLOR_abstract_collection__Iterator__item]))(var_i) /* item on <var_i:IndexedIterator[nullable Object]>*/;
2428 if (var4 == NULL) {
2429 var5 = (var_item == NULL);
2430 } else {
2431 var5 = ((short int (*)(val*, val*))(var4->class->vft[COLOR_kernel__Object___61d_61d]))(var4, var_item) /* == on <var4:nullable Object>*/;
2432 }
2433 if (var5){
2434 var6 = ((long (*)(val*))(var_i->class->vft[COLOR_abstract_collection__IndexedIterator__index]))(var_i) /* index on <var_i:IndexedIterator[nullable Object]>*/;
2435 var = var6;
2436 goto RET_LABEL;
2437 } else {
2438 }
2439 ((void (*)(val*))(var_i->class->vft[COLOR_abstract_collection__Iterator__next]))(var_i) /* next on <var_i:IndexedIterator[nullable Object]>*/;
2440 CONTINUE_label: (void)0;
2441 }
2442 BREAK_label: (void)0;
2443 var7 = 1;
2444 { /* Inline kernel#Int#unary - (var7) */
2445 var10 = -var7;
2446 var8 = var10;
2447 goto RET_LABEL9;
2448 RET_LABEL9:(void)0;
2449 }
2450 var = var8;
2451 goto RET_LABEL;
2452 RET_LABEL:;
2453 return var;
2454 }
2455 /* method abstract_collection#SequenceRead#index_of for (self: Object, nullable Object): Int */
2456 long VIRTUAL_abstract_collection__SequenceRead__index_of(val* self, val* p0) {
2457 long var /* : Int */;
2458 long var1 /* : Int */;
2459 var1 = abstract_collection__SequenceRead__index_of(self, p0);
2460 var = var1;
2461 RET_LABEL:;
2462 return var;
2463 }
2464 /* method abstract_collection#SequenceRead#iterator for (self: SequenceRead[nullable Object]): IndexedIterator[nullable Object] */
2465 val* abstract_collection__SequenceRead__iterator(val* self) {
2466 val* var /* : IndexedIterator[nullable Object] */;
2467 const char* var_class_name;
2468 var_class_name = self == NULL ? "null" : self->type->name;
2469 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "iterator", var_class_name);
2470 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 463);
2471 show_backtrace(1);
2472 RET_LABEL:;
2473 return var;
2474 }
2475 /* method abstract_collection#SequenceRead#iterator for (self: Object): Iterator[nullable Object] */
2476 val* VIRTUAL_abstract_collection__SequenceRead__iterator(val* self) {
2477 val* var /* : Iterator[nullable Object] */;
2478 val* var1 /* : IndexedIterator[nullable Object] */;
2479 var1 = abstract_collection__SequenceRead__iterator(self);
2480 var = var1;
2481 RET_LABEL:;
2482 return var;
2483 }
2484 /* method abstract_collection#SequenceRead#== for (self: SequenceRead[nullable Object], nullable Object): Bool */
2485 short int abstract_collection__SequenceRead___61d_61d(val* self, val* p0) {
2486 short int var /* : Bool */;
2487 val* var_o /* var o: nullable Object */;
2488 short int var1 /* : Bool */;
2489 int cltype;
2490 int idtype;
2491 short int var2 /* : Bool */;
2492 short int var3 /* : Bool */;
2493 long var4 /* : Int */;
2494 long var_l /* var l: Int */;
2495 long var5 /* : Int */;
2496 short int var6 /* : Bool */;
2497 short int var8 /* : Bool */;
2498 short int var9 /* : Bool */;
2499 short int var10 /* : Bool */;
2500 long var11 /* : Int */;
2501 long var_i /* var i: Int */;
2502 short int var12 /* : Bool */;
2503 short int var14 /* : Bool */;
2504 int cltype15;
2505 int idtype16;
2506 const char* var_class_name;
2507 short int var17 /* : Bool */;
2508 val* var18 /* : nullable Object */;
2509 val* var19 /* : nullable Object */;
2510 short int var20 /* : Bool */;
2511 short int var21 /* : Bool */;
2512 long var22 /* : Int */;
2513 long var23 /* : Int */;
2514 long var25 /* : Int */;
2515 short int var26 /* : Bool */;
2516 var_o = p0;
2517 /* <var_o:nullable Object> isa SequenceRead[nullable Object] */
2518 cltype = type_abstract_collection__SequenceReadnullable_kernel__Object.color;
2519 idtype = type_abstract_collection__SequenceReadnullable_kernel__Object.id;
2520 if(var_o == NULL) {
2521 var1 = 0;
2522 } else {
2523 if(cltype >= var_o->type->table_size) {
2524 var1 = 0;
2525 } else {
2526 var1 = var_o->type->type_table[cltype] == idtype;
2527 }
2528 }
2529 var2 = !var1;
2530 if (var2){
2531 var3 = 0;
2532 var = var3;
2533 goto RET_LABEL;
2534 } else {
2535 }
2536 var4 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:SequenceRead[nullable Object]>*/;
2537 var_l = var4;
2538 var5 = ((long (*)(val*))(var_o->class->vft[COLOR_abstract_collection__Collection__length]))(var_o) /* length on <var_o:nullable Object(SequenceRead[nullable Object])>*/;
2539 { /* Inline kernel#Int#!= (var5,var_l) */
2540 var8 = var5 == var_l;
2541 var9 = !var8;
2542 var6 = var9;
2543 goto RET_LABEL7;
2544 RET_LABEL7:(void)0;
2545 }
2546 if (var6){
2547 var10 = 0;
2548 var = var10;
2549 goto RET_LABEL;
2550 } else {
2551 }
2552 var11 = 0;
2553 var_i = var11;
2554 for(;;) {
2555 { /* Inline kernel#Int#< (var_i,var_l) */
2556 /* Covariant cast for argument 0 (i) <var_l:Int> isa OTHER */
2557 /* <var_l:Int> isa OTHER */
2558 var14 = 1; /* easy <var_l:Int> isa OTHER*/
2559 if (!var14) {
2560 var_class_name = type_kernel__Int.name;
2561 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
2562 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 265);
2563 show_backtrace(1);
2564 }
2565 var17 = var_i < var_l;
2566 var12 = var17;
2567 goto RET_LABEL13;
2568 RET_LABEL13:(void)0;
2569 }
2570 if (!var12) break;
2571 var18 = ((val* (*)(val*, long))(self->class->vft[COLOR_abstract_collection__SequenceRead___91d_93d]))(self, var_i) /* [] on <self:SequenceRead[nullable Object]>*/;
2572 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])>*/;
2573 if (var18 == NULL) {
2574 var20 = (var19 != NULL);
2575 } else {
2576 var20 = ((short int (*)(val*, val*))(var18->class->vft[COLOR_kernel__Object___33d_61d]))(var18, var19) /* != on <var18:nullable Object>*/;
2577 }
2578 if (var20){
2579 var21 = 0;
2580 var = var21;
2581 goto RET_LABEL;
2582 } else {
2583 }
2584 var22 = 1;
2585 { /* Inline kernel#Int#+ (var_i,var22) */
2586 var25 = var_i + var22;
2587 var23 = var25;
2588 goto RET_LABEL24;
2589 RET_LABEL24:(void)0;
2590 }
2591 var_i = var23;
2592 CONTINUE_label: (void)0;
2593 }
2594 BREAK_label: (void)0;
2595 var26 = 1;
2596 var = var26;
2597 goto RET_LABEL;
2598 RET_LABEL:;
2599 return var;
2600 }
2601 /* method abstract_collection#SequenceRead#== for (self: Object, nullable Object): Bool */
2602 short int VIRTUAL_abstract_collection__SequenceRead___61d_61d(val* self, val* p0) {
2603 short int var /* : Bool */;
2604 short int var1 /* : Bool */;
2605 var1 = abstract_collection__SequenceRead___61d_61d(self, p0);
2606 var = var1;
2607 RET_LABEL:;
2608 return var;
2609 }
2610 /* method abstract_collection#SequenceRead#hash for (self: SequenceRead[nullable Object]): Int */
2611 long abstract_collection__SequenceRead__hash(val* self) {
2612 long var /* : Int */;
2613 long var1 /* : Int */;
2614 long var_res /* var res: Int */;
2615 val* var2 /* : Iterator[nullable Object] */;
2616 short int var3 /* : Bool */;
2617 val* var4 /* : nullable Object */;
2618 val* var_e /* var e: nullable Object */;
2619 long var5 /* : Int */;
2620 long var6 /* : Int */;
2621 long var8 /* : Int */;
2622 var1 = 0;
2623 var_res = var1;
2624 var2 = ((val* (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__iterator]))(self) /* iterator on <self:SequenceRead[nullable Object]>*/;
2625 for(;;) {
2626 var3 = ((short int (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var2) /* is_ok on <var2:Iterator[nullable Object]>*/;
2627 if(!var3) break;
2628 var4 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__item]))(var2) /* item on <var2:Iterator[nullable Object]>*/;
2629 var_e = var4;
2630 var5 = kernel__Int__hash(var_res);
2631 { /* Inline kernel#Int#+ (var_res,var5) */
2632 var8 = var_res + var5;
2633 var6 = var8;
2634 goto RET_LABEL7;
2635 RET_LABEL7:(void)0;
2636 }
2637 var_res = var6;
2638 CONTINUE_label: (void)0;
2639 ((void (*)(val*))(var2->class->vft[COLOR_abstract_collection__Iterator__next]))(var2) /* next on <var2:Iterator[nullable Object]>*/;
2640 }
2641 BREAK_label: (void)0;
2642 var = var_res;
2643 goto RET_LABEL;
2644 RET_LABEL:;
2645 return var;
2646 }
2647 /* method abstract_collection#SequenceRead#hash for (self: Object): Int */
2648 long VIRTUAL_abstract_collection__SequenceRead__hash(val* self) {
2649 long var /* : Int */;
2650 long var1 /* : Int */;
2651 var1 = abstract_collection__SequenceRead__hash(self);
2652 var = var1;
2653 RET_LABEL:;
2654 return var;
2655 }
2656 /* method abstract_collection#Sequence#first= for (self: Sequence[nullable Object], nullable Object) */
2657 void abstract_collection__Sequence__first_61d(val* self, val* p0) {
2658 short int var /* : Bool */;
2659 int cltype;
2660 int idtype;
2661 const struct type* type_struct;
2662 short int is_nullable;
2663 const char* var_class_name;
2664 val* var_item /* var item: nullable Object */;
2665 long var1 /* : Int */;
2666 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa Sequence#0 */
2667 /* <p0:nullable Object> isa Sequence#0 */
2668 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Sequence_FT0];
2669 cltype = type_struct->color;
2670 idtype = type_struct->id;
2671 is_nullable = type_struct->is_nullable;
2672 if(p0 == NULL) {
2673 var = is_nullable;
2674 } else {
2675 if(cltype >= p0->type->table_size) {
2676 var = 0;
2677 } else {
2678 var = p0->type->type_table[cltype] == idtype;
2679 }
2680 }
2681 if (!var) {
2682 var_class_name = p0 == NULL ? "null" : p0->type->name;
2683 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Sequence#0", var_class_name);
2684 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 494);
2685 show_backtrace(1);
2686 }
2687 var_item = p0;
2688 var1 = 0;
2689 ((void (*)(val*, long, val*))(self->class->vft[COLOR_abstract_collection__Sequence___91d_93d_61d]))(self, var1, var_item) /* []= on <self:Sequence[nullable Object]>*/;
2690 RET_LABEL:;
2691 }
2692 /* method abstract_collection#Sequence#first= for (self: Object, nullable Object) */
2693 void VIRTUAL_abstract_collection__Sequence__first_61d(val* self, val* p0) {
2694 abstract_collection__Sequence__first_61d(self, p0);
2695 RET_LABEL:;
2696 }
2697 /* method abstract_collection#Sequence#last= for (self: Sequence[nullable Object], nullable Object) */
2698 void abstract_collection__Sequence__last_61d(val* self, val* p0) {
2699 short int var /* : Bool */;
2700 int cltype;
2701 int idtype;
2702 const struct type* type_struct;
2703 short int is_nullable;
2704 const char* var_class_name;
2705 val* var_item /* var item: nullable Object */;
2706 long var1 /* : Int */;
2707 long var_l /* var l: Int */;
2708 long var2 /* : Int */;
2709 short int var3 /* : Bool */;
2710 short int var5 /* : Bool */;
2711 int cltype6;
2712 int idtype7;
2713 const char* var_class_name8;
2714 short int var9 /* : Bool */;
2715 long var10 /* : Int */;
2716 long var11 /* : Int */;
2717 long var13 /* : Int */;
2718 long var14 /* : Int */;
2719 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa Sequence#0 */
2720 /* <p0:nullable Object> isa Sequence#0 */
2721 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Sequence_FT0];
2722 cltype = type_struct->color;
2723 idtype = type_struct->id;
2724 is_nullable = type_struct->is_nullable;
2725 if(p0 == NULL) {
2726 var = is_nullable;
2727 } else {
2728 if(cltype >= p0->type->table_size) {
2729 var = 0;
2730 } else {
2731 var = p0->type->type_table[cltype] == idtype;
2732 }
2733 }
2734 if (!var) {
2735 var_class_name = p0 == NULL ? "null" : p0->type->name;
2736 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Sequence#0", var_class_name);
2737 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 499);
2738 show_backtrace(1);
2739 }
2740 var_item = p0;
2741 var1 = ((long (*)(val*))(self->class->vft[COLOR_abstract_collection__Collection__length]))(self) /* length on <self:Sequence[nullable Object]>*/;
2742 var_l = var1;
2743 var2 = 0;
2744 { /* Inline kernel#Int#> (var_l,var2) */
2745 /* Covariant cast for argument 0 (i) <var2:Int> isa OTHER */
2746 /* <var2:Int> isa OTHER */
2747 var5 = 1; /* easy <var2:Int> isa OTHER*/
2748 if (!var5) {
2749 var_class_name8 = type_kernel__Int.name;
2750 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name8);
2751 fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 267);
2752 show_backtrace(1);
2753 }
2754 var9 = var_l > var2;
2755 var3 = var9;
2756 goto RET_LABEL4;
2757 RET_LABEL4:(void)0;
2758 }
2759 if (var3){
2760 var10 = 1;
2761 { /* Inline kernel#Int#- (var_l,var10) */
2762 var13 = var_l - var10;
2763 var11 = var13;
2764 goto RET_LABEL12;
2765 RET_LABEL12:(void)0;
2766 }
2767 ((void (*)(val*, long, val*))(self->class->vft[COLOR_abstract_collection__Sequence___91d_93d_61d]))(self, var11, var_item) /* []= on <self:Sequence[nullable Object]>*/;
2768 } else {
2769 var14 = 0;
2770 ((void (*)(val*, long, val*))(self->class->vft[COLOR_abstract_collection__Sequence___91d_93d_61d]))(self, var14, var_item) /* []= on <self:Sequence[nullable Object]>*/;
2771 }
2772 RET_LABEL:;
2773 }
2774 /* method abstract_collection#Sequence#last= for (self: Object, nullable Object) */
2775 void VIRTUAL_abstract_collection__Sequence__last_61d(val* self, val* p0) {
2776 abstract_collection__Sequence__last_61d(self, p0);
2777 RET_LABEL:;
2778 }
2779 /* method abstract_collection#Sequence#add for (self: Sequence[nullable Object], nullable Object) */
2780 void abstract_collection__Sequence__add(val* self, val* p0) {
2781 short int var /* : Bool */;
2782 int cltype;
2783 int idtype;
2784 const struct type* type_struct;
2785 short int is_nullable;
2786 const char* var_class_name;
2787 val* var_e /* var e: nullable Object */;
2788 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa SimpleCollection#0 */
2789 /* <p0:nullable Object> isa SimpleCollection#0 */
2790 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__SimpleCollection_FT0];
2791 cltype = type_struct->color;
2792 idtype = type_struct->id;
2793 is_nullable = type_struct->is_nullable;
2794 if(p0 == NULL) {
2795 var = is_nullable;
2796 } else {
2797 if(cltype >= p0->type->table_size) {
2798 var = 0;
2799 } else {
2800 var = p0->type->type_table[cltype] == idtype;
2801 }
2802 }
2803 if (!var) {
2804 var_class_name = p0 == NULL ? "null" : p0->type->name;
2805 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "SimpleCollection#0", var_class_name);
2806 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 511);
2807 show_backtrace(1);
2808 }
2809 var_e = p0;
2810 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__Sequence__push]))(self, var_e) /* push on <self:Sequence[nullable Object]>*/;
2811 RET_LABEL:;
2812 }
2813 /* method abstract_collection#Sequence#add for (self: Object, nullable Object) */
2814 void VIRTUAL_abstract_collection__Sequence__add(val* self, val* p0) {
2815 abstract_collection__Sequence__add(self, p0);
2816 RET_LABEL:;
2817 }
2818 /* method abstract_collection#Sequence#push for (self: Sequence[nullable Object], nullable Object) */
2819 void abstract_collection__Sequence__push(val* self, val* p0) {
2820 short int var /* : Bool */;
2821 int cltype;
2822 int idtype;
2823 const struct type* type_struct;
2824 short int is_nullable;
2825 const char* var_class_name;
2826 const char* var_class_name1;
2827 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa Sequence#0 */
2828 /* <p0:nullable Object> isa Sequence#0 */
2829 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Sequence_FT0];
2830 cltype = type_struct->color;
2831 idtype = type_struct->id;
2832 is_nullable = type_struct->is_nullable;
2833 if(p0 == NULL) {
2834 var = is_nullable;
2835 } else {
2836 if(cltype >= p0->type->table_size) {
2837 var = 0;
2838 } else {
2839 var = p0->type->type_table[cltype] == idtype;
2840 }
2841 }
2842 if (!var) {
2843 var_class_name = p0 == NULL ? "null" : p0->type->name;
2844 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Sequence#0", var_class_name);
2845 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 514);
2846 show_backtrace(1);
2847 }
2848 var_class_name1 = self == NULL ? "null" : self->type->name;
2849 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "push", var_class_name1);
2850 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 514);
2851 show_backtrace(1);
2852 RET_LABEL:;
2853 }
2854 /* method abstract_collection#Sequence#push for (self: Object, nullable Object) */
2855 void VIRTUAL_abstract_collection__Sequence__push(val* self, val* p0) {
2856 abstract_collection__Sequence__push(self, p0);
2857 RET_LABEL:;
2858 }
2859 /* method abstract_collection#Sequence#append for (self: Sequence[nullable Object], Collection[nullable Object]) */
2860 void abstract_collection__Sequence__append(val* self, val* p0) {
2861 short int var /* : Bool */;
2862 int cltype;
2863 int idtype;
2864 const struct type* type_struct;
2865 const char* var_class_name;
2866 val* var_coll /* var coll: Collection[nullable Object] */;
2867 val* var1 /* : Iterator[nullable Object] */;
2868 short int var2 /* : Bool */;
2869 val* var3 /* : nullable Object */;
2870 val* var_i /* var i: nullable Object */;
2871 /* Covariant cast for argument 0 (coll) <p0:Collection[nullable Object]> isa Collection[Sequence#0] */
2872 /* <p0:Collection[nullable Object]> isa Collection[Sequence#0] */
2873 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collectionabstract_collection__Sequence_FT0];
2874 cltype = type_struct->color;
2875 idtype = type_struct->id;
2876 if(cltype >= p0->type->table_size) {
2877 var = 0;
2878 } else {
2879 var = p0->type->type_table[cltype] == idtype;
2880 }
2881 if (!var) {
2882 var_class_name = p0 == NULL ? "null" : p0->type->name;
2883 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection[Sequence#0]", var_class_name);
2884 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 517);
2885 show_backtrace(1);
2886 }
2887 var_coll = p0;
2888 var1 = ((val* (*)(val*))(var_coll->class->vft[COLOR_abstract_collection__Collection__iterator]))(var_coll) /* iterator on <var_coll:Collection[nullable Object]>*/;
2889 for(;;) {
2890 var2 = ((short int (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var1) /* is_ok on <var1:Iterator[nullable Object]>*/;
2891 if(!var2) break;
2892 var3 = ((val* (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__item]))(var1) /* item on <var1:Iterator[nullable Object]>*/;
2893 var_i = var3;
2894 ((void (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__Sequence__push]))(self, var_i) /* push on <self:Sequence[nullable Object]>*/;
2895 CONTINUE_label: (void)0;
2896 ((void (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__next]))(var1) /* next on <var1:Iterator[nullable Object]>*/;
2897 }
2898 BREAK_label: (void)0;
2899 RET_LABEL:;
2900 }
2901 /* method abstract_collection#Sequence#append for (self: Object, Collection[nullable Object]) */
2902 void VIRTUAL_abstract_collection__Sequence__append(val* self, val* p0) {
2903 abstract_collection__Sequence__append(self, p0);
2904 RET_LABEL:;
2905 }
2906 /* method abstract_collection#Sequence#pop for (self: Sequence[nullable Object]): nullable Object */
2907 val* abstract_collection__Sequence__pop(val* self) {
2908 val* var /* : nullable Object */;
2909 const char* var_class_name;
2910 var_class_name = self == NULL ? "null" : self->type->name;
2911 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "pop", var_class_name);
2912 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 520);
2913 show_backtrace(1);
2914 RET_LABEL:;
2915 return var;
2916 }
2917 /* method abstract_collection#Sequence#pop for (self: Object): nullable Object */
2918 val* VIRTUAL_abstract_collection__Sequence__pop(val* self) {
2919 val* var /* : nullable Object */;
2920 val* var1 /* : nullable Object */;
2921 var1 = abstract_collection__Sequence__pop(self);
2922 var = var1;
2923 RET_LABEL:;
2924 return var;
2925 }
2926 /* method abstract_collection#Sequence#unshift for (self: Sequence[nullable Object], nullable Object) */
2927 void abstract_collection__Sequence__unshift(val* self, val* p0) {
2928 short int var /* : Bool */;
2929 int cltype;
2930 int idtype;
2931 const struct type* type_struct;
2932 short int is_nullable;
2933 const char* var_class_name;
2934 const char* var_class_name1;
2935 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa Sequence#0 */
2936 /* <p0:nullable Object> isa Sequence#0 */
2937 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Sequence_FT0];
2938 cltype = type_struct->color;
2939 idtype = type_struct->id;
2940 is_nullable = type_struct->is_nullable;
2941 if(p0 == NULL) {
2942 var = is_nullable;
2943 } else {
2944 if(cltype >= p0->type->table_size) {
2945 var = 0;
2946 } else {
2947 var = p0->type->type_table[cltype] == idtype;
2948 }
2949 }
2950 if (!var) {
2951 var_class_name = p0 == NULL ? "null" : p0->type->name;
2952 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Sequence#0", var_class_name);
2953 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 523);
2954 show_backtrace(1);
2955 }
2956 var_class_name1 = self == NULL ? "null" : self->type->name;
2957 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "unshift", var_class_name1);
2958 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 523);
2959 show_backtrace(1);
2960 RET_LABEL:;
2961 }
2962 /* method abstract_collection#Sequence#unshift for (self: Object, nullable Object) */
2963 void VIRTUAL_abstract_collection__Sequence__unshift(val* self, val* p0) {
2964 abstract_collection__Sequence__unshift(self, p0);
2965 RET_LABEL:;
2966 }
2967 /* method abstract_collection#Sequence#shift for (self: Sequence[nullable Object]): nullable Object */
2968 val* abstract_collection__Sequence__shift(val* self) {
2969 val* var /* : nullable Object */;
2970 const char* var_class_name;
2971 var_class_name = self == NULL ? "null" : self->type->name;
2972 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "shift", var_class_name);
2973 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 526);
2974 show_backtrace(1);
2975 RET_LABEL:;
2976 return var;
2977 }
2978 /* method abstract_collection#Sequence#shift for (self: Object): nullable Object */
2979 val* VIRTUAL_abstract_collection__Sequence__shift(val* self) {
2980 val* var /* : nullable Object */;
2981 val* var1 /* : nullable Object */;
2982 var1 = abstract_collection__Sequence__shift(self);
2983 var = var1;
2984 RET_LABEL:;
2985 return var;
2986 }
2987 /* method abstract_collection#Sequence#[]= for (self: Sequence[nullable Object], Int, nullable Object) */
2988 void abstract_collection__Sequence___91d_93d_61d(val* self, long p0, val* p1) {
2989 short int var /* : Bool */;
2990 int cltype;
2991 int idtype;
2992 const struct type* type_struct;
2993 short int is_nullable;
2994 const char* var_class_name;
2995 const char* var_class_name1;
2996 /* Covariant cast for argument 1 (item) <p1:nullable Object> isa Sequence#0 */
2997 /* <p1:nullable Object> isa Sequence#0 */
2998 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Sequence_FT0];
2999 cltype = type_struct->color;
3000 idtype = type_struct->id;
3001 is_nullable = type_struct->is_nullable;
3002 if(p1 == NULL) {
3003 var = is_nullable;
3004 } else {
3005 if(cltype >= p1->type->table_size) {
3006 var = 0;
3007 } else {
3008 var = p1->type->type_table[cltype] == idtype;
3009 }
3010 }
3011 if (!var) {
3012 var_class_name = p1 == NULL ? "null" : p1->type->name;
3013 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Sequence#0", var_class_name);
3014 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 530);
3015 show_backtrace(1);
3016 }
3017 var_class_name1 = self == NULL ? "null" : self->type->name;
3018 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "[]=", var_class_name1);
3019 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 530);
3020 show_backtrace(1);
3021 RET_LABEL:;
3022 }
3023 /* method abstract_collection#Sequence#[]= for (self: Object, Int, nullable Object) */
3024 void VIRTUAL_abstract_collection__Sequence___91d_93d_61d(val* self, long p0, val* p1) {
3025 abstract_collection__Sequence___91d_93d_61d(self, p0, p1);
3026 RET_LABEL:;
3027 }
3028 /* method abstract_collection#Sequence#remove_at for (self: Sequence[nullable Object], Int) */
3029 void abstract_collection__Sequence__remove_at(val* self, long p0) {
3030 const char* var_class_name;
3031 var_class_name = self == NULL ? "null" : self->type->name;
3032 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "remove_at", var_class_name);
3033 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 533);
3034 show_backtrace(1);
3035 RET_LABEL:;
3036 }
3037 /* method abstract_collection#Sequence#remove_at for (self: Object, Int) */
3038 void VIRTUAL_abstract_collection__Sequence__remove_at(val* self, long p0) {
3039 abstract_collection__Sequence__remove_at(self, p0);
3040 RET_LABEL:;
3041 }
3042 /* method abstract_collection#IndexedIterator#index for (self: IndexedIterator[nullable Object]): Int */
3043 long abstract_collection__IndexedIterator__index(val* self) {
3044 long var /* : Int */;
3045 const char* var_class_name;
3046 var_class_name = self == NULL ? "null" : self->type->name;
3047 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "index", var_class_name);
3048 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 540);
3049 show_backtrace(1);
3050 RET_LABEL:;
3051 return var;
3052 }
3053 /* method abstract_collection#IndexedIterator#index for (self: Object): Int */
3054 long VIRTUAL_abstract_collection__IndexedIterator__index(val* self) {
3055 long var /* : Int */;
3056 long var1 /* : Int */;
3057 var1 = abstract_collection__IndexedIterator__index(self);
3058 var = var1;
3059 RET_LABEL:;
3060 return var;
3061 }
3062 /* method abstract_collection#CoupleMap#couple_at for (self: CoupleMap[Object, nullable Object], Object): nullable Couple[Object, nullable Object] */
3063 val* abstract_collection__CoupleMap__couple_at(val* self, val* p0) {
3064 val* var /* : nullable Couple[Object, nullable Object] */;
3065 short int var1 /* : Bool */;
3066 int cltype;
3067 int idtype;
3068 const struct type* type_struct;
3069 const char* var_class_name;
3070 const char* var_class_name2;
3071 /* Covariant cast for argument 0 (key) <p0:Object> isa CoupleMap#0 */
3072 /* <p0:Object> isa CoupleMap#0 */
3073 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__CoupleMap_FT0];
3074 cltype = type_struct->color;
3075 idtype = type_struct->id;
3076 if(cltype >= p0->type->table_size) {
3077 var1 = 0;
3078 } else {
3079 var1 = p0->type->type_table[cltype] == idtype;
3080 }
3081 if (!var1) {
3082 var_class_name = p0 == NULL ? "null" : p0->type->name;
3083 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "CoupleMap#0", var_class_name);
3084 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 547);
3085 show_backtrace(1);
3086 }
3087 var_class_name2 = self == NULL ? "null" : self->type->name;
3088 fprintf(stderr, "Runtime error: Abstract method `%s` called on `%s`", "couple_at", var_class_name2);
3089 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 547);
3090 show_backtrace(1);
3091 RET_LABEL:;
3092 return var;
3093 }
3094 /* method abstract_collection#CoupleMap#couple_at for (self: Object, Object): nullable Couple[Object, nullable Object] */
3095 val* VIRTUAL_abstract_collection__CoupleMap__couple_at(val* self, val* p0) {
3096 val* var /* : nullable Couple[Object, nullable Object] */;
3097 val* var1 /* : nullable Couple[Object, nullable Object] */;
3098 var1 = abstract_collection__CoupleMap__couple_at(self, p0);
3099 var = var1;
3100 RET_LABEL:;
3101 return var;
3102 }
3103 /* method abstract_collection#CoupleMap#[] for (self: CoupleMap[Object, nullable Object], Object): nullable Object */
3104 val* abstract_collection__CoupleMap___91d_93d(val* self, val* p0) {
3105 val* var /* : nullable Object */;
3106 short int var1 /* : Bool */;
3107 int cltype;
3108 int idtype;
3109 const struct type* type_struct;
3110 const char* var_class_name;
3111 val* var_key /* var key: Object */;
3112 val* var2 /* : nullable Couple[Object, nullable Object] */;
3113 val* var_c /* var c: nullable Couple[Object, nullable Object] */;
3114 val* var3 /* : null */;
3115 short int var4 /* : Bool */;
3116 val* var5 /* : nullable Object */;
3117 val* var6 /* : nullable Object */;
3118 /* Covariant cast for argument 0 (key) <p0:Object> isa MapRead#0 */
3119 /* <p0:Object> isa MapRead#0 */
3120 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__MapRead_FT0];
3121 cltype = type_struct->color;
3122 idtype = type_struct->id;
3123 if(cltype >= p0->type->table_size) {
3124 var1 = 0;
3125 } else {
3126 var1 = p0->type->type_table[cltype] == idtype;
3127 }
3128 if (!var1) {
3129 var_class_name = p0 == NULL ? "null" : p0->type->name;
3130 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "MapRead#0", var_class_name);
3131 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 551);
3132 show_backtrace(1);
3133 }
3134 var_key = p0;
3135 var2 = ((val* (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__CoupleMap__couple_at]))(self, var_key) /* couple_at on <self:CoupleMap[Object, nullable Object]>*/;
3136 var_c = var2;
3137 var3 = NULL;
3138 if (var_c == NULL) {
3139 var4 = 1; /* is null */
3140 } else {
3141 var4 = 0; /* arg is null but recv is not */
3142 }
3143 if (var4){
3144 var5 = ((val* (*)(val*, val*))(self->class->vft[COLOR_abstract_collection__MapRead__provide_default_value]))(self, var_key) /* provide_default_value on <self:CoupleMap[Object, nullable Object]>*/;
3145 var = var5;
3146 goto RET_LABEL;
3147 } else {
3148 var6 = ((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])>*/;
3149 var = var6;
3150 goto RET_LABEL;
3151 }
3152 RET_LABEL:;
3153 return var;
3154 }
3155 /* method abstract_collection#CoupleMap#[] for (self: Object, Object): nullable Object */
3156 val* VIRTUAL_abstract_collection__CoupleMap___91d_93d(val* self, val* p0) {
3157 val* var /* : nullable Object */;
3158 val* var1 /* : nullable Object */;
3159 var1 = abstract_collection__CoupleMap___91d_93d(self, p0);
3160 var = var1;
3161 RET_LABEL:;
3162 return var;
3163 }
3164 /* method abstract_collection#CoupleMapIterator#item for (self: CoupleMapIterator[Object, nullable Object]): nullable Object */
3165 val* abstract_collection__CoupleMapIterator__item(val* self) {
3166 val* var /* : nullable Object */;
3167 val* var1 /* : Iterator[Couple[Object, nullable Object]] */;
3168 val* var2 /* : nullable Object */;
3169 val* var3 /* : nullable Object */;
3170 var1 = self->attrs[COLOR_abstract_collection__CoupleMapIterator___iter].val; /* _iter on <self:CoupleMapIterator[Object, nullable Object]> */
3171 if (var1 == NULL) {
3172 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _iter");
3173 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 567);
3174 show_backtrace(1);
3175 }
3176 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__item]))(var1) /* item on <var1:Iterator[Couple[Object, nullable Object]]>*/;
3177 var3 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_collection__Couple__second]))(var2) /* second on <var2:nullable Object(Couple[Object, nullable Object])>*/;
3178 var = var3;
3179 goto RET_LABEL;
3180 RET_LABEL:;
3181 return var;
3182 }
3183 /* method abstract_collection#CoupleMapIterator#item for (self: Object): nullable Object */
3184 val* VIRTUAL_abstract_collection__CoupleMapIterator__item(val* self) {
3185 val* var /* : nullable Object */;
3186 val* var1 /* : nullable Object */;
3187 var1 = abstract_collection__CoupleMapIterator__item(self);
3188 var = var1;
3189 RET_LABEL:;
3190 return var;
3191 }
3192 /* method abstract_collection#CoupleMapIterator#key for (self: CoupleMapIterator[Object, nullable Object]): Object */
3193 val* abstract_collection__CoupleMapIterator__key(val* self) {
3194 val* var /* : Object */;
3195 val* var1 /* : Iterator[Couple[Object, nullable Object]] */;
3196 val* var2 /* : nullable Object */;
3197 val* var3 /* : nullable Object */;
3198 var1 = self->attrs[COLOR_abstract_collection__CoupleMapIterator___iter].val; /* _iter on <self:CoupleMapIterator[Object, nullable Object]> */
3199 if (var1 == NULL) {
3200 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _iter");
3201 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 571);
3202 show_backtrace(1);
3203 }
3204 var2 = ((val* (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__item]))(var1) /* item on <var1:Iterator[Couple[Object, nullable Object]]>*/;
3205 var3 = ((val* (*)(val*))(var2->class->vft[COLOR_abstract_collection__Couple__first]))(var2) /* first on <var2:nullable Object(Couple[Object, nullable Object])>*/;
3206 var = var3;
3207 goto RET_LABEL;
3208 RET_LABEL:;
3209 return var;
3210 }
3211 /* method abstract_collection#CoupleMapIterator#key for (self: Object): Object */
3212 val* VIRTUAL_abstract_collection__CoupleMapIterator__key(val* self) {
3213 val* var /* : Object */;
3214 val* var1 /* : Object */;
3215 var1 = abstract_collection__CoupleMapIterator__key(self);
3216 var = var1;
3217 RET_LABEL:;
3218 return var;
3219 }
3220 /* method abstract_collection#CoupleMapIterator#is_ok for (self: CoupleMapIterator[Object, nullable Object]): Bool */
3221 short int abstract_collection__CoupleMapIterator__is_ok(val* self) {
3222 short int var /* : Bool */;
3223 val* var1 /* : Iterator[Couple[Object, nullable Object]] */;
3224 short int var2 /* : Bool */;
3225 var1 = self->attrs[COLOR_abstract_collection__CoupleMapIterator___iter].val; /* _iter on <self:CoupleMapIterator[Object, nullable Object]> */
3226 if (var1 == NULL) {
3227 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _iter");
3228 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 573);
3229 show_backtrace(1);
3230 }
3231 var2 = ((short int (*)(val*))(var1->class->vft[COLOR_abstract_collection__Iterator__is_ok]))(var1) /* is_ok on <var1:Iterator[Couple[Object, nullable Object]]>*/;
3232 var = var2;
3233 goto RET_LABEL;
3234 RET_LABEL:;
3235 return var;
3236 }
3237 /* method abstract_collection#CoupleMapIterator#is_ok for (self: Object): Bool */
3238 short int VIRTUAL_abstract_collection__CoupleMapIterator__is_ok(val* self) {
3239 short int var /* : Bool */;
3240 short int var1 /* : Bool */;
3241 var1 = abstract_collection__CoupleMapIterator__is_ok(self);
3242 var = var1;
3243 RET_LABEL:;
3244 return var;
3245 }
3246 /* method abstract_collection#CoupleMapIterator#next for (self: CoupleMapIterator[Object, nullable Object]) */
3247 void abstract_collection__CoupleMapIterator__next(val* self) {
3248 val* var /* : Iterator[Couple[Object, nullable Object]] */;
3249 var = self->attrs[COLOR_abstract_collection__CoupleMapIterator___iter].val; /* _iter on <self:CoupleMapIterator[Object, nullable Object]> */
3250 if (var == NULL) {
3251 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _iter");
3252 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 577);
3253 show_backtrace(1);
3254 }
3255 ((void (*)(val*))(var->class->vft[COLOR_abstract_collection__Iterator__next]))(var) /* next on <var:Iterator[Couple[Object, nullable Object]]>*/;
3256 RET_LABEL:;
3257 }
3258 /* method abstract_collection#CoupleMapIterator#next for (self: Object) */
3259 void VIRTUAL_abstract_collection__CoupleMapIterator__next(val* self) {
3260 abstract_collection__CoupleMapIterator__next(self);
3261 RET_LABEL:;
3262 }
3263 /* method abstract_collection#CoupleMapIterator#init for (self: CoupleMapIterator[Object, nullable Object], Iterator[Couple[Object, nullable Object]]) */
3264 void abstract_collection__CoupleMapIterator__init(val* self, val* p0) {
3265 short int var /* : Bool */;
3266 int cltype;
3267 int idtype;
3268 const struct type* type_struct;
3269 const char* var_class_name;
3270 val* var_i /* var i: Iterator[Couple[Object, nullable Object]] */;
3271 /* Covariant cast for argument 0 (i) <p0:Iterator[Couple[Object, nullable Object]]> isa Iterator[Couple[CoupleMapIterator#0, CoupleMapIterator#1]] */
3272 /* <p0:Iterator[Couple[Object, nullable Object]]> isa Iterator[Couple[CoupleMapIterator#0, CoupleMapIterator#1]] */
3273 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Iteratorabstract_collection__Coupleabstract_collection__CoupleMapIterator_FT0abstract_collection__CoupleMapIterator_FT1];
3274 cltype = type_struct->color;
3275 idtype = type_struct->id;
3276 if(cltype >= p0->type->table_size) {
3277 var = 0;
3278 } else {
3279 var = p0->type->type_table[cltype] == idtype;
3280 }
3281 if (!var) {
3282 var_class_name = p0 == NULL ? "null" : p0->type->name;
3283 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Iterator[Couple[CoupleMapIterator#0, CoupleMapIterator#1]]", var_class_name);
3284 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 582);
3285 show_backtrace(1);
3286 }
3287 var_i = p0;
3288 self->attrs[COLOR_abstract_collection__CoupleMapIterator___iter].val = var_i; /* _iter on <self:CoupleMapIterator[Object, nullable Object]> */
3289 RET_LABEL:;
3290 }
3291 /* method abstract_collection#CoupleMapIterator#init for (self: Object, Iterator[Couple[Object, nullable Object]]) */
3292 void VIRTUAL_abstract_collection__CoupleMapIterator__init(val* self, val* p0) {
3293 abstract_collection__CoupleMapIterator__init(self, p0);
3294 RET_LABEL:;
3295 }
3296 /* method abstract_collection#Couple#first for (self: Couple[nullable Object, nullable Object]): nullable Object */
3297 val* abstract_collection__Couple__first(val* self) {
3298 val* var /* : nullable Object */;
3299 val* var1 /* : nullable Object */;
3300 var1 = self->attrs[COLOR_abstract_collection__Couple___first].val; /* _first on <self:Couple[nullable Object, nullable Object]> */
3301 var = var1;
3302 RET_LABEL:;
3303 return var;
3304 }
3305 /* method abstract_collection#Couple#first for (self: Object): nullable Object */
3306 val* VIRTUAL_abstract_collection__Couple__first(val* self) {
3307 val* var /* : nullable Object */;
3308 val* var1 /* : nullable Object */;
3309 var1 = abstract_collection__Couple__first(self);
3310 var = var1;
3311 RET_LABEL:;
3312 return var;
3313 }
3314 /* method abstract_collection#Couple#first= for (self: Couple[nullable Object, nullable Object], nullable Object) */
3315 void abstract_collection__Couple__first_61d(val* self, val* p0) {
3316 short int var /* : Bool */;
3317 int cltype;
3318 int idtype;
3319 const struct type* type_struct;
3320 short int is_nullable;
3321 const char* var_class_name;
3322 /* Covariant cast for argument 0 (first) <p0:nullable Object> isa Couple#0 */
3323 /* <p0:nullable Object> isa Couple#0 */
3324 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Couple_FT0];
3325 cltype = type_struct->color;
3326 idtype = type_struct->id;
3327 is_nullable = type_struct->is_nullable;
3328 if(p0 == NULL) {
3329 var = is_nullable;
3330 } else {
3331 if(cltype >= p0->type->table_size) {
3332 var = 0;
3333 } else {
3334 var = p0->type->type_table[cltype] == idtype;
3335 }
3336 }
3337 if (!var) {
3338 var_class_name = p0 == NULL ? "null" : p0->type->name;
3339 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Couple#0", var_class_name);
3340 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 590);
3341 show_backtrace(1);
3342 }
3343 self->attrs[COLOR_abstract_collection__Couple___first].val = p0; /* _first on <self:Couple[nullable Object, nullable Object]> */
3344 RET_LABEL:;
3345 }
3346 /* method abstract_collection#Couple#first= for (self: Object, nullable Object) */
3347 void VIRTUAL_abstract_collection__Couple__first_61d(val* self, val* p0) {
3348 abstract_collection__Couple__first_61d(self, p0);
3349 RET_LABEL:;
3350 }
3351 /* method abstract_collection#Couple#second for (self: Couple[nullable Object, nullable Object]): nullable Object */
3352 val* abstract_collection__Couple__second(val* self) {
3353 val* var /* : nullable Object */;
3354 val* var1 /* : nullable Object */;
3355 var1 = self->attrs[COLOR_abstract_collection__Couple___second].val; /* _second on <self:Couple[nullable Object, nullable Object]> */
3356 var = var1;
3357 RET_LABEL:;
3358 return var;
3359 }
3360 /* method abstract_collection#Couple#second for (self: Object): nullable Object */
3361 val* VIRTUAL_abstract_collection__Couple__second(val* self) {
3362 val* var /* : nullable Object */;
3363 val* var1 /* : nullable Object */;
3364 var1 = abstract_collection__Couple__second(self);
3365 var = var1;
3366 RET_LABEL:;
3367 return var;
3368 }
3369 /* method abstract_collection#Couple#second= for (self: Couple[nullable Object, nullable Object], nullable Object) */
3370 void abstract_collection__Couple__second_61d(val* self, val* p0) {
3371 short int var /* : Bool */;
3372 int cltype;
3373 int idtype;
3374 const struct type* type_struct;
3375 short int is_nullable;
3376 const char* var_class_name;
3377 /* Covariant cast for argument 0 (second) <p0:nullable Object> isa Couple#1 */
3378 /* <p0:nullable Object> isa Couple#1 */
3379 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Couple_FT1];
3380 cltype = type_struct->color;
3381 idtype = type_struct->id;
3382 is_nullable = type_struct->is_nullable;
3383 if(p0 == NULL) {
3384 var = is_nullable;
3385 } else {
3386 if(cltype >= p0->type->table_size) {
3387 var = 0;
3388 } else {
3389 var = p0->type->type_table[cltype] == idtype;
3390 }
3391 }
3392 if (!var) {
3393 var_class_name = p0 == NULL ? "null" : p0->type->name;
3394 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Couple#1", var_class_name);
3395 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 593);
3396 show_backtrace(1);
3397 }
3398 self->attrs[COLOR_abstract_collection__Couple___second].val = p0; /* _second on <self:Couple[nullable Object, nullable Object]> */
3399 RET_LABEL:;
3400 }
3401 /* method abstract_collection#Couple#second= for (self: Object, nullable Object) */
3402 void VIRTUAL_abstract_collection__Couple__second_61d(val* self, val* p0) {
3403 abstract_collection__Couple__second_61d(self, p0);
3404 RET_LABEL:;
3405 }
3406 /* method abstract_collection#Couple#init for (self: Couple[nullable Object, nullable Object], nullable Object, nullable Object) */
3407 void abstract_collection__Couple__init(val* self, val* p0, val* p1) {
3408 short int var /* : Bool */;
3409 int cltype;
3410 int idtype;
3411 const struct type* type_struct;
3412 short int is_nullable;
3413 const char* var_class_name;
3414 short int var1 /* : Bool */;
3415 int cltype2;
3416 int idtype3;
3417 const struct type* type_struct4;
3418 short int is_nullable5;
3419 const char* var_class_name6;
3420 val* var_f /* var f: nullable Object */;
3421 val* var_s /* var s: nullable Object */;
3422 /* Covariant cast for argument 0 (f) <p0:nullable Object> isa Couple#0 */
3423 /* <p0:nullable Object> isa Couple#0 */
3424 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Couple_FT0];
3425 cltype = type_struct->color;
3426 idtype = type_struct->id;
3427 is_nullable = type_struct->is_nullable;
3428 if(p0 == NULL) {
3429 var = is_nullable;
3430 } else {
3431 if(cltype >= p0->type->table_size) {
3432 var = 0;
3433 } else {
3434 var = p0->type->type_table[cltype] == idtype;
3435 }
3436 }
3437 if (!var) {
3438 var_class_name = p0 == NULL ? "null" : p0->type->name;
3439 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Couple#0", var_class_name);
3440 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 596);
3441 show_backtrace(1);
3442 }
3443 /* Covariant cast for argument 1 (s) <p1:nullable Object> isa Couple#1 */
3444 /* <p1:nullable Object> isa Couple#1 */
3445 type_struct4 = self->type->resolution_table->types[COLOR_abstract_collection__Couple_FT1];
3446 cltype2 = type_struct4->color;
3447 idtype3 = type_struct4->id;
3448 is_nullable5 = type_struct4->is_nullable;
3449 if(p1 == NULL) {
3450 var1 = is_nullable5;
3451 } else {
3452 if(cltype2 >= p1->type->table_size) {
3453 var1 = 0;
3454 } else {
3455 var1 = p1->type->type_table[cltype2] == idtype3;
3456 }
3457 }
3458 if (!var1) {
3459 var_class_name6 = p1 == NULL ? "null" : p1->type->name;
3460 fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "Couple#1", var_class_name6);
3461 fprintf(stderr, " (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 596);
3462 show_backtrace(1);
3463 }
3464 var_f = p0;
3465 var_s = p1;
3466 self->attrs[COLOR_abstract_collection__Couple___first].val = var_f; /* _first on <self:Couple[nullable Object, nullable Object]> */
3467 self->attrs[COLOR_abstract_collection__Couple___second].val = var_s; /* _second on <self:Couple[nullable Object, nullable Object]> */
3468 RET_LABEL:;
3469 }
3470 /* method abstract_collection#Couple#init for (self: Object, nullable Object, nullable Object) */
3471 void VIRTUAL_abstract_collection__Couple__init(val* self, val* p0, val* p1) {
3472 abstract_collection__Couple__init(self, p0, p1);
3473 RET_LABEL:;
3474 }