c_src/standard__abstract_collection.sep.1.c

   1 #include "standard__abstract_collection.sep.0.h"
   2 /* method abstract_collection#Collection#is_empty for (self: Collection[nullable Object]): Bool */
   3 short int standard___standard__Collection___is_empty(val* self) {
   4 short int var /* : Bool */;
   5 long var1 /* : Int */;
   6 long var2 /* : Int */;
   7 short int var3 /* : Bool */;
   8 short int var5 /* : Bool */;
   9 {
  10 var1 = ((long (*)(val* self))(self->class->vft[COLOR_standard__abstract_collection__Collection__length]))(self) /* length on <self:Collection[nullable Object]>*/;
  11 }
  12 var2 = 0;
  13 {
  14 { /* Inline kernel#Int#== (var1,var2) on <var1:Int> */
  15 var5 = var1 == var2;
  16 var3 = var5;
  17 goto RET_LABEL4;
  18 RET_LABEL4:(void)0;
  19 }
  20 }
  21 var = var3;
  22 goto RET_LABEL;
  23 RET_LABEL:;
  24 return var;
  25 }
  26 /* method abstract_collection#Collection#length for (self: Collection[nullable Object]): Int */
  27 long standard___standard__Collection___length(val* self) {
  28 long var /* : Int */;
  29 long var1 /* : Int */;
  30 long var_nb /* var nb: Int */;
  31 val* var_ /* var : Collection[nullable Object] */;
  32 val* var2 /* : Iterator[nullable Object] */;
  33 val* var_3 /* var : Iterator[nullable Object] */;
  34 short int var4 /* : Bool */;
  35 val* var5 /* : nullable Object */;
  36 val* var_i /* var i: nullable Object */;
  37 long var6 /* : Int */;
  38 long var7 /* : Int */;
  39 short int var9 /* : Bool */;
  40 int cltype;
  41 int idtype;
  42 const char* var_class_name;
  43 long var10 /* : Int */;
  44 var1 = 0;
  45 var_nb = var1;
  46 var_ = self;
  47 {
  48 var2 = ((val* (*)(val* self))(var_->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_) /* iterator on <var_:Collection[nullable Object]>*/;
  49 }
  50 var_3 = var2;
  51 for(;;) {
  52 {
  53 var4 = ((short int (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_3) /* is_ok on <var_3:Iterator[nullable Object]>*/;
  54 }
  55 if (var4){
  56 {
  57 var5 = ((val* (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_3) /* item on <var_3:Iterator[nullable Object]>*/;
  58 }
  59 var_i = var5;
  60 var6 = 1;
  61 {
  62 { /* Inline kernel#Int#+ (var_nb,var6) on <var_nb:Int> */
  63 /* Covariant cast for argument 0 (i) <var6:Int> isa OTHER */
  64 /* <var6:Int> isa OTHER */
  65 var9 = 1; /* easy <var6:Int> isa OTHER*/
  66 if (unlikely(!var9)) {
  67 var_class_name = type_standard__Int.name;
  68 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
  69 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413);
  70 show_backtrace(1);
  71 }
  72 var10 = var_nb + var6;
  73 var7 = var10;
  74 goto RET_LABEL8;
  75 RET_LABEL8:(void)0;
  76 }
  77 }
  78 var_nb = var7;
  79 {
  80 ((void (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_3) /* next on <var_3:Iterator[nullable Object]>*/;
  81 }
  82 } else {
  83 goto BREAK_label;
  84 }
  85 }
  86 BREAK_label: (void)0;
  87 {
  88 { /* Inline abstract_collection#Iterator#finish (var_3) on <var_3:Iterator[nullable Object]> */
  89 RET_LABEL11:(void)0;
  90 }
  91 }
  92 var = var_nb;
  93 goto RET_LABEL;
  94 RET_LABEL:;
  95 return var;
  96 }
  97 /* method abstract_collection#Collection#has for (self: Collection[nullable Object], nullable Object): Bool */
  98 short int standard___standard__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* var_ /* var : Collection[nullable Object] */;
 108 val* var2 /* : Iterator[nullable Object] */;
 109 val* var_3 /* var : Iterator[nullable Object] */;
 110 short int var4 /* : Bool */;
 111 val* var5 /* : nullable Object */;
 112 val* var_i /* var i: nullable Object */;
 113 short int var6 /* : Bool */;
 114 short int var7 /* : Bool */;
 115 short int var8 /* : Bool */;
 116 short int var10 /* : Bool */;
 117 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa E */
 118 /* <p0:nullable Object> isa E */
 119 type_struct = self->type->resolution_table->types[COLOR_standard__Collection___35dE];
 120 cltype = type_struct->color;
 121 idtype = type_struct->id;
 122 is_nullable = type_struct->is_nullable;
 123 if(p0 == NULL) {
 124 var1 = is_nullable;
 125 } else {
 126 if(cltype >= p0->type->table_size) {
 127 var1 = 0;
 128 } else {
 129 var1 = p0->type->type_table[cltype] == idtype;
 130 }
 131 }
 132 if (unlikely(!var1)) {
 133 var_class_name = p0 == NULL ? "null" : p0->type->name;
 134 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
 135 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 80);
 136 show_backtrace(1);
 137 }
 138 var_item = p0;
 139 var_ = self;
 140 {
 141 var2 = ((val* (*)(val* self))(var_->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_) /* iterator on <var_:Collection[nullable Object]>*/;
 142 }
 143 var_3 = var2;
 144 for(;;) {
 145 {
 146 var4 = ((short int (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_3) /* is_ok on <var_3:Iterator[nullable Object]>*/;
 147 }
 148 if (var4){
 149 {
 150 var5 = ((val* (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_3) /* item on <var_3:Iterator[nullable Object]>*/;
 151 }
 152 var_i = var5;
 153 if (var_i == NULL) {
 154 var6 = (var_item == NULL);
 155 } else {
 156 var7 = ((short int (*)(val* self, val* p0))(var_i->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_i, var_item) /* == on <var_i:nullable Object>*/;
 157 var6 = var7;
 158 }
 159 if (var6){
 160 var8 = 1;
 161 var = var8;
 162 goto RET_LABEL;
 163 } else {
 164 }
 165 {
 166 ((void (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_3) /* next on <var_3:Iterator[nullable Object]>*/;
 167 }
 168 } else {
 169 goto BREAK_label;
 170 }
 171 }
 172 BREAK_label: (void)0;
 173 {
 174 { /* Inline abstract_collection#Iterator#finish (var_3) on <var_3:Iterator[nullable Object]> */
 175 RET_LABEL9:(void)0;
 176 }
 177 }
 178 var10 = 0;
 179 var = var10;
 180 goto RET_LABEL;
 181 RET_LABEL:;
 182 return var;
 183 }
 184 /* method abstract_collection#Collection#first for (self: Collection[nullable Object]): nullable Object */
 185 val* standard___standard__Collection___first(val* self) {
 186 val* var /* : nullable Object */;
 187 long var1 /* : Int */;
 188 long var2 /* : Int */;
 189 short int var3 /* : Bool */;
 190 short int var5 /* : Bool */;
 191 int cltype;
 192 int idtype;
 193 const char* var_class_name;
 194 short int var6 /* : Bool */;
 195 val* var7 /* : Iterator[nullable Object] */;
 196 val* var8 /* : nullable Object */;
 197 {
 198 var1 = ((long (*)(val* self))(self->class->vft[COLOR_standard__abstract_collection__Collection__length]))(self) /* length on <self:Collection[nullable Object]>*/;
 199 }
 200 var2 = 0;
 201 {
 202 { /* Inline kernel#Int#> (var1,var2) on <var1:Int> */
 203 /* Covariant cast for argument 0 (i) <var2:Int> isa OTHER */
 204 /* <var2:Int> isa OTHER */
 205 var5 = 1; /* easy <var2:Int> isa OTHER*/
 206 if (unlikely(!var5)) {
 207 var_class_name = type_standard__Int.name;
 208 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
 209 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 412);
 210 show_backtrace(1);
 211 }
 212 var6 = var1 > var2;
 213 var3 = var6;
 214 goto RET_LABEL4;
 215 RET_LABEL4:(void)0;
 216 }
 217 }
 218 if (unlikely(!var3)) {
 219 PRINT_ERROR("Runtime error: %s", "Assert failed");
 220 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 126);
 221 show_backtrace(1);
 222 }
 223 {
 224 var7 = ((val* (*)(val* self))(self->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(self) /* iterator on <self:Collection[nullable Object]>*/;
 225 }
 226 {
 227 var8 = ((val* (*)(val* self))(var7->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var7) /* item on <var7:Iterator[nullable Object]>*/;
 228 }
 229 var = var8;
 230 goto RET_LABEL;
 231 RET_LABEL:;
 232 return var;
 233 }
 234 /* method abstract_collection#Collection#has_all for (self: Collection[nullable Object], Collection[nullable Object]): Bool */
 235 short int standard___standard__Collection___has_all(val* self, val* p0) {
 236 short int var /* : Bool */;
 237 short int var1 /* : Bool */;
 238 int cltype;
 239 int idtype;
 240 const struct type* type_struct;
 241 const char* var_class_name;
 242 val* var_other /* var other: Collection[nullable Object] */;
 243 val* var_ /* var : Collection[nullable Object] */;
 244 val* var2 /* : Iterator[nullable Object] */;
 245 val* var_3 /* var : Iterator[nullable Object] */;
 246 short int var4 /* : Bool */;
 247 val* var5 /* : nullable Object */;
 248 val* var_x /* var x: nullable Object */;
 249 short int var6 /* : Bool */;
 250 short int var7 /* : Bool */;
 251 short int var8 /* : Bool */;
 252 short int var10 /* : Bool */;
 253 /* Covariant cast for argument 0 (other) <p0:Collection[nullable Object]> isa Collection[E] */
 254 /* <p0:Collection[nullable Object]> isa Collection[E] */
 255 type_struct = self->type->resolution_table->types[COLOR_standard__Collection__standard__Collection___35dE];
 256 cltype = type_struct->color;
 257 idtype = type_struct->id;
 258 if(cltype >= p0->type->table_size) {
 259 var1 = 0;
 260 } else {
 261 var1 = p0->type->type_table[cltype] == idtype;
 262 }
 263 if (unlikely(!var1)) {
 264 var_class_name = p0 == NULL ? "null" : p0->type->name;
 265 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection[E]", var_class_name);
 266 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 130);
 267 show_backtrace(1);
 268 }
 269 var_other = p0;
 270 var_ = var_other;
 271 {
 272 var2 = ((val* (*)(val* self))(var_->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_) /* iterator on <var_:Collection[nullable Object]>*/;
 273 }
 274 var_3 = var2;
 275 for(;;) {
 276 {
 277 var4 = ((short int (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_3) /* is_ok on <var_3:Iterator[nullable Object]>*/;
 278 }
 279 if (var4){
 280 {
 281 var5 = ((val* (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_3) /* item on <var_3:Iterator[nullable Object]>*/;
 282 }
 283 var_x = var5;
 284 {
 285 var6 = ((short int (*)(val* self, val* p0))(self->class->vft[COLOR_standard__abstract_collection__Collection__has]))(self, var_x) /* has on <self:Collection[nullable Object]>*/;
 286 }
 287 var7 = !var6;
 288 if (var7){
 289 var8 = 0;
 290 var = var8;
 291 goto RET_LABEL;
 292 } else {
 293 }
 294 {
 295 ((void (*)(val* self))(var_3->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_3) /* next on <var_3:Iterator[nullable Object]>*/;
 296 }
 297 } else {
 298 goto BREAK_label;
 299 }
 300 }
 301 BREAK_label: (void)0;
 302 {
 303 { /* Inline abstract_collection#Iterator#finish (var_3) on <var_3:Iterator[nullable Object]> */
 304 RET_LABEL9:(void)0;
 305 }
 306 }
 307 var10 = 1;
 308 var = var10;
 309 goto RET_LABEL;
 310 RET_LABEL:;
 311 return var;
 312 }
 313 /* method abstract_collection#Iterator#iterator for (self: Iterator[nullable Object]): Iterator[nullable Object] */
 314 val* standard___standard__Iterator___iterator(val* self) {
 315 val* var /* : Iterator[nullable Object] */;
 316 var = self;
 317 goto RET_LABEL;
 318 RET_LABEL:;
 319 return var;
 320 }
 321 /* method abstract_collection#Iterator#finish for (self: Iterator[nullable Object]) */
 322 void standard___standard__Iterator___finish(val* self) {
 323 RET_LABEL:;
 324 }
 325 /* method abstract_collection#Container#first for (self: Container[nullable Object]): nullable Object */
 326 val* standard___standard__Container___Collection__first(val* self) {
 327 val* var /* : nullable Object */;
 328 val* var1 /* : nullable Object */;
 329 val* var3 /* : nullable Object */;
 330 {
 331 { /* Inline abstract_collection#Container#item (self) on <self:Container[nullable Object]> */
 332 var3 = self->attrs[COLOR_standard__abstract_collection__Container___item].val; /* _item on <self:Container[nullable Object]> */
 333 var1 = var3;
 334 RET_LABEL2:(void)0;
 335 }
 336 }
 337 var = var1;
 338 goto RET_LABEL;
 339 RET_LABEL:;
 340 return var;
 341 }
 342 /* method abstract_collection#Container#is_empty for (self: Container[nullable Object]): Bool */
 343 short int standard___standard__Container___Collection__is_empty(val* self) {
 344 short int var /* : Bool */;
 345 short int var1 /* : Bool */;
 346 var1 = 0;
 347 var = var1;
 348 goto RET_LABEL;
 349 RET_LABEL:;
 350 return var;
 351 }
 352 /* method abstract_collection#Container#length for (self: Container[nullable Object]): Int */
 353 long standard___standard__Container___Collection__length(val* self) {
 354 long var /* : Int */;
 355 long var1 /* : Int */;
 356 var1 = 1;
 357 var = var1;
 358 goto RET_LABEL;
 359 RET_LABEL:;
 360 return var;
 361 }
 362 /* method abstract_collection#Container#has for (self: Container[nullable Object], nullable Object): Bool */
 363 short int standard___standard__Container___Collection__has(val* self, val* p0) {
 364 short int var /* : Bool */;
 365 short int var1 /* : Bool */;
 366 int cltype;
 367 int idtype;
 368 const struct type* type_struct;
 369 short int is_nullable;
 370 const char* var_class_name;
 371 val* var_an_item /* var an_item: nullable Object */;
 372 val* var2 /* : nullable Object */;
 373 val* var4 /* : nullable Object */;
 374 short int var5 /* : Bool */;
 375 short int var6 /* : Bool */;
 376 /* Covariant cast for argument 0 (an_item) <p0:nullable Object> isa E */
 377 /* <p0:nullable Object> isa E */
 378 type_struct = self->type->resolution_table->types[COLOR_standard__Container___35dE];
 379 cltype = type_struct->color;
 380 idtype = type_struct->id;
 381 is_nullable = type_struct->is_nullable;
 382 if(p0 == NULL) {
 383 var1 = is_nullable;
 384 } else {
 385 if(cltype >= p0->type->table_size) {
 386 var1 = 0;
 387 } else {
 388 var1 = p0->type->type_table[cltype] == idtype;
 389 }
 390 }
 391 if (unlikely(!var1)) {
 392 var_class_name = p0 == NULL ? "null" : p0->type->name;
 393 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
 394 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 217);
 395 show_backtrace(1);
 396 }
 397 var_an_item = p0;
 398 {
 399 { /* Inline abstract_collection#Container#item (self) on <self:Container[nullable Object]> */
 400 var4 = self->attrs[COLOR_standard__abstract_collection__Container___item].val; /* _item on <self:Container[nullable Object]> */
 401 var2 = var4;
 402 RET_LABEL3:(void)0;
 403 }
 404 }
 405 if (var2 == NULL) {
 406 var5 = (var_an_item == NULL);
 407 } else {
 408 var6 = ((short int (*)(val* self, val* p0))(var2->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var2, var_an_item) /* == on <var2:nullable Object>*/;
 409 var5 = var6;
 410 }
 411 var = var5;
 412 goto RET_LABEL;
 413 RET_LABEL:;
 414 return var;
 415 }
 416 /* method abstract_collection#Container#iterator for (self: Container[nullable Object]): Iterator[nullable Object] */
 417 val* standard___standard__Container___Collection__iterator(val* self) {
 418 val* var /* : Iterator[nullable Object] */;
 419 val* var1 /* : ContainerIterator[nullable Object] */;
 420 var1 = NEW_standard__abstract_collection__ContainerIterator(self->type->resolution_table->types[COLOR_standard__abstract_collection__ContainerIterator__standard__Container___35dE]);
 421 {
 422 ((void (*)(val* self, val* p0))(var1->class->vft[COLOR_standard__abstract_collection__ContainerIterator__container_61d]))(var1, self) /* container= on <var1:ContainerIterator[nullable Object]>*/;
 423 }
 424 {
 425 ((void (*)(val* self))(var1->class->vft[COLOR_standard__kernel__Object__init]))(var1) /* init on <var1:ContainerIterator[nullable Object]>*/;
 426 }
 427 var = var1;
 428 goto RET_LABEL;
 429 RET_LABEL:;
 430 return var;
 431 }
 432 /* method abstract_collection#Container#item for (self: Container[nullable Object]): nullable Object */
 433 val* standard___standard__Container___item(val* self) {
 434 val* var /* : nullable Object */;
 435 val* var1 /* : nullable Object */;
 436 var1 = self->attrs[COLOR_standard__abstract_collection__Container___item].val; /* _item on <self:Container[nullable Object]> */
 437 var = var1;
 438 RET_LABEL:;
 439 return var;
 440 }
 441 /* method abstract_collection#Container#item= for (self: Container[nullable Object], nullable Object) */
 442 void standard___standard__Container___item_61d(val* self, val* p0) {
 443 short int var /* : Bool */;
 444 int cltype;
 445 int idtype;
 446 const struct type* type_struct;
 447 short int is_nullable;
 448 const char* var_class_name;
 449 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa E */
 450 /* <p0:nullable Object> isa E */
 451 type_struct = self->type->resolution_table->types[COLOR_standard__Container___35dE];
 452 cltype = type_struct->color;
 453 idtype = type_struct->id;
 454 is_nullable = type_struct->is_nullable;
 455 if(p0 == NULL) {
 456 var = is_nullable;
 457 } else {
 458 if(cltype >= p0->type->table_size) {
 459 var = 0;
 460 } else {
 461 var = p0->type->type_table[cltype] == idtype;
 462 }
 463 }
 464 if (unlikely(!var)) {
 465 var_class_name = p0 == NULL ? "null" : p0->type->name;
 466 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
 467 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 232);
 468 show_backtrace(1);
 469 }
 470 self->attrs[COLOR_standard__abstract_collection__Container___item].val = p0; /* _item on <self:Container[nullable Object]> */
 471 RET_LABEL:;
 472 }
 473 /* method abstract_collection#Container#init for (self: Container[nullable Object]) */
 474 void standard___standard__Container___standard__kernel__Object__init(val* self) {
 475 {
 476 ((void (*)(val* self))(self->class->vft[COLOR_standard___standard__Container___standard__kernel__Object__init]))(self) /* init on <self:Container[nullable Object]>*/;
 477 }
 478 RET_LABEL:;
 479 }
 480 /* method abstract_collection#ContainerIterator#item for (self: ContainerIterator[nullable Object]): nullable Object */
 481 val* standard__abstract_collection___standard__abstract_collection__ContainerIterator___Iterator__item(val* self) {
 482 val* var /* : nullable Object */;
 483 val* var1 /* : Container[nullable Object] */;
 484 val* var2 /* : nullable Object */;
 485 val* var4 /* : nullable Object */;
 486 var1 = self->attrs[COLOR_standard__abstract_collection__ContainerIterator___container].val; /* _container on <self:ContainerIterator[nullable Object]> */
 487 if (unlikely(var1 == NULL)) {
 488 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _container");
 489 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 239);
 490 show_backtrace(1);
 491 }
 492 {
 493 { /* Inline abstract_collection#Container#item (var1) on <var1:Container[nullable Object]> */
 494 var4 = var1->attrs[COLOR_standard__abstract_collection__Container___item].val; /* _item on <var1:Container[nullable Object]> */
 495 var2 = var4;
 496 RET_LABEL3:(void)0;
 497 }
 498 }
 499 var = var2;
 500 goto RET_LABEL;
 501 RET_LABEL:;
 502 return var;
 503 }
 504 /* method abstract_collection#ContainerIterator#next for (self: ContainerIterator[nullable Object]) */
 505 void standard__abstract_collection___standard__abstract_collection__ContainerIterator___Iterator__next(val* self) {
 506 short int var /* : Bool */;
 507 var = 0;
 508 {
 509 { /* Inline abstract_collection#ContainerIterator#is_ok= (self,var) on <self:ContainerIterator[nullable Object]> */
 510 self->attrs[COLOR_standard__abstract_collection__ContainerIterator___is_ok].s = var; /* _is_ok on <self:ContainerIterator[nullable Object]> */
 511 RET_LABEL1:(void)0;
 512 }
 513 }
 514 RET_LABEL:;
 515 }
 516 /* method abstract_collection#ContainerIterator#is_ok for (self: ContainerIterator[nullable Object]): Bool */
 517 short int standard__abstract_collection___standard__abstract_collection__ContainerIterator___Iterator__is_ok(val* self) {
 518 short int var /* : Bool */;
 519 short int var1 /* : Bool */;
 520 var1 = self->attrs[COLOR_standard__abstract_collection__ContainerIterator___is_ok].s; /* _is_ok on <self:ContainerIterator[nullable Object]> */
 521 var = var1;
 522 RET_LABEL:;
 523 return var;
 524 }
 525 /* method abstract_collection#ContainerIterator#is_ok= for (self: ContainerIterator[nullable Object], Bool) */
 526 void standard__abstract_collection___standard__abstract_collection__ContainerIterator___is_ok_61d(val* self, short int p0) {
 527 self->attrs[COLOR_standard__abstract_collection__ContainerIterator___is_ok].s = p0; /* _is_ok on <self:ContainerIterator[nullable Object]> */
 528 RET_LABEL:;
 529 }
 530 /* method abstract_collection#ContainerIterator#container= for (self: ContainerIterator[nullable Object], Container[nullable Object]) */
 531 void standard__abstract_collection___standard__abstract_collection__ContainerIterator___container_61d(val* self, val* p0) {
 532 short int var /* : Bool */;
 533 int cltype;
 534 int idtype;
 535 const struct type* type_struct;
 536 const char* var_class_name;
 537 /* Covariant cast for argument 0 (container) <p0:Container[nullable Object]> isa Container[E] */
 538 /* <p0:Container[nullable Object]> isa Container[E] */
 539 type_struct = self->type->resolution_table->types[COLOR_standard__Container__standard__abstract_collection__ContainerIterator___35dE];
 540 cltype = type_struct->color;
 541 idtype = type_struct->id;
 542 if(cltype >= p0->type->table_size) {
 543 var = 0;
 544 } else {
 545 var = p0->type->type_table[cltype] == idtype;
 546 }
 547 if (unlikely(!var)) {
 548 var_class_name = p0 == NULL ? "null" : p0->type->name;
 549 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "Container[E]", var_class_name);
 550 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 245);
 551 show_backtrace(1);
 552 }
 553 self->attrs[COLOR_standard__abstract_collection__ContainerIterator___container].val = p0; /* _container on <self:ContainerIterator[nullable Object]> */
 554 RET_LABEL:;
 555 }
 556 /* method abstract_collection#ContainerIterator#init for (self: ContainerIterator[nullable Object]) */
 557 void standard__abstract_collection___standard__abstract_collection__ContainerIterator___standard__kernel__Object__init(val* self) {
 558 {
 559 ((void (*)(val* self))(self->class->vft[COLOR_standard__abstract_collection___standard__abstract_collection__ContainerIterator___standard__kernel__Object__init]))(self) /* init on <self:ContainerIterator[nullable Object]>*/;
 560 }
 561 RET_LABEL:;
 562 }
 563 /* method abstract_collection#RemovableCollection#clear for (self: RemovableCollection[nullable Object]) */
 564 void standard___standard__RemovableCollection___clear(val* self) {
 565 const char* var_class_name;
 566 var_class_name = self == NULL ? "null" : self->type->name;
 567 PRINT_ERROR("Runtime error: Abstract method `%s` called on `%s`", "clear", var_class_name);
 568 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 252);
 569 show_backtrace(1);
 570 RET_LABEL:;
 571 }
 572 /* method abstract_collection#RemovableCollection#remove for (self: RemovableCollection[nullable Object], nullable Object) */
 573 void standard___standard__RemovableCollection___remove(val* self, val* p0) {
 574 short int var /* : Bool */;
 575 int cltype;
 576 int idtype;
 577 const struct type* type_struct;
 578 short int is_nullable;
 579 const char* var_class_name;
 580 const char* var_class_name1;
 581 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa E */
 582 /* <p0:nullable Object> isa E */
 583 type_struct = self->type->resolution_table->types[COLOR_standard__RemovableCollection___35dE];
 584 cltype = type_struct->color;
 585 idtype = type_struct->id;
 586 is_nullable = type_struct->is_nullable;
 587 if(p0 == NULL) {
 588 var = is_nullable;
 589 } else {
 590 if(cltype >= p0->type->table_size) {
 591 var = 0;
 592 } else {
 593 var = p0->type->type_table[cltype] == idtype;
 594 }
 595 }
 596 if (unlikely(!var)) {
 597 var_class_name = p0 == NULL ? "null" : p0->type->name;
 598 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
 599 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 261);
 600 show_backtrace(1);
 601 }
 602 var_class_name1 = self == NULL ? "null" : self->type->name;
 603 PRINT_ERROR("Runtime error: Abstract method `%s` called on `%s`", "remove", var_class_name1);
 604 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 261);
 605 show_backtrace(1);
 606 RET_LABEL:;
 607 }
 608 /* method abstract_collection#SimpleCollection#add_all for (self: SimpleCollection[nullable Object], Collection[nullable Object]) */
 609 void standard___standard__SimpleCollection___add_all(val* self, val* p0) {
 610 short int var /* : Bool */;
 611 int cltype;
 612 int idtype;
 613 const struct type* type_struct;
 614 const char* var_class_name;
 615 val* var_coll /* var coll: Collection[nullable Object] */;
 616 val* var_ /* var : Collection[nullable Object] */;
 617 val* var1 /* : Iterator[nullable Object] */;
 618 val* var_2 /* var : Iterator[nullable Object] */;
 619 short int var3 /* : Bool */;
 620 val* var4 /* : nullable Object */;
 621 val* var_i /* var i: nullable Object */;
 622 /* Covariant cast for argument 0 (coll) <p0:Collection[nullable Object]> isa Collection[E] */
 623 /* <p0:Collection[nullable Object]> isa Collection[E] */
 624 type_struct = self->type->resolution_table->types[COLOR_standard__Collection__standard__SimpleCollection___35dE];
 625 cltype = type_struct->color;
 626 idtype = type_struct->id;
 627 if(cltype >= p0->type->table_size) {
 628 var = 0;
 629 } else {
 630 var = p0->type->type_table[cltype] == idtype;
 631 }
 632 if (unlikely(!var)) {
 633 var_class_name = p0 == NULL ? "null" : p0->type->name;
 634 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection[E]", var_class_name);
 635 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 290);
 636 show_backtrace(1);
 637 }
 638 var_coll = p0;
 639 var_ = var_coll;
 640 {
 641 var1 = ((val* (*)(val* self))(var_->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_) /* iterator on <var_:Collection[nullable Object]>*/;
 642 }
 643 var_2 = var1;
 644 for(;;) {
 645 {
 646 var3 = ((short int (*)(val* self))(var_2->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_2) /* is_ok on <var_2:Iterator[nullable Object]>*/;
 647 }
 648 if (var3){
 649 {
 650 var4 = ((val* (*)(val* self))(var_2->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_2) /* item on <var_2:Iterator[nullable Object]>*/;
 651 }
 652 var_i = var4;
 653 {
 654 ((void (*)(val* self, val* p0))(self->class->vft[COLOR_standard__abstract_collection__SimpleCollection__add]))(self, var_i) /* add on <self:SimpleCollection[nullable Object]>*/;
 655 }
 656 {
 657 ((void (*)(val* self))(var_2->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_2) /* next on <var_2:Iterator[nullable Object]>*/;
 658 }
 659 } else {
 660 goto BREAK_label;
 661 }
 662 }
 663 BREAK_label: (void)0;
 664 {
 665 { /* Inline abstract_collection#Iterator#finish (var_2) on <var_2:Iterator[nullable Object]> */
 666 RET_LABEL5:(void)0;
 667 }
 668 }
 669 RET_LABEL:;
 670 }
 671 /* method abstract_collection#Set#== for (self: Set[nullable Object], nullable Object): Bool */
 672 short int standard___standard__Set___standard__kernel__Object___61d_61d(val* self, val* p0) {
 673 short int var /* : Bool */;
 674 val* var_other /* var other: nullable Object */;
 675 short int var1 /* : Bool */;
 676 int cltype;
 677 int idtype;
 678 short int var2 /* : Bool */;
 679 short int var3 /* : Bool */;
 680 long var4 /* : Int */;
 681 long var5 /* : Int */;
 682 short int var6 /* : Bool */;
 683 short int var8 /* : Bool */;
 684 short int var9 /* : Bool */;
 685 short int var10 /* : Bool */;
 686 short int var11 /* : Bool */;
 687 int cltype12;
 688 int idtype13;
 689 const struct type* type_struct;
 690 const char* var_class_name;
 691 short int var14 /* : Bool */;
 692 var_other = p0;
 693 /* <var_other:nullable Object> isa Set[Object] */
 694 cltype = type_standard__Set__standard__Object.color;
 695 idtype = type_standard__Set__standard__Object.id;
 696 if(var_other == NULL) {
 697 var1 = 0;
 698 } else {
 699 if(cltype >= var_other->type->table_size) {
 700 var1 = 0;
 701 } else {
 702 var1 = var_other->type->type_table[cltype] == idtype;
 703 }
 704 }
 705 var2 = !var1;
 706 if (var2){
 707 var3 = 0;
 708 var = var3;
 709 goto RET_LABEL;
 710 } else {
 711 }
 712 {
 713 var4 = ((long (*)(val* self))(var_other->class->vft[COLOR_standard__abstract_collection__Collection__length]))(var_other) /* length on <var_other:nullable Object(Set[Object])>*/;
 714 }
 715 {
 716 var5 = ((long (*)(val* self))(self->class->vft[COLOR_standard__abstract_collection__Collection__length]))(self) /* length on <self:Set[nullable Object]>*/;
 717 }
 718 {
 719 { /* Inline kernel#Int#!= (var4,var5) on <var4:Int> */
 720 var8 = var4 == var5;
 721 var9 = !var8;
 722 var6 = var9;
 723 goto RET_LABEL7;
 724 RET_LABEL7:(void)0;
 725 }
 726 }
 727 if (var6){
 728 var10 = 0;
 729 var = var10;
 730 goto RET_LABEL;
 731 } else {
 732 }
 733 /* <var_other:nullable Object(Set[Object])> isa Collection[E] */
 734 type_struct = self->type->resolution_table->types[COLOR_standard__Collection__standard__Set___35dE];
 735 cltype12 = type_struct->color;
 736 idtype13 = type_struct->id;
 737 if(cltype12 >= var_other->type->table_size) {
 738 var11 = 0;
 739 } else {
 740 var11 = var_other->type->type_table[cltype12] == idtype13;
 741 }
 742 if (unlikely(!var11)) {
 743 var_class_name = var_other == NULL ? "null" : var_other->type->name;
 744 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection[E]", var_class_name);
 745 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 341);
 746 show_backtrace(1);
 747 }
 748 {
 749 var14 = standard___standard__Collection___has_all(self, var_other);
 750 }
 751 var = var14;
 752 goto RET_LABEL;
 753 RET_LABEL:;
 754 return var;
 755 }
 756 /* method abstract_collection#Set#hash for (self: Set[nullable Object]): Int */
 757 long standard___standard__Set___standard__kernel__Object__hash(val* self) {
 758 long var /* : Int */;
 759 long var1 /* : Int */;
 760 long var2 /* : Int */;
 761 long var3 /* : Int */;
 762 short int var5 /* : Bool */;
 763 int cltype;
 764 int idtype;
 765 const char* var_class_name;
 766 long var6 /* : Int */;
 767 long var_res /* var res: Int */;
 768 val* var_ /* var : Set[nullable Object] */;
 769 val* var7 /* : Iterator[nullable Object] */;
 770 val* var_8 /* var : Iterator[nullable Object] */;
 771 short int var9 /* : Bool */;
 772 val* var10 /* : nullable Object */;
 773 val* var_e /* var e: nullable Object */;
 774 long var11 /* : Int */;
 775 long var12 /* : Int */;
 776 short int var14 /* : Bool */;
 777 int cltype15;
 778 int idtype16;
 779 const char* var_class_name17;
 780 long var18 /* : Int */;
 781 var1 = 23;
 782 {
 783 var2 = ((long (*)(val* self))(self->class->vft[COLOR_standard__abstract_collection__Collection__length]))(self) /* length on <self:Set[nullable Object]>*/;
 784 }
 785 {
 786 { /* Inline kernel#Int#+ (var1,var2) on <var1:Int> */
 787 /* Covariant cast for argument 0 (i) <var2:Int> isa OTHER */
 788 /* <var2:Int> isa OTHER */
 789 var5 = 1; /* easy <var2:Int> isa OTHER*/
 790 if (unlikely(!var5)) {
 791 var_class_name = type_standard__Int.name;
 792 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
 793 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413);
 794 show_backtrace(1);
 795 }
 796 var6 = var1 + var2;
 797 var3 = var6;
 798 goto RET_LABEL4;
 799 RET_LABEL4:(void)0;
 800 }
 801 }
 802 var_res = var3;
 803 var_ = self;
 804 {
 805 var7 = ((val* (*)(val* self))(var_->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_) /* iterator on <var_:Set[nullable Object]>*/;
 806 }
 807 var_8 = var7;
 808 for(;;) {
 809 {
 810 var9 = ((short int (*)(val* self))(var_8->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_8) /* is_ok on <var_8:Iterator[nullable Object]>*/;
 811 }
 812 if (var9){
 813 {
 814 var10 = ((val* (*)(val* self))(var_8->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_8) /* item on <var_8:Iterator[nullable Object]>*/;
 815 }
 816 var_e = var10;
 817 if (var_e == NULL) {
 818 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 819 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 351);
 820 show_backtrace(1);
 821 } else {
 822 var11 = ((long (*)(val* self))(var_e->class->vft[COLOR_standard__kernel__Object__hash]))(var_e) /* hash on <var_e:nullable Object>*/;
 823 }
 824 {
 825 { /* Inline kernel#Int#+ (var_res,var11) on <var_res:Int> */
 826 /* Covariant cast for argument 0 (i) <var11:Int> isa OTHER */
 827 /* <var11:Int> isa OTHER */
 828 var14 = 1; /* easy <var11:Int> isa OTHER*/
 829 if (unlikely(!var14)) {
 830 var_class_name17 = type_standard__Int.name;
 831 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name17);
 832 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413);
 833 show_backtrace(1);
 834 }
 835 var18 = var_res + var11;
 836 var12 = var18;
 837 goto RET_LABEL13;
 838 RET_LABEL13:(void)0;
 839 }
 840 }
 841 var_res = var12;
 842 {
 843 ((void (*)(val* self))(var_8->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_8) /* next on <var_8:Iterator[nullable Object]>*/;
 844 }
 845 } else {
 846 goto BREAK_label;
 847 }
 848 }
 849 BREAK_label: (void)0;
 850 {
 851 { /* Inline abstract_collection#Iterator#finish (var_8) on <var_8:Iterator[nullable Object]> */
 852 RET_LABEL19:(void)0;
 853 }
 854 }
 855 var = var_res;
 856 goto RET_LABEL;
 857 RET_LABEL:;
 858 return var;
 859 }
 860 /* method abstract_collection#MapRead#get_or_null for (self: MapRead[nullable Object, nullable Object], nullable Object): nullable Object */
 861 val* standard___standard__MapRead___get_or_null(val* self, val* p0) {
 862 val* var /* : nullable Object */;
 863 short int var1 /* : Bool */;
 864 int cltype;
 865 int idtype;
 866 const struct type* type_struct;
 867 short int is_nullable;
 868 const char* var_class_name;
 869 val* var_key /* var key: nullable Object */;
 870 short int var2 /* : Bool */;
 871 val* var3 /* : nullable Object */;
 872 val* var4 /* : null */;
 873 /* Covariant cast for argument 0 (key) <p0:nullable Object> isa K */
 874 /* <p0:nullable Object> isa K */
 875 type_struct = self->type->resolution_table->types[COLOR_standard__MapRead___35dK];
 876 cltype = type_struct->color;
 877 idtype = type_struct->id;
 878 is_nullable = type_struct->is_nullable;
 879 if(p0 == NULL) {
 880 var1 = is_nullable;
 881 } else {
 882 if(cltype >= p0->type->table_size) {
 883 var1 = 0;
 884 } else {
 885 var1 = p0->type->type_table[cltype] == idtype;
 886 }
 887 }
 888 if (unlikely(!var1)) {
 889 var_class_name = p0 == NULL ? "null" : p0->type->name;
 890 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "K", var_class_name);
 891 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 392);
 892 show_backtrace(1);
 893 }
 894 var_key = p0;
 895 {
 896 var2 = standard___standard__MapRead___has_key(self, var_key);
 897 }
 898 if (var2){
 899 {
 900 var3 = ((val* (*)(val* self, val* p0))(self->class->vft[COLOR_standard__abstract_collection__MapRead___91d_93d]))(self, var_key) /* [] on <self:MapRead[nullable Object, nullable Object]>*/;
 901 }
 902 var = var3;
 903 goto RET_LABEL;
 904 } else {
 905 }
 906 var4 = NULL;
 907 var = var4;
 908 goto RET_LABEL;
 909 RET_LABEL:;
 910 return var;
 911 }
 912 /* method abstract_collection#MapRead#has_key for (self: MapRead[nullable Object, nullable Object], nullable Object): Bool */
 913 short int standard___standard__MapRead___has_key(val* self, val* p0) {
 914 short int var /* : Bool */;
 915 short int var1 /* : Bool */;
 916 int cltype;
 917 int idtype;
 918 const struct type* type_struct;
 919 short int is_nullable;
 920 const char* var_class_name;
 921 val* var_key /* var key: nullable Object */;
 922 val* var2 /* : Collection[nullable Object] */;
 923 short int var3 /* : Bool */;
 924 /* Covariant cast for argument 0 (key) <p0:nullable Object> isa K */
 925 /* <p0:nullable Object> isa K */
 926 type_struct = self->type->resolution_table->types[COLOR_standard__MapRead___35dK];
 927 cltype = type_struct->color;
 928 idtype = type_struct->id;
 929 is_nullable = type_struct->is_nullable;
 930 if(p0 == NULL) {
 931 var1 = is_nullable;
 932 } else {
 933 if(cltype >= p0->type->table_size) {
 934 var1 = 0;
 935 } else {
 936 var1 = p0->type->type_table[cltype] == idtype;
 937 }
 938 }
 939 if (unlikely(!var1)) {
 940 var_class_name = p0 == NULL ? "null" : p0->type->name;
 941 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "K", var_class_name);
 942 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 419);
 943 show_backtrace(1);
 944 }
 945 var_key = p0;
 946 {
 947 var2 = ((val* (*)(val* self))(self->class->vft[COLOR_standard__abstract_collection__MapRead__keys]))(self) /* keys on <self:MapRead[nullable Object, nullable Object]>*/;
 948 }
 949 {
 950 var3 = ((short int (*)(val* self, val* p0))(var2->class->vft[COLOR_standard__abstract_collection__Collection__has]))(var2, var_key) /* has on <var2:Collection[nullable Object]>*/;
 951 }
 952 var = var3;
 953 goto RET_LABEL;
 954 RET_LABEL:;
 955 return var;
 956 }
 957 /* method abstract_collection#MapRead#provide_default_value for (self: MapRead[nullable Object, nullable Object], nullable Object): nullable Object */
 958 val* standard___standard__MapRead___provide_default_value(val* self, val* p0) {
 959 val* var /* : nullable Object */;
 960 short int var1 /* : Bool */;
 961 int cltype;
 962 int idtype;
 963 const struct type* type_struct;
 964 short int is_nullable;
 965 const char* var_class_name;
 966 val* var_key /* var key: nullable Object */;
 967 /* Covariant cast for argument 0 (key) <p0:nullable Object> isa K */
 968 /* <p0:nullable Object> isa K */
 969 type_struct = self->type->resolution_table->types[COLOR_standard__MapRead___35dK];
 970 cltype = type_struct->color;
 971 idtype = type_struct->id;
 972 is_nullable = type_struct->is_nullable;
 973 if(p0 == NULL) {
 974 var1 = is_nullable;
 975 } else {
 976 if(cltype >= p0->type->table_size) {
 977 var1 = 0;
 978 } else {
 979 var1 = p0->type->type_table[cltype] == idtype;
 980 }
 981 }
 982 if (unlikely(!var1)) {
 983 var_class_name = p0 == NULL ? "null" : p0->type->name;
 984 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "K", var_class_name);
 985 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 463);
 986 show_backtrace(1);
 987 }
 988 var_key = p0;
 989 PRINT_ERROR("Runtime error: %s", "Aborted");
 990 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 468);
 991 show_backtrace(1);
 992 RET_LABEL:;
 993 return var;
 994 }
 995 /* method abstract_collection#MapIterator#finish for (self: MapIterator[nullable Object, nullable Object]) */
 996 void standard___standard__MapIterator___finish(val* self) {
 997 RET_LABEL:;
 998 }
 999 /* method abstract_collection#MapKeysIterator#original_iterator for (self: MapKeysIterator[nullable Object, nullable Object]): MapIterator[nullable Object, nullable Object] */
1000 val* standard___standard__MapKeysIterator___original_iterator(val* self) {
1001 val* var /* : MapIterator[nullable Object, nullable Object] */;
1002 val* var1 /* : MapIterator[nullable Object, nullable Object] */;
1003 var1 = self->attrs[COLOR_standard__abstract_collection__MapKeysIterator___original_iterator].val; /* _original_iterator on <self:MapKeysIterator[nullable Object, nullable Object]> */
1004 if (unlikely(var1 == NULL)) {
1005 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _original_iterator");
1006 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 588);
1007 show_backtrace(1);
1008 }
1009 var = var1;
1010 RET_LABEL:;
1011 return var;
1012 }
1013 /* method abstract_collection#MapKeysIterator#original_iterator= for (self: MapKeysIterator[nullable Object, nullable Object], MapIterator[nullable Object, nullable Object]) */
1014 void standard___standard__MapKeysIterator___original_iterator_61d(val* self, val* p0) {
1015 short int var /* : Bool */;
1016 int cltype;
1017 int idtype;
1018 const struct type* type_struct;
1019 const char* var_class_name;
1020 /* Covariant cast for argument 0 (original_iterator) <p0:MapIterator[nullable Object, nullable Object]> isa MapIterator[K, V] */
1021 /* <p0:MapIterator[nullable Object, nullable Object]> isa MapIterator[K, V] */
1022 type_struct = self->type->resolution_table->types[COLOR_standard__MapIterator__standard__MapKeysIterator___35dK__standard__MapKeysIterator___35dV];
1023 cltype = type_struct->color;
1024 idtype = type_struct->id;
1025 if(cltype >= p0->type->table_size) {
1026 var = 0;
1027 } else {
1028 var = p0->type->type_table[cltype] == idtype;
1029 }
1030 if (unlikely(!var)) {
1031 var_class_name = p0 == NULL ? "null" : p0->type->name;
1032 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MapIterator[K, V]", var_class_name);
1033 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 588);
1034 show_backtrace(1);
1035 }
1036 self->attrs[COLOR_standard__abstract_collection__MapKeysIterator___original_iterator].val = p0; /* _original_iterator on <self:MapKeysIterator[nullable Object, nullable Object]> */
1037 RET_LABEL:;
1038 }
1039 /* method abstract_collection#MapKeysIterator#is_ok for (self: MapKeysIterator[nullable Object, nullable Object]): Bool */
1040 short int standard___standard__MapKeysIterator___Iterator__is_ok(val* self) {
1041 short int var /* : Bool */;
1042 val* var1 /* : MapIterator[nullable Object, nullable Object] */;
1043 val* var3 /* : MapIterator[nullable Object, nullable Object] */;
1044 short int var4 /* : Bool */;
1045 {
1046 { /* Inline abstract_collection#MapKeysIterator#original_iterator (self) on <self:MapKeysIterator[nullable Object, nullable Object]> */
1047 var3 = self->attrs[COLOR_standard__abstract_collection__MapKeysIterator___original_iterator].val; /* _original_iterator on <self:MapKeysIterator[nullable Object, nullable Object]> */
1048 if (unlikely(var3 == NULL)) {
1049 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _original_iterator");
1050 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 588);
1051 show_backtrace(1);
1052 }
1053 var1 = var3;
1054 RET_LABEL2:(void)0;
1055 }
1056 }
1057 {
1058 var4 = ((short int (*)(val* self))(var1->class->vft[COLOR_standard__abstract_collection__MapIterator__is_ok]))(var1) /* is_ok on <var1:MapIterator[nullable Object, nullable Object]>*/;
1059 }
1060 var = var4;
1061 goto RET_LABEL;
1062 RET_LABEL:;
1063 return var;
1064 }
1065 /* method abstract_collection#MapKeysIterator#next for (self: MapKeysIterator[nullable Object, nullable Object]) */
1066 void standard___standard__MapKeysIterator___Iterator__next(val* self) {
1067 val* var /* : MapIterator[nullable Object, nullable Object] */;
1068 val* var2 /* : MapIterator[nullable Object, nullable Object] */;
1069 {
1070 { /* Inline abstract_collection#MapKeysIterator#original_iterator (self) on <self:MapKeysIterator[nullable Object, nullable Object]> */
1071 var2 = self->attrs[COLOR_standard__abstract_collection__MapKeysIterator___original_iterator].val; /* _original_iterator on <self:MapKeysIterator[nullable Object, nullable Object]> */
1072 if (unlikely(var2 == NULL)) {
1073 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _original_iterator");
1074 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 588);
1075 show_backtrace(1);
1076 }
1077 var = var2;
1078 RET_LABEL1:(void)0;
1079 }
1080 }
1081 {
1082 ((void (*)(val* self))(var->class->vft[COLOR_standard__abstract_collection__MapIterator__next]))(var) /* next on <var:MapIterator[nullable Object, nullable Object]>*/;
1083 }
1084 RET_LABEL:;
1085 }
1086 /* method abstract_collection#MapKeysIterator#item for (self: MapKeysIterator[nullable Object, nullable Object]): nullable Object */
1087 val* standard___standard__MapKeysIterator___Iterator__item(val* self) {
1088 val* var /* : nullable Object */;
1089 val* var1 /* : MapIterator[nullable Object, nullable Object] */;
1090 val* var3 /* : MapIterator[nullable Object, nullable Object] */;
1091 val* var4 /* : nullable Object */;
1092 {
1093 { /* Inline abstract_collection#MapKeysIterator#original_iterator (self) on <self:MapKeysIterator[nullable Object, nullable Object]> */
1094 var3 = self->attrs[COLOR_standard__abstract_collection__MapKeysIterator___original_iterator].val; /* _original_iterator on <self:MapKeysIterator[nullable Object, nullable Object]> */
1095 if (unlikely(var3 == NULL)) {
1096 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _original_iterator");
1097 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 588);
1098 show_backtrace(1);
1099 }
1100 var1 = var3;
1101 RET_LABEL2:(void)0;
1102 }
1103 }
1104 {
1105 var4 = ((val* (*)(val* self))(var1->class->vft[COLOR_standard__abstract_collection__MapIterator__key]))(var1) /* key on <var1:MapIterator[nullable Object, nullable Object]>*/;
1106 }
1107 var = var4;
1108 goto RET_LABEL;
1109 RET_LABEL:;
1110 return var;
1111 }
1112 /* method abstract_collection#MapKeysIterator#init for (self: MapKeysIterator[nullable Object, nullable Object]) */
1113 void standard___standard__MapKeysIterator___standard__kernel__Object__init(val* self) {
1114 {
1115 ((void (*)(val* self))(self->class->vft[COLOR_standard___standard__MapKeysIterator___standard__kernel__Object__init]))(self) /* init on <self:MapKeysIterator[nullable Object, nullable Object]>*/;
1116 }
1117 RET_LABEL:;
1118 }
1119 /* method abstract_collection#MapValuesIterator#original_iterator for (self: MapValuesIterator[nullable Object, nullable Object]): MapIterator[nullable Object, nullable Object] */
1120 val* standard___standard__MapValuesIterator___original_iterator(val* self) {
1121 val* var /* : MapIterator[nullable Object, nullable Object] */;
1122 val* var1 /* : MapIterator[nullable Object, nullable Object] */;
1123 var1 = self->attrs[COLOR_standard__abstract_collection__MapValuesIterator___original_iterator].val; /* _original_iterator on <self:MapValuesIterator[nullable Object, nullable Object]> */
1124 if (unlikely(var1 == NULL)) {
1125 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _original_iterator");
1126 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 599);
1127 show_backtrace(1);
1128 }
1129 var = var1;
1130 RET_LABEL:;
1131 return var;
1132 }
1133 /* method abstract_collection#MapValuesIterator#original_iterator= for (self: MapValuesIterator[nullable Object, nullable Object], MapIterator[nullable Object, nullable Object]) */
1134 void standard___standard__MapValuesIterator___original_iterator_61d(val* self, val* p0) {
1135 short int var /* : Bool */;
1136 int cltype;
1137 int idtype;
1138 const struct type* type_struct;
1139 const char* var_class_name;
1140 /* Covariant cast for argument 0 (original_iterator) <p0:MapIterator[nullable Object, nullable Object]> isa MapIterator[K, V] */
1141 /* <p0:MapIterator[nullable Object, nullable Object]> isa MapIterator[K, V] */
1142 type_struct = self->type->resolution_table->types[COLOR_standard__MapIterator__standard__MapValuesIterator___35dK__standard__MapValuesIterator___35dV];
1143 cltype = type_struct->color;
1144 idtype = type_struct->id;
1145 if(cltype >= p0->type->table_size) {
1146 var = 0;
1147 } else {
1148 var = p0->type->type_table[cltype] == idtype;
1149 }
1150 if (unlikely(!var)) {
1151 var_class_name = p0 == NULL ? "null" : p0->type->name;
1152 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MapIterator[K, V]", var_class_name);
1153 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 599);
1154 show_backtrace(1);
1155 }
1156 self->attrs[COLOR_standard__abstract_collection__MapValuesIterator___original_iterator].val = p0; /* _original_iterator on <self:MapValuesIterator[nullable Object, nullable Object]> */
1157 RET_LABEL:;
1158 }
1159 /* method abstract_collection#MapValuesIterator#is_ok for (self: MapValuesIterator[nullable Object, nullable Object]): Bool */
1160 short int standard___standard__MapValuesIterator___Iterator__is_ok(val* self) {
1161 short int var /* : Bool */;
1162 val* var1 /* : MapIterator[nullable Object, nullable Object] */;
1163 val* var3 /* : MapIterator[nullable Object, nullable Object] */;
1164 short int var4 /* : Bool */;
1165 {
1166 { /* Inline abstract_collection#MapValuesIterator#original_iterator (self) on <self:MapValuesIterator[nullable Object, nullable Object]> */
1167 var3 = self->attrs[COLOR_standard__abstract_collection__MapValuesIterator___original_iterator].val; /* _original_iterator on <self:MapValuesIterator[nullable Object, nullable Object]> */
1168 if (unlikely(var3 == NULL)) {
1169 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _original_iterator");
1170 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 599);
1171 show_backtrace(1);
1172 }
1173 var1 = var3;
1174 RET_LABEL2:(void)0;
1175 }
1176 }
1177 {
1178 var4 = ((short int (*)(val* self))(var1->class->vft[COLOR_standard__abstract_collection__MapIterator__is_ok]))(var1) /* is_ok on <var1:MapIterator[nullable Object, nullable Object]>*/;
1179 }
1180 var = var4;
1181 goto RET_LABEL;
1182 RET_LABEL:;
1183 return var;
1184 }
1185 /* method abstract_collection#MapValuesIterator#next for (self: MapValuesIterator[nullable Object, nullable Object]) */
1186 void standard___standard__MapValuesIterator___Iterator__next(val* self) {
1187 val* var /* : MapIterator[nullable Object, nullable Object] */;
1188 val* var2 /* : MapIterator[nullable Object, nullable Object] */;
1189 {
1190 { /* Inline abstract_collection#MapValuesIterator#original_iterator (self) on <self:MapValuesIterator[nullable Object, nullable Object]> */
1191 var2 = self->attrs[COLOR_standard__abstract_collection__MapValuesIterator___original_iterator].val; /* _original_iterator on <self:MapValuesIterator[nullable Object, nullable Object]> */
1192 if (unlikely(var2 == NULL)) {
1193 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _original_iterator");
1194 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 599);
1195 show_backtrace(1);
1196 }
1197 var = var2;
1198 RET_LABEL1:(void)0;
1199 }
1200 }
1201 {
1202 ((void (*)(val* self))(var->class->vft[COLOR_standard__abstract_collection__MapIterator__next]))(var) /* next on <var:MapIterator[nullable Object, nullable Object]>*/;
1203 }
1204 RET_LABEL:;
1205 }
1206 /* method abstract_collection#MapValuesIterator#item for (self: MapValuesIterator[nullable Object, nullable Object]): nullable Object */
1207 val* standard___standard__MapValuesIterator___Iterator__item(val* self) {
1208 val* var /* : nullable Object */;
1209 val* var1 /* : MapIterator[nullable Object, nullable Object] */;
1210 val* var3 /* : MapIterator[nullable Object, nullable Object] */;
1211 val* var4 /* : nullable Object */;
1212 {
1213 { /* Inline abstract_collection#MapValuesIterator#original_iterator (self) on <self:MapValuesIterator[nullable Object, nullable Object]> */
1214 var3 = self->attrs[COLOR_standard__abstract_collection__MapValuesIterator___original_iterator].val; /* _original_iterator on <self:MapValuesIterator[nullable Object, nullable Object]> */
1215 if (unlikely(var3 == NULL)) {
1216 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _original_iterator");
1217 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 599);
1218 show_backtrace(1);
1219 }
1220 var1 = var3;
1221 RET_LABEL2:(void)0;
1222 }
1223 }
1224 {
1225 var4 = ((val* (*)(val* self))(var1->class->vft[COLOR_standard__abstract_collection__MapIterator__item]))(var1) /* item on <var1:MapIterator[nullable Object, nullable Object]>*/;
1226 }
1227 var = var4;
1228 goto RET_LABEL;
1229 RET_LABEL:;
1230 return var;
1231 }
1232 /* method abstract_collection#MapValuesIterator#init for (self: MapValuesIterator[nullable Object, nullable Object]) */
1233 void standard___standard__MapValuesIterator___standard__kernel__Object__init(val* self) {
1234 {
1235 ((void (*)(val* self))(self->class->vft[COLOR_standard___standard__MapValuesIterator___standard__kernel__Object__init]))(self) /* init on <self:MapValuesIterator[nullable Object, nullable Object]>*/;
1236 }
1237 RET_LABEL:;
1238 }
1239 /* method abstract_collection#SequenceRead#first for (self: SequenceRead[nullable Object]): nullable Object */
1240 val* standard___standard__SequenceRead___Collection__first(val* self) {
1241 val* var /* : nullable Object */;
1242 short int var1 /* : Bool */;
1243 short int var2 /* : Bool */;
1244 long var3 /* : Int */;
1245 val* var4 /* : nullable Object */;
1246 {
1247 var1 = ((short int (*)(val* self))(self->class->vft[COLOR_standard__abstract_collection__Collection__is_empty]))(self) /* is_empty on <self:SequenceRead[nullable Object]>*/;
1248 }
1249 var2 = !var1;
1250 if (unlikely(!var2)) {
1251 PRINT_ERROR("Runtime error: %s", "Assert \'not_empty\' failed");
1252 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 624);
1253 show_backtrace(1);
1254 }
1255 var3 = 0;
1256 {
1257 var4 = ((val* (*)(val* self, long p0))(self->class->vft[COLOR_standard__abstract_collection__SequenceRead___91d_93d]))(self, var3) /* [] on <self:SequenceRead[nullable Object]>*/;
1258 }
1259 var = var4;
1260 goto RET_LABEL;
1261 RET_LABEL:;
1262 return var;
1263 }
1264 /* method abstract_collection#SequenceRead#last for (self: SequenceRead[nullable Object]): nullable Object */
1265 val* standard___standard__SequenceRead___last(val* self) {
1266 val* var /* : nullable Object */;
1267 short int var1 /* : Bool */;
1268 short int var2 /* : Bool */;
1269 long var3 /* : Int */;
1270 long var4 /* : Int */;
1271 long var5 /* : Int */;
1272 short int var7 /* : Bool */;
1273 int cltype;
1274 int idtype;
1275 const char* var_class_name;
1276 long var8 /* : Int */;
1277 val* var9 /* : nullable Object */;
1278 {
1279 var1 = ((short int (*)(val* self))(self->class->vft[COLOR_standard__abstract_collection__Collection__is_empty]))(self) /* is_empty on <self:SequenceRead[nullable Object]>*/;
1280 }
1281 var2 = !var1;
1282 if (unlikely(!var2)) {
1283 PRINT_ERROR("Runtime error: %s", "Assert \'not_empty\' failed");
1284 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 649);
1285 show_backtrace(1);
1286 }
1287 {
1288 var3 = ((long (*)(val* self))(self->class->vft[COLOR_standard__abstract_collection__Collection__length]))(self) /* length on <self:SequenceRead[nullable Object]>*/;
1289 }
1290 var4 = 1;
1291 {
1292 { /* Inline kernel#Int#- (var3,var4) on <var3:Int> */
1293 /* Covariant cast for argument 0 (i) <var4:Int> isa OTHER */
1294 /* <var4:Int> isa OTHER */
1295 var7 = 1; /* easy <var4:Int> isa OTHER*/
1296 if (unlikely(!var7)) {
1297 var_class_name = type_standard__Int.name;
1298 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
1299 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 416);
1300 show_backtrace(1);
1301 }
1302 var8 = var3 - var4;
1303 var5 = var8;
1304 goto RET_LABEL6;
1305 RET_LABEL6:(void)0;
1306 }
1307 }
1308 {
1309 var9 = ((val* (*)(val* self, long p0))(self->class->vft[COLOR_standard__abstract_collection__SequenceRead___91d_93d]))(self, var5) /* [] on <self:SequenceRead[nullable Object]>*/;
1310 }
1311 var = var9;
1312 goto RET_LABEL;
1313 RET_LABEL:;
1314 return var;
1315 }
1316 /* method abstract_collection#SequenceRead#index_of for (self: SequenceRead[nullable Object], nullable Object): Int */
1317 long standard___standard__SequenceRead___index_of(val* self, val* p0) {
1318 long var /* : Int */;
1319 short int var1 /* : Bool */;
1320 int cltype;
1321 int idtype;
1322 const struct type* type_struct;
1323 short int is_nullable;
1324 const char* var_class_name;
1325 val* var_item /* var item: nullable Object */;
1326 long var2 /* : Int */;
1327 long var3 /* : Int */;
1328 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa E */
1329 /* <p0:nullable Object> isa E */
1330 type_struct = self->type->resolution_table->types[COLOR_standard__SequenceRead___35dE];
1331 cltype = type_struct->color;
1332 idtype = type_struct->id;
1333 is_nullable = type_struct->is_nullable;
1334 if(p0 == NULL) {
1335 var1 = is_nullable;
1336 } else {
1337 if(cltype >= p0->type->table_size) {
1338 var1 = 0;
1339 } else {
1340 var1 = p0->type->type_table[cltype] == idtype;
1341 }
1342 }
1343 if (unlikely(!var1)) {
1344 var_class_name = p0 == NULL ? "null" : p0->type->name;
1345 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
1346 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 653);
1347 show_backtrace(1);
1348 }
1349 var_item = p0;
1350 var2 = 0;
1351 {
1352 var3 = ((long (*)(val* self, val* p0, long p1))(self->class->vft[COLOR_standard__abstract_collection__SequenceRead__index_of_from]))(self, var_item, var2) /* index_of_from on <self:SequenceRead[nullable Object]>*/;
1353 }
1354 var = var3;
1355 goto RET_LABEL;
1356 RET_LABEL:;
1357 return var;
1358 }
1359 /* method abstract_collection#SequenceRead#last_index_of for (self: SequenceRead[nullable Object], nullable Object): Int */
1360 long standard___standard__SequenceRead___last_index_of(val* self, val* p0) {
1361 long var /* : Int */;
1362 short int var1 /* : Bool */;
1363 int cltype;
1364 int idtype;
1365 const struct type* type_struct;
1366 short int is_nullable;
1367 const char* var_class_name;
1368 val* var_item /* var item: nullable Object */;
1369 long var2 /* : Int */;
1370 long var3 /* : Int */;
1371 long var4 /* : Int */;
1372 short int var6 /* : Bool */;
1373 int cltype7;
1374 int idtype8;
1375 const char* var_class_name9;
1376 long var10 /* : Int */;
1377 long var11 /* : Int */;
1378 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa E */
1379 /* <p0:nullable Object> isa E */
1380 type_struct = self->type->resolution_table->types[COLOR_standard__SequenceRead___35dE];
1381 cltype = type_struct->color;
1382 idtype = type_struct->id;
1383 is_nullable = type_struct->is_nullable;
1384 if(p0 == NULL) {
1385 var1 = is_nullable;
1386 } else {
1387 if(cltype >= p0->type->table_size) {
1388 var1 = 0;
1389 } else {
1390 var1 = p0->type->type_table[cltype] == idtype;
1391 }
1392 }
1393 if (unlikely(!var1)) {
1394 var_class_name = p0 == NULL ? "null" : p0->type->name;
1395 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
1396 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 662);
1397 show_backtrace(1);
1398 }
1399 var_item = p0;
1400 {
1401 var2 = ((long (*)(val* self))(self->class->vft[COLOR_standard__abstract_collection__Collection__length]))(self) /* length on <self:SequenceRead[nullable Object]>*/;
1402 }
1403 var3 = 1;
1404 {
1405 { /* Inline kernel#Int#- (var2,var3) on <var2:Int> */
1406 /* Covariant cast for argument 0 (i) <var3:Int> isa OTHER */
1407 /* <var3:Int> isa OTHER */
1408 var6 = 1; /* easy <var3:Int> isa OTHER*/
1409 if (unlikely(!var6)) {
1410 var_class_name9 = type_standard__Int.name;
1411 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name9);
1412 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 416);
1413 show_backtrace(1);
1414 }
1415 var10 = var2 - var3;
1416 var4 = var10;
1417 goto RET_LABEL5;
1418 RET_LABEL5:(void)0;
1419 }
1420 }
1421 {
1422 var11 = ((long (*)(val* self, val* p0, long p1))(self->class->vft[COLOR_standard__abstract_collection__SequenceRead__last_index_of_from]))(self, var_item, var4) /* last_index_of_from on <self:SequenceRead[nullable Object]>*/;
1423 }
1424 var = var11;
1425 goto RET_LABEL;
1426 RET_LABEL:;
1427 return var;
1428 }
1429 /* method abstract_collection#SequenceRead#index_of_from for (self: SequenceRead[nullable Object], nullable Object, Int): Int */
1430 long standard___standard__SequenceRead___index_of_from(val* self, val* p0, long p1) {
1431 long var /* : Int */;
1432 short int var1 /* : Bool */;
1433 int cltype;
1434 int idtype;
1435 const struct type* type_struct;
1436 short int is_nullable;
1437 const char* var_class_name;
1438 val* var_item /* var item: nullable Object */;
1439 long var_pos /* var pos: Int */;
1440 long var2 /* : Int */;
1441 long var_p /* var p: Int */;
1442 val* var3 /* : Iterator[nullable Object] */;
1443 val* var_i /* var i: IndexedIterator[nullable Object] */;
1444 short int var4 /* : Bool */;
1445 short int var5 /* : Bool */;
1446 short int var6 /* : Bool */;
1447 short int var8 /* : Bool */;
1448 int cltype9;
1449 int idtype10;
1450 const char* var_class_name11;
1451 short int var12 /* : Bool */;
1452 short int var_ /* var : Bool */;
1453 val* var13 /* : nullable Object */;
1454 short int var14 /* : Bool */;
1455 short int var15 /* : Bool */;
1456 long var16 /* : Int */;
1457 long var17 /* : Int */;
1458 long var18 /* : Int */;
1459 short int var20 /* : Bool */;
1460 int cltype21;
1461 int idtype22;
1462 const char* var_class_name23;
1463 long var24 /* : Int */;
1464 long var25 /* : Int */;
1465 long var26 /* : Int */;
1466 long var28 /* : Int */;
1467 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa E */
1468 /* <p0:nullable Object> isa E */
1469 type_struct = self->type->resolution_table->types[COLOR_standard__SequenceRead___35dE];
1470 cltype = type_struct->color;
1471 idtype = type_struct->id;
1472 is_nullable = type_struct->is_nullable;
1473 if(p0 == NULL) {
1474 var1 = is_nullable;
1475 } else {
1476 if(cltype >= p0->type->table_size) {
1477 var1 = 0;
1478 } else {
1479 var1 = p0->type->type_table[cltype] == idtype;
1480 }
1481 }
1482 if (unlikely(!var1)) {
1483 var_class_name = p0 == NULL ? "null" : p0->type->name;
1484 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
1485 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 671);
1486 show_backtrace(1);
1487 }
1488 var_item = p0;
1489 var_pos = p1;
1490 var2 = 0;
1491 var_p = var2;
1492 {
1493 var3 = ((val* (*)(val* self))(self->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(self) /* iterator on <self:SequenceRead[nullable Object]>*/;
1494 }
1495 var_i = var3;
1496 for(;;) {
1497 {
1498 var4 = ((short int (*)(val* self))(var_i->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_i) /* is_ok on <var_i:IndexedIterator[nullable Object]>*/;
1499 }
1500 if (var4){
1501 {
1502 { /* Inline kernel#Int#>= (var_p,var_pos) on <var_p:Int> */
1503 /* Covariant cast for argument 0 (i) <var_pos:Int> isa OTHER */
1504 /* <var_pos:Int> isa OTHER */
1505 var8 = 1; /* easy <var_pos:Int> isa OTHER*/
1506 if (unlikely(!var8)) {
1507 var_class_name11 = type_standard__Int.name;
1508 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name11);
1509 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 411);
1510 show_backtrace(1);
1511 }
1512 var12 = var_p >= var_pos;
1513 var6 = var12;
1514 goto RET_LABEL7;
1515 RET_LABEL7:(void)0;
1516 }
1517 }
1518 var_ = var6;
1519 if (var6){
1520 {
1521 var13 = ((val* (*)(val* self))(var_i->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_i) /* item on <var_i:IndexedIterator[nullable Object]>*/;
1522 }
1523 if (var13 == NULL) {
1524 var14 = (var_item == NULL);
1525 } else {
1526 var15 = ((short int (*)(val* self, val* p0))(var13->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var13, var_item) /* == on <var13:nullable Object>*/;
1527 var14 = var15;
1528 }
1529 var5 = var14;
1530 } else {
1531 var5 = var_;
1532 }
1533 if (var5){
1534 {
1535 var16 = ((long (*)(val* self))(var_i->class->vft[COLOR_standard__abstract_collection__IndexedIterator__index]))(var_i) /* index on <var_i:IndexedIterator[nullable Object]>*/;
1536 }
1537 var = var16;
1538 goto RET_LABEL;
1539 } else {
1540 }
1541 {
1542 ((void (*)(val* self))(var_i->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_i) /* next on <var_i:IndexedIterator[nullable Object]>*/;
1543 }
1544 var17 = 1;
1545 {
1546 { /* Inline kernel#Int#+ (var_p,var17) on <var_p:Int> */
1547 /* Covariant cast for argument 0 (i) <var17:Int> isa OTHER */
1548 /* <var17:Int> isa OTHER */
1549 var20 = 1; /* easy <var17:Int> isa OTHER*/
1550 if (unlikely(!var20)) {
1551 var_class_name23 = type_standard__Int.name;
1552 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name23);
1553 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413);
1554 show_backtrace(1);
1555 }
1556 var24 = var_p + var17;
1557 var18 = var24;
1558 goto RET_LABEL19;
1559 RET_LABEL19:(void)0;
1560 }
1561 }
1562 var_p = var18;
1563 } else {
1564 goto BREAK_label;
1565 }
1566 }
1567 BREAK_label: (void)0;
1568 var25 = 1;
1569 {
1570 { /* Inline kernel#Int#unary - (var25) on <var25:Int> */
1571 var28 = -var25;
1572 var26 = var28;
1573 goto RET_LABEL27;
1574 RET_LABEL27:(void)0;
1575 }
1576 }
1577 var = var26;
1578 goto RET_LABEL;
1579 RET_LABEL:;
1580 return var;
1581 }
1582 /* method abstract_collection#SequenceRead#last_index_of_from for (self: SequenceRead[nullable Object], nullable Object, Int): Int */
1583 long standard___standard__SequenceRead___last_index_of_from(val* self, val* p0, long p1) {
1584 long var /* : Int */;
1585 short int var1 /* : Bool */;
1586 int cltype;
1587 int idtype;
1588 const struct type* type_struct;
1589 short int is_nullable;
1590 const char* var_class_name;
1591 val* var_item /* var item: nullable Object */;
1592 long var_pos /* var pos: Int */;
1593 long var2 /* : Int */;
1594 long var3 /* : Int */;
1595 long var5 /* : Int */;
1596 long var_res /* var res: Int */;
1597 long var6 /* : Int */;
1598 long var_p /* var p: Int */;
1599 val* var7 /* : Iterator[nullable Object] */;
1600 val* var_i /* var i: IndexedIterator[nullable Object] */;
1601 short int var8 /* : Bool */;
1602 short int var9 /* : Bool */;
1603 short int var11 /* : Bool */;
1604 int cltype12;
1605 int idtype13;
1606 const char* var_class_name14;
1607 short int var15 /* : Bool */;
1608 val* var16 /* : nullable Object */;
1609 short int var17 /* : Bool */;
1610 short int var18 /* : Bool */;
1611 long var19 /* : Int */;
1612 long var20 /* : Int */;
1613 short int var22 /* : Bool */;
1614 int cltype23;
1615 int idtype24;
1616 const char* var_class_name25;
1617 long var26 /* : Int */;
1618 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa E */
1619 /* <p0:nullable Object> isa E */
1620 type_struct = self->type->resolution_table->types[COLOR_standard__SequenceRead___35dE];
1621 cltype = type_struct->color;
1622 idtype = type_struct->id;
1623 is_nullable = type_struct->is_nullable;
1624 if(p0 == NULL) {
1625 var1 = is_nullable;
1626 } else {
1627 if(cltype >= p0->type->table_size) {
1628 var1 = 0;
1629 } else {
1630 var1 = p0->type->type_table[cltype] == idtype;
1631 }
1632 }
1633 if (unlikely(!var1)) {
1634 var_class_name = p0 == NULL ? "null" : p0->type->name;
1635 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
1636 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 691);
1637 show_backtrace(1);
1638 }
1639 var_item = p0;
1640 var_pos = p1;
1641 var2 = 1;
1642 {
1643 { /* Inline kernel#Int#unary - (var2) on <var2:Int> */
1644 var5 = -var2;
1645 var3 = var5;
1646 goto RET_LABEL4;
1647 RET_LABEL4:(void)0;
1648 }
1649 }
1650 var_res = var3;
1651 var6 = 0;
1652 var_p = var6;
1653 {
1654 var7 = ((val* (*)(val* self))(self->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(self) /* iterator on <self:SequenceRead[nullable Object]>*/;
1655 }
1656 var_i = var7;
1657 for(;;) {
1658 {
1659 var8 = ((short int (*)(val* self))(var_i->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_i) /* is_ok on <var_i:IndexedIterator[nullable Object]>*/;
1660 }
1661 if (var8){
1662 {
1663 { /* Inline kernel#Int#> (var_p,var_pos) on <var_p:Int> */
1664 /* Covariant cast for argument 0 (i) <var_pos:Int> isa OTHER */
1665 /* <var_pos:Int> isa OTHER */
1666 var11 = 1; /* easy <var_pos:Int> isa OTHER*/
1667 if (unlikely(!var11)) {
1668 var_class_name14 = type_standard__Int.name;
1669 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name14);
1670 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 412);
1671 show_backtrace(1);
1672 }
1673 var15 = var_p > var_pos;
1674 var9 = var15;
1675 goto RET_LABEL10;
1676 RET_LABEL10:(void)0;
1677 }
1678 }
1679 if (var9){
1680 goto BREAK_label;
1681 } else {
1682 }
1683 {
1684 var16 = ((val* (*)(val* self))(var_i->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_i) /* item on <var_i:IndexedIterator[nullable Object]>*/;
1685 }
1686 if (var16 == NULL) {
1687 var17 = (var_item == NULL);
1688 } else {
1689 var18 = ((short int (*)(val* self, val* p0))(var16->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var16, var_item) /* == on <var16:nullable Object>*/;
1690 var17 = var18;
1691 }
1692 if (var17){
1693 var_res = var_p;
1694 } else {
1695 }
1696 {
1697 ((void (*)(val* self))(var_i->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_i) /* next on <var_i:IndexedIterator[nullable Object]>*/;
1698 }
1699 var19 = 1;
1700 {
1701 { /* Inline kernel#Int#+ (var_p,var19) on <var_p:Int> */
1702 /* Covariant cast for argument 0 (i) <var19:Int> isa OTHER */
1703 /* <var19:Int> isa OTHER */
1704 var22 = 1; /* easy <var19:Int> isa OTHER*/
1705 if (unlikely(!var22)) {
1706 var_class_name25 = type_standard__Int.name;
1707 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name25);
1708 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413);
1709 show_backtrace(1);
1710 }
1711 var26 = var_p + var19;
1712 var20 = var26;
1713 goto RET_LABEL21;
1714 RET_LABEL21:(void)0;
1715 }
1716 }
1717 var_p = var20;
1718 } else {
1719 goto BREAK_label;
1720 }
1721 }
1722 BREAK_label: (void)0;
1723 var = var_res;
1724 goto RET_LABEL;
1725 RET_LABEL:;
1726 return var;
1727 }
1728 /* method abstract_collection#SequenceRead#== for (self: SequenceRead[nullable Object], nullable Object): Bool */
1729 short int standard___standard__SequenceRead___standard__kernel__Object___61d_61d(val* self, val* p0) {
1730 short int var /* : Bool */;
1731 val* var_o /* var o: nullable Object */;
1732 short int var1 /* : Bool */;
1733 int cltype;
1734 int idtype;
1735 short int var2 /* : Bool */;
1736 short int var3 /* : Bool */;
1737 long var4 /* : Int */;
1738 long var_l /* var l: Int */;
1739 long var5 /* : Int */;
1740 short int var6 /* : Bool */;
1741 short int var8 /* : Bool */;
1742 short int var9 /* : Bool */;
1743 short int var10 /* : Bool */;
1744 long var11 /* : Int */;
1745 long var_i /* var i: Int */;
1746 short int var12 /* : Bool */;
1747 short int var14 /* : Bool */;
1748 int cltype15;
1749 int idtype16;
1750 const char* var_class_name;
1751 short int var17 /* : Bool */;
1752 val* var18 /* : nullable Object */;
1753 val* var19 /* : nullable Object */;
1754 short int var20 /* : Bool */;
1755 short int var21 /* : Bool */;
1756 short int var22 /* : Bool */;
1757 long var23 /* : Int */;
1758 long var24 /* : Int */;
1759 short int var26 /* : Bool */;
1760 int cltype27;
1761 int idtype28;
1762 const char* var_class_name29;
1763 long var30 /* : Int */;
1764 short int var31 /* : Bool */;
1765 var_o = p0;
1766 /* <var_o:nullable Object> isa SequenceRead[nullable Object] */
1767 cltype = type_standard__SequenceRead__nullable__standard__Object.color;
1768 idtype = type_standard__SequenceRead__nullable__standard__Object.id;
1769 if(var_o == NULL) {
1770 var1 = 0;
1771 } else {
1772 if(cltype >= var_o->type->table_size) {
1773 var1 = 0;
1774 } else {
1775 var1 = var_o->type->type_table[cltype] == idtype;
1776 }
1777 }
1778 var2 = !var1;
1779 if (var2){
1780 var3 = 0;
1781 var = var3;
1782 goto RET_LABEL;
1783 } else {
1784 }
1785 {
1786 var4 = ((long (*)(val* self))(self->class->vft[COLOR_standard__abstract_collection__Collection__length]))(self) /* length on <self:SequenceRead[nullable Object]>*/;
1787 }
1788 var_l = var4;
1789 {
1790 var5 = ((long (*)(val* self))(var_o->class->vft[COLOR_standard__abstract_collection__Collection__length]))(var_o) /* length on <var_o:nullable Object(SequenceRead[nullable Object])>*/;
1791 }
1792 {
1793 { /* Inline kernel#Int#!= (var5,var_l) on <var5:Int> */
1794 var8 = var5 == var_l;
1795 var9 = !var8;
1796 var6 = var9;
1797 goto RET_LABEL7;
1798 RET_LABEL7:(void)0;
1799 }
1800 }
1801 if (var6){
1802 var10 = 0;
1803 var = var10;
1804 goto RET_LABEL;
1805 } else {
1806 }
1807 var11 = 0;
1808 var_i = var11;
1809 for(;;) {
1810 {
1811 { /* Inline kernel#Int#< (var_i,var_l) on <var_i:Int> */
1812 /* Covariant cast for argument 0 (i) <var_l:Int> isa OTHER */
1813 /* <var_l:Int> isa OTHER */
1814 var14 = 1; /* easy <var_l:Int> isa OTHER*/
1815 if (unlikely(!var14)) {
1816 var_class_name = type_standard__Int.name;
1817 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
1818 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 410);
1819 show_backtrace(1);
1820 }
1821 var17 = var_i < var_l;
1822 var12 = var17;
1823 goto RET_LABEL13;
1824 RET_LABEL13:(void)0;
1825 }
1826 }
1827 if (var12){
1828 {
1829 var18 = ((val* (*)(val* self, long p0))(self->class->vft[COLOR_standard__abstract_collection__SequenceRead___91d_93d]))(self, var_i) /* [] on <self:SequenceRead[nullable Object]>*/;
1830 }
1831 {
1832 var19 = ((val* (*)(val* self, long p0))(var_o->class->vft[COLOR_standard__abstract_collection__SequenceRead___91d_93d]))(var_o, var_i) /* [] on <var_o:nullable Object(SequenceRead[nullable Object])>*/;
1833 }
1834 if (var18 == NULL) {
1835 var20 = (var19 != NULL);
1836 } else {
1837 var21 = ((short int (*)(val* self, val* p0))(var18->class->vft[COLOR_standard__kernel__Object___33d_61d]))(var18, var19) /* != on <var18:nullable Object>*/;
1838 var20 = var21;
1839 }
1840 if (var20){
1841 var22 = 0;
1842 var = var22;
1843 goto RET_LABEL;
1844 } else {
1845 }
1846 var23 = 1;
1847 {
1848 { /* Inline kernel#Int#+ (var_i,var23) on <var_i:Int> */
1849 /* Covariant cast for argument 0 (i) <var23:Int> isa OTHER */
1850 /* <var23:Int> isa OTHER */
1851 var26 = 1; /* easy <var23:Int> isa OTHER*/
1852 if (unlikely(!var26)) {
1853 var_class_name29 = type_standard__Int.name;
1854 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name29);
1855 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413);
1856 show_backtrace(1);
1857 }
1858 var30 = var_i + var23;
1859 var24 = var30;
1860 goto RET_LABEL25;
1861 RET_LABEL25:(void)0;
1862 }
1863 }
1864 var_i = var24;
1865 } else {
1866 goto BREAK_label;
1867 }
1868 }
1869 BREAK_label: (void)0;
1870 var31 = 1;
1871 var = var31;
1872 goto RET_LABEL;
1873 RET_LABEL:;
1874 return var;
1875 }
1876 /* method abstract_collection#SequenceRead#hash for (self: SequenceRead[nullable Object]): Int */
1877 long standard___standard__SequenceRead___standard__kernel__Object__hash(val* self) {
1878 long var /* : Int */;
1879 long var1 /* : Int */;
1880 long var2 /* : Int */;
1881 long var3 /* : Int */;
1882 short int var5 /* : Bool */;
1883 int cltype;
1884 int idtype;
1885 const char* var_class_name;
1886 long var6 /* : Int */;
1887 long var_res /* var res: Int */;
1888 val* var_ /* var : SequenceRead[nullable Object] */;
1889 val* var7 /* : Iterator[nullable Object] */;
1890 val* var_8 /* var : IndexedIterator[nullable Object] */;
1891 short int var9 /* : Bool */;
1892 val* var10 /* : nullable Object */;
1893 val* var_e /* var e: nullable Object */;
1894 long var11 /* : Int */;
1895 long var12 /* : Int */;
1896 short int var14 /* : Bool */;
1897 int cltype15;
1898 int idtype16;
1899 const char* var_class_name17;
1900 long var18 /* : Int */;
1901 long var19 /* : Int */;
1902 long var20 /* : Int */;
1903 short int var22 /* : Bool */;
1904 int cltype23;
1905 int idtype24;
1906 const char* var_class_name25;
1907 long var26 /* : Int */;
1908 val* var27 /* : null */;
1909 short int var28 /* : Bool */;
1910 short int var29 /* : Bool */;
1911 long var30 /* : Int */;
1912 long var31 /* : Int */;
1913 short int var33 /* : Bool */;
1914 int cltype34;
1915 int idtype35;
1916 const char* var_class_name36;
1917 long var37 /* : Int */;
1918 var1 = 17;
1919 {
1920 var2 = ((long (*)(val* self))(self->class->vft[COLOR_standard__abstract_collection__Collection__length]))(self) /* length on <self:SequenceRead[nullable Object]>*/;
1921 }
1922 {
1923 { /* Inline kernel#Int#+ (var1,var2) on <var1:Int> */
1924 /* Covariant cast for argument 0 (i) <var2:Int> isa OTHER */
1925 /* <var2:Int> isa OTHER */
1926 var5 = 1; /* easy <var2:Int> isa OTHER*/
1927 if (unlikely(!var5)) {
1928 var_class_name = type_standard__Int.name;
1929 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
1930 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413);
1931 show_backtrace(1);
1932 }
1933 var6 = var1 + var2;
1934 var3 = var6;
1935 goto RET_LABEL4;
1936 RET_LABEL4:(void)0;
1937 }
1938 }
1939 var_res = var3;
1940 var_ = self;
1941 {
1942 var7 = ((val* (*)(val* self))(var_->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_) /* iterator on <var_:SequenceRead[nullable Object]>*/;
1943 }
1944 var_8 = var7;
1945 for(;;) {
1946 {
1947 var9 = ((short int (*)(val* self))(var_8->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_8) /* is_ok on <var_8:IndexedIterator[nullable Object]>*/;
1948 }
1949 if (var9){
1950 {
1951 var10 = ((val* (*)(val* self))(var_8->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_8) /* item on <var_8:IndexedIterator[nullable Object]>*/;
1952 }
1953 var_e = var10;
1954 var11 = 3;
1955 {
1956 { /* Inline kernel#Int#* (var_res,var11) on <var_res:Int> */
1957 /* Covariant cast for argument 0 (i) <var11:Int> isa OTHER */
1958 /* <var11:Int> isa OTHER */
1959 var14 = 1; /* easy <var11:Int> isa OTHER*/
1960 if (unlikely(!var14)) {
1961 var_class_name17 = type_standard__Int.name;
1962 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name17);
1963 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 417);
1964 show_backtrace(1);
1965 }
1966 var18 = var_res * var11;
1967 var12 = var18;
1968 goto RET_LABEL13;
1969 RET_LABEL13:(void)0;
1970 }
1971 }
1972 var19 = 2;
1973 {
1974 { /* Inline kernel#Int#/ (var12,var19) on <var12:Int> */
1975 /* Covariant cast for argument 0 (i) <var19:Int> isa OTHER */
1976 /* <var19:Int> isa OTHER */
1977 var22 = 1; /* easy <var19:Int> isa OTHER*/
1978 if (unlikely(!var22)) {
1979 var_class_name25 = type_standard__Int.name;
1980 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name25);
1981 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 418);
1982 show_backtrace(1);
1983 }
1984 var26 = var12 / var19;
1985 var20 = var26;
1986 goto RET_LABEL21;
1987 RET_LABEL21:(void)0;
1988 }
1989 }
1990 var_res = var20;
1991 var27 = NULL;
1992 if (var_e == NULL) {
1993 var28 = 0; /* is null */
1994 } else {
1995 var28 = 1; /* arg is null and recv is not */
1996 }
1997 if (0) {
1998 var29 = ((short int (*)(val* self, val* p0))(var_e->class->vft[COLOR_standard__kernel__Object___33d_61d]))(var_e, var27) /* != on <var_e:nullable Object>*/;
1999 var28 = var29;
2000 }
2001 if (var28){
2002 if (var_e == NULL) {
2003 PRINT_ERROR("Runtime error: %s", "Receiver is null");
2004 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 743);
2005 show_backtrace(1);
2006 } else {
2007 var30 = ((long (*)(val* self))(var_e->class->vft[COLOR_standard__kernel__Object__hash]))(var_e) /* hash on <var_e:nullable Object>*/;
2008 }
2009 {
2010 { /* Inline kernel#Int#+ (var_res,var30) on <var_res:Int> */
2011 /* Covariant cast for argument 0 (i) <var30:Int> isa OTHER */
2012 /* <var30:Int> isa OTHER */
2013 var33 = 1; /* easy <var30:Int> isa OTHER*/
2014 if (unlikely(!var33)) {
2015 var_class_name36 = type_standard__Int.name;
2016 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name36);
2017 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413);
2018 show_backtrace(1);
2019 }
2020 var37 = var_res + var30;
2021 var31 = var37;
2022 goto RET_LABEL32;
2023 RET_LABEL32:(void)0;
2024 }
2025 }
2026 var_res = var31;
2027 } else {
2028 }
2029 {
2030 ((void (*)(val* self))(var_8->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_8) /* next on <var_8:IndexedIterator[nullable Object]>*/;
2031 }
2032 } else {
2033 goto BREAK_label;
2034 }
2035 }
2036 BREAK_label: (void)0;
2037 {
2038 { /* Inline abstract_collection#Iterator#finish (var_8) on <var_8:IndexedIterator[nullable Object]> */
2039 RET_LABEL38:(void)0;
2040 }
2041 }
2042 var = var_res;
2043 goto RET_LABEL;
2044 RET_LABEL:;
2045 return var;
2046 }
2047 /* method abstract_collection#SequenceRead#iterator_from for (self: SequenceRead[nullable Object], Int): IndexedIterator[nullable Object] */
2048 val* standard___standard__SequenceRead___iterator_from(val* self, long p0) {
2049 val* var /* : IndexedIterator[nullable Object] */;
2050 long var_pos /* var pos: Int */;
2051 val* var1 /* : Iterator[nullable Object] */;
2052 val* var_res /* var res: IndexedIterator[nullable Object] */;
2053 short int var2 /* : Bool */;
2054 long var3 /* : Int */;
2055 short int var4 /* : Bool */;
2056 short int var6 /* : Bool */;
2057 int cltype;
2058 int idtype;
2059 const char* var_class_name;
2060 short int var7 /* : Bool */;
2061 short int var_ /* var : Bool */;
2062 short int var8 /* : Bool */;
2063 long var9 /* : Int */;
2064 long var10 /* : Int */;
2065 short int var12 /* : Bool */;
2066 int cltype13;
2067 int idtype14;
2068 const char* var_class_name15;
2069 long var16 /* : Int */;
2070 var_pos = p0;
2071 {
2072 var1 = ((val* (*)(val* self))(self->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(self) /* iterator on <self:SequenceRead[nullable Object]>*/;
2073 }
2074 var_res = var1;
2075 for(;;) {
2076 var3 = 0;
2077 {
2078 { /* Inline kernel#Int#> (var_pos,var3) on <var_pos:Int> */
2079 /* Covariant cast for argument 0 (i) <var3:Int> isa OTHER */
2080 /* <var3:Int> isa OTHER */
2081 var6 = 1; /* easy <var3:Int> isa OTHER*/
2082 if (unlikely(!var6)) {
2083 var_class_name = type_standard__Int.name;
2084 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
2085 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 412);
2086 show_backtrace(1);
2087 }
2088 var7 = var_pos > var3;
2089 var4 = var7;
2090 goto RET_LABEL5;
2091 RET_LABEL5:(void)0;
2092 }
2093 }
2094 var_ = var4;
2095 if (var4){
2096 {
2097 var8 = ((short int (*)(val* self))(var_res->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_res) /* is_ok on <var_res:IndexedIterator[nullable Object]>*/;
2098 }
2099 var2 = var8;
2100 } else {
2101 var2 = var_;
2102 }
2103 if (var2){
2104 {
2105 ((void (*)(val* self))(var_res->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_res) /* next on <var_res:IndexedIterator[nullable Object]>*/;
2106 }
2107 var9 = 1;
2108 {
2109 { /* Inline kernel#Int#- (var_pos,var9) on <var_pos:Int> */
2110 /* Covariant cast for argument 0 (i) <var9:Int> isa OTHER */
2111 /* <var9:Int> isa OTHER */
2112 var12 = 1; /* easy <var9:Int> isa OTHER*/
2113 if (unlikely(!var12)) {
2114 var_class_name15 = type_standard__Int.name;
2115 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name15);
2116 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 416);
2117 show_backtrace(1);
2118 }
2119 var16 = var_pos - var9;
2120 var10 = var16;
2121 goto RET_LABEL11;
2122 RET_LABEL11:(void)0;
2123 }
2124 }
2125 var_pos = var10;
2126 } else {
2127 goto BREAK_label;
2128 }
2129 }
2130 BREAK_label: (void)0;
2131 var = var_res;
2132 goto RET_LABEL;
2133 RET_LABEL:;
2134 return var;
2135 }
2136 /* method abstract_collection#Sequence#first= for (self: Sequence[nullable Object], nullable Object) */
2137 void standard___standard__Sequence___first_61d(val* self, val* p0) {
2138 short int var /* : Bool */;
2139 int cltype;
2140 int idtype;
2141 const struct type* type_struct;
2142 short int is_nullable;
2143 const char* var_class_name;
2144 val* var_item /* var item: nullable Object */;
2145 long var1 /* : Int */;
2146 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa E */
2147 /* <p0:nullable Object> isa E */
2148 type_struct = self->type->resolution_table->types[COLOR_standard__Sequence___35dE];
2149 cltype = type_struct->color;
2150 idtype = type_struct->id;
2151 is_nullable = type_struct->is_nullable;
2152 if(p0 == NULL) {
2153 var = is_nullable;
2154 } else {
2155 if(cltype >= p0->type->table_size) {
2156 var = 0;
2157 } else {
2158 var = p0->type->type_table[cltype] == idtype;
2159 }
2160 }
2161 if (unlikely(!var)) {
2162 var_class_name = p0 == NULL ? "null" : p0->type->name;
2163 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
2164 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 791);
2165 show_backtrace(1);
2166 }
2167 var_item = p0;
2168 var1 = 0;
2169 {
2170 ((void (*)(val* self, long p0, val* p1))(self->class->vft[COLOR_standard__abstract_collection__Sequence___91d_93d_61d]))(self, var1, var_item) /* []= on <self:Sequence[nullable Object]>*/;
2171 }
2172 RET_LABEL:;
2173 }
2174 /* method abstract_collection#Sequence#add for (self: Sequence[nullable Object], nullable Object) */
2175 void standard___standard__Sequence___SimpleCollection__add(val* self, val* p0) {
2176 short int var /* : Bool */;
2177 int cltype;
2178 int idtype;
2179 const struct type* type_struct;
2180 short int is_nullable;
2181 const char* var_class_name;
2182 val* var_e /* var e: nullable Object */;
2183 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa E */
2184 /* <p0:nullable Object> isa E */
2185 type_struct = self->type->resolution_table->types[COLOR_standard__Sequence___35dE];
2186 cltype = type_struct->color;
2187 idtype = type_struct->id;
2188 is_nullable = type_struct->is_nullable;
2189 if(p0 == NULL) {
2190 var = is_nullable;
2191 } else {
2192 if(cltype >= p0->type->table_size) {
2193 var = 0;
2194 } else {
2195 var = p0->type->type_table[cltype] == idtype;
2196 }
2197 }
2198 if (unlikely(!var)) {
2199 var_class_name = p0 == NULL ? "null" : p0->type->name;
2200 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
2201 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 822);
2202 show_backtrace(1);
2203 }
2204 var_e = p0;
2205 {
2206 ((void (*)(val* self, val* p0))(self->class->vft[COLOR_standard__abstract_collection__Sequence__push]))(self, var_e) /* push on <self:Sequence[nullable Object]>*/;
2207 }
2208 RET_LABEL:;
2209 }
2210 /* method abstract_collection#Sequence#append for (self: Sequence[nullable Object], Collection[nullable Object]) */
2211 void standard___standard__Sequence___append(val* self, val* p0) {
2212 short int var /* : Bool */;
2213 int cltype;
2214 int idtype;
2215 const struct type* type_struct;
2216 const char* var_class_name;
2217 val* var_coll /* var coll: Collection[nullable Object] */;
2218 /* Covariant cast for argument 0 (coll) <p0:Collection[nullable Object]> isa Collection[E] */
2219 /* <p0:Collection[nullable Object]> isa Collection[E] */
2220 type_struct = self->type->resolution_table->types[COLOR_standard__Collection__standard__Sequence___35dE];
2221 cltype = type_struct->color;
2222 idtype = type_struct->id;
2223 if(cltype >= p0->type->table_size) {
2224 var = 0;
2225 } else {
2226 var = p0->type->type_table[cltype] == idtype;
2227 }
2228 if (unlikely(!var)) {
2229 var_class_name = p0 == NULL ? "null" : p0->type->name;
2230 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection[E]", var_class_name);
2231 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 833);
2232 show_backtrace(1);
2233 }
2234 var_coll = p0;
2235 {
2236 ((void (*)(val* self, val* p0))(self->class->vft[COLOR_standard__abstract_collection__SimpleCollection__add_all]))(self, var_coll) /* add_all on <self:Sequence[nullable Object]>*/;
2237 }
2238 RET_LABEL:;
2239 }
2240 /* method abstract_collection#Sequence#pop for (self: Sequence[nullable Object]): nullable Object */
2241 val* standard___standard__Sequence___pop(val* self) {
2242 val* var /* : nullable Object */;
2243 const char* var_class_name;
2244 var_class_name = self == NULL ? "null" : self->type->name;
2245 PRINT_ERROR("Runtime error: Abstract method `%s` called on `%s`", "pop", var_class_name);
2246 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 842);
2247 show_backtrace(1);
2248 RET_LABEL:;
2249 return var;
2250 }
2251 /* method abstract_collection#Sequence#unshift for (self: Sequence[nullable Object], nullable Object) */
2252 void standard___standard__Sequence___unshift(val* self, val* p0) {
2253 short int var /* : Bool */;
2254 int cltype;
2255 int idtype;
2256 const struct type* type_struct;
2257 short int is_nullable;
2258 const char* var_class_name;
2259 const char* var_class_name1;
2260 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa E */
2261 /* <p0:nullable Object> isa E */
2262 type_struct = self->type->resolution_table->types[COLOR_standard__Sequence___35dE];
2263 cltype = type_struct->color;
2264 idtype = type_struct->id;
2265 is_nullable = type_struct->is_nullable;
2266 if(p0 == NULL) {
2267 var = is_nullable;
2268 } else {
2269 if(cltype >= p0->type->table_size) {
2270 var = 0;
2271 } else {
2272 var = p0->type->type_table[cltype] == idtype;
2273 }
2274 }
2275 if (unlikely(!var)) {
2276 var_class_name = p0 == NULL ? "null" : p0->type->name;
2277 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
2278 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 852);
2279 show_backtrace(1);
2280 }
2281 var_class_name1 = self == NULL ? "null" : self->type->name;
2282 PRINT_ERROR("Runtime error: Abstract method `%s` called on `%s`", "unshift", var_class_name1);
2283 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 852);
2284 show_backtrace(1);
2285 RET_LABEL:;
2286 }
2287 /* method abstract_collection#Sequence#prepend for (self: Sequence[nullable Object], Collection[nullable Object]) */
2288 void standard___standard__Sequence___prepend(val* self, val* p0) {
2289 short int var /* : Bool */;
2290 int cltype;
2291 int idtype;
2292 const struct type* type_struct;
2293 const char* var_class_name;
2294 val* var_coll /* var coll: Collection[nullable Object] */;
2295 long var1 /* : Int */;
2296 /* Covariant cast for argument 0 (coll) <p0:Collection[nullable Object]> isa Collection[E] */
2297 /* <p0:Collection[nullable Object]> isa Collection[E] */
2298 type_struct = self->type->resolution_table->types[COLOR_standard__Collection__standard__Sequence___35dE];
2299 cltype = type_struct->color;
2300 idtype = type_struct->id;
2301 if(cltype >= p0->type->table_size) {
2302 var = 0;
2303 } else {
2304 var = p0->type->type_table[cltype] == idtype;
2305 }
2306 if (unlikely(!var)) {
2307 var_class_name = p0 == NULL ? "null" : p0->type->name;
2308 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection[E]", var_class_name);
2309 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 860);
2310 show_backtrace(1);
2311 }
2312 var_coll = p0;
2313 var1 = 0;
2314 {
2315 ((void (*)(val* self, val* p0, long p1))(self->class->vft[COLOR_standard__abstract_collection__Sequence__insert_all]))(self, var_coll, var1) /* insert_all on <self:Sequence[nullable Object]>*/;
2316 }
2317 RET_LABEL:;
2318 }
2319 /* method abstract_collection#Sequence#shift for (self: Sequence[nullable Object]): nullable Object */
2320 val* standard___standard__Sequence___shift(val* self) {
2321 val* var /* : nullable Object */;
2322 const char* var_class_name;
2323 var_class_name = self == NULL ? "null" : self->type->name;
2324 PRINT_ERROR("Runtime error: Abstract method `%s` called on `%s`", "shift", var_class_name);
2325 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 869);
2326 show_backtrace(1);
2327 RET_LABEL:;
2328 return var;
2329 }
2330 /* method abstract_collection#Sequence#insert for (self: Sequence[nullable Object], nullable Object, Int) */
2331 void standard___standard__Sequence___insert(val* self, val* p0, long p1) {
2332 short int var /* : Bool */;
2333 int cltype;
2334 int idtype;
2335 const struct type* type_struct;
2336 short int is_nullable;
2337 const char* var_class_name;
2338 const char* var_class_name1;
2339 /* Covariant cast for argument 0 (item) <p0:nullable Object> isa E */
2340 /* <p0:nullable Object> isa E */
2341 type_struct = self->type->resolution_table->types[COLOR_standard__Sequence___35dE];
2342 cltype = type_struct->color;
2343 idtype = type_struct->id;
2344 is_nullable = type_struct->is_nullable;
2345 if(p0 == NULL) {
2346 var = is_nullable;
2347 } else {
2348 if(cltype >= p0->type->table_size) {
2349 var = 0;
2350 } else {
2351 var = p0->type->type_table[cltype] == idtype;
2352 }
2353 }
2354 if (unlikely(!var)) {
2355 var_class_name = p0 == NULL ? "null" : p0->type->name;
2356 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
2357 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 895);
2358 show_backtrace(1);
2359 }
2360 var_class_name1 = self == NULL ? "null" : self->type->name;
2361 PRINT_ERROR("Runtime error: Abstract method `%s` called on `%s`", "insert", var_class_name1);
2362 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 895);
2363 show_backtrace(1);
2364 RET_LABEL:;
2365 }
2366 /* method abstract_collection#Sequence#insert_all for (self: Sequence[nullable Object], Collection[nullable Object], Int) */
2367 void standard___standard__Sequence___insert_all(val* self, val* p0, long p1) {
2368 short int var /* : Bool */;
2369 int cltype;
2370 int idtype;
2371 const struct type* type_struct;
2372 const char* var_class_name;
2373 val* var_coll /* var coll: Collection[nullable Object] */;
2374 long var_index /* var index: Int */;
2375 short int var1 /* : Bool */;
2376 long var2 /* : Int */;
2377 short int var3 /* : Bool */;
2378 short int var5 /* : Bool */;
2379 int cltype6;
2380 int idtype7;
2381 const char* var_class_name8;
2382 short int var9 /* : Bool */;
2383 short int var_ /* var : Bool */;
2384 long var10 /* : Int */;
2385 short int var11 /* : Bool */;
2386 short int var13 /* : Bool */;
2387 int cltype14;
2388 int idtype15;
2389 const char* var_class_name16;
2390 short int var17 /* : Bool */;
2391 long var18 /* : Int */;
2392 short int var19 /* : Bool */;
2393 short int var21 /* : Bool */;
2394 val* var_22 /* var : Collection[nullable Object] */;
2395 val* var23 /* : Iterator[nullable Object] */;
2396 val* var_24 /* var : Iterator[nullable Object] */;
2397 short int var25 /* : Bool */;
2398 val* var26 /* : nullable Object */;
2399 val* var_c /* var c: nullable Object */;
2400 long var27 /* : Int */;
2401 long var28 /* : Int */;
2402 short int var30 /* : Bool */;
2403 int cltype31;
2404 int idtype32;
2405 const char* var_class_name33;
2406 long var34 /* : Int */;
2407 /* Covariant cast for argument 0 (coll) <p0:Collection[nullable Object]> isa Collection[E] */
2408 /* <p0:Collection[nullable Object]> isa Collection[E] */
2409 type_struct = self->type->resolution_table->types[COLOR_standard__Collection__standard__Sequence___35dE];
2410 cltype = type_struct->color;
2411 idtype = type_struct->id;
2412 if(cltype >= p0->type->table_size) {
2413 var = 0;
2414 } else {
2415 var = p0->type->type_table[cltype] == idtype;
2416 }
2417 if (unlikely(!var)) {
2418 var_class_name = p0 == NULL ? "null" : p0->type->name;
2419 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection[E]", var_class_name);
2420 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 905);
2421 show_backtrace(1);
2422 }
2423 var_coll = p0;
2424 var_index = p1;
2425 var2 = 0;
2426 {
2427 { /* Inline kernel#Int#>= (var_index,var2) on <var_index:Int> */
2428 /* Covariant cast for argument 0 (i) <var2:Int> isa OTHER */
2429 /* <var2:Int> isa OTHER */
2430 var5 = 1; /* easy <var2:Int> isa OTHER*/
2431 if (unlikely(!var5)) {
2432 var_class_name8 = type_standard__Int.name;
2433 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name8);
2434 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 411);
2435 show_backtrace(1);
2436 }
2437 var9 = var_index >= var2;
2438 var3 = var9;
2439 goto RET_LABEL4;
2440 RET_LABEL4:(void)0;
2441 }
2442 }
2443 var_ = var3;
2444 if (var3){
2445 {
2446 var10 = ((long (*)(val* self))(self->class->vft[COLOR_standard__abstract_collection__Collection__length]))(self) /* length on <self:Sequence[nullable Object]>*/;
2447 }
2448 {
2449 { /* Inline kernel#Int#< (var_index,var10) on <var_index:Int> */
2450 /* Covariant cast for argument 0 (i) <var10:Int> isa OTHER */
2451 /* <var10:Int> isa OTHER */
2452 var13 = 1; /* easy <var10:Int> isa OTHER*/
2453 if (unlikely(!var13)) {
2454 var_class_name16 = type_standard__Int.name;
2455 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name16);
2456 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 410);
2457 show_backtrace(1);
2458 }
2459 var17 = var_index < var10;
2460 var11 = var17;
2461 goto RET_LABEL12;
2462 RET_LABEL12:(void)0;
2463 }
2464 }
2465 var1 = var11;
2466 } else {
2467 var1 = var_;
2468 }
2469 if (unlikely(!var1)) {
2470 PRINT_ERROR("Runtime error: %s", "Assert failed");
2471 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 915);
2472 show_backtrace(1);
2473 }
2474 {
2475 var18 = ((long (*)(val* self))(self->class->vft[COLOR_standard__abstract_collection__Collection__length]))(self) /* length on <self:Sequence[nullable Object]>*/;
2476 }
2477 {
2478 { /* Inline kernel#Int#== (var_index,var18) on <var_index:Int> */
2479 var21 = var_index == var18;
2480 var19 = var21;
2481 goto RET_LABEL20;
2482 RET_LABEL20:(void)0;
2483 }
2484 }
2485 if (var19){
2486 {
2487 ((void (*)(val* self, val* p0))(self->class->vft[COLOR_standard__abstract_collection__SimpleCollection__add_all]))(self, var_coll) /* add_all on <self:Sequence[nullable Object]>*/;
2488 }
2489 } else {
2490 }
2491 var_22 = var_coll;
2492 {
2493 var23 = ((val* (*)(val* self))(var_22->class->vft[COLOR_standard__abstract_collection__Collection__iterator]))(var_22) /* iterator on <var_22:Collection[nullable Object]>*/;
2494 }
2495 var_24 = var23;
2496 for(;;) {
2497 {
2498 var25 = ((short int (*)(val* self))(var_24->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var_24) /* is_ok on <var_24:Iterator[nullable Object]>*/;
2499 }
2500 if (var25){
2501 {
2502 var26 = ((val* (*)(val* self))(var_24->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var_24) /* item on <var_24:Iterator[nullable Object]>*/;
2503 }
2504 var_c = var26;
2505 {
2506 ((void (*)(val* self, val* p0, long p1))(self->class->vft[COLOR_standard__abstract_collection__Sequence__insert]))(self, var_c, var_index) /* insert on <self:Sequence[nullable Object]>*/;
2507 }
2508 var27 = 1;
2509 {
2510 { /* Inline kernel#Int#+ (var_index,var27) on <var_index:Int> */
2511 /* Covariant cast for argument 0 (i) <var27:Int> isa OTHER */
2512 /* <var27:Int> isa OTHER */
2513 var30 = 1; /* easy <var27:Int> isa OTHER*/
2514 if (unlikely(!var30)) {
2515 var_class_name33 = type_standard__Int.name;
2516 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name33);
2517 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413);
2518 show_backtrace(1);
2519 }
2520 var34 = var_index + var27;
2521 var28 = var34;
2522 goto RET_LABEL29;
2523 RET_LABEL29:(void)0;
2524 }
2525 }
2526 var_index = var28;
2527 {
2528 ((void (*)(val* self))(var_24->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var_24) /* next on <var_24:Iterator[nullable Object]>*/;
2529 }
2530 } else {
2531 goto BREAK_label;
2532 }
2533 }
2534 BREAK_label: (void)0;
2535 {
2536 { /* Inline abstract_collection#Iterator#finish (var_24) on <var_24:Iterator[nullable Object]> */
2537 RET_LABEL35:(void)0;
2538 }
2539 }
2540 RET_LABEL:;
2541 }
2542 /* method abstract_collection#Sequence#remove_at for (self: Sequence[nullable Object], Int) */
2543 void standard___standard__Sequence___remove_at(val* self, long p0) {
2544 const char* var_class_name;
2545 var_class_name = self == NULL ? "null" : self->type->name;
2546 PRINT_ERROR("Runtime error: Abstract method `%s` called on `%s`", "remove_at", var_class_name);
2547 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 925);
2548 show_backtrace(1);
2549 RET_LABEL:;
2550 }
2551 /* method abstract_collection#CoupleMap#iterator for (self: CoupleMap[nullable Object, nullable Object]): MapIterator[nullable Object, nullable Object] */
2552 val* standard___standard__CoupleMap___MapRead__iterator(val* self) {
2553 val* var /* : MapIterator[nullable Object, nullable Object] */;
2554 val* var1 /* : CoupleMapIterator[nullable Object, nullable Object] */;
2555 val* var2 /* : Iterator[Couple[nullable Object, nullable Object]] */;
2556 var1 = NEW_standard__abstract_collection__CoupleMapIterator(self->type->resolution_table->types[COLOR_standard__abstract_collection__CoupleMapIterator__standard__CoupleMap___35dK__standard__CoupleMap___35dV]);
2557 {
2558 var2 = standard___standard__ArrayMap___standard__abstract_collection__CoupleMap__couple_iterator(self);
2559 }
2560 {
2561 ((void (*)(val* self, val* p0))(var1->class->vft[COLOR_standard__abstract_collection__CoupleMapIterator__iter_61d]))(var1, var2) /* iter= on <var1:CoupleMapIterator[nullable Object, nullable Object]>*/;
2562 }
2563 {
2564 ((void (*)(val* self))(var1->class->vft[COLOR_standard__kernel__Object__init]))(var1) /* init on <var1:CoupleMapIterator[nullable Object, nullable Object]>*/;
2565 }
2566 var = var1;
2567 goto RET_LABEL;
2568 RET_LABEL:;
2569 return var;
2570 }
2571 /* method abstract_collection#CoupleMapIterator#item for (self: CoupleMapIterator[nullable Object, nullable Object]): nullable Object */
2572 val* standard__abstract_collection___standard__abstract_collection__CoupleMapIterator___MapIterator__item(val* self) {
2573 val* var /* : nullable Object */;
2574 val* var1 /* : Iterator[Couple[nullable Object, nullable Object]] */;
2575 val* var2 /* : nullable Object */;
2576 val* var3 /* : nullable Object */;
2577 val* var5 /* : nullable Object */;
2578 var1 = self->attrs[COLOR_standard__abstract_collection__CoupleMapIterator___iter].val; /* _iter on <self:CoupleMapIterator[nullable Object, nullable Object]> */
2579 if (unlikely(var1 == NULL)) {
2580 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _iter");
2581 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 973);
2582 show_backtrace(1);
2583 }
2584 {
2585 var2 = ((val* (*)(val* self))(var1->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var1) /* item on <var1:Iterator[Couple[nullable Object, nullable Object]]>*/;
2586 }
2587 {
2588 { /* Inline abstract_collection#Couple#second (var2) on <var2:nullable Object(Couple[nullable Object, nullable Object])> */
2589 var5 = var2->attrs[COLOR_standard__abstract_collection__Couple___second].val; /* _second on <var2:nullable Object(Couple[nullable Object, nullable Object])> */
2590 var3 = var5;
2591 RET_LABEL4:(void)0;
2592 }
2593 }
2594 var = var3;
2595 goto RET_LABEL;
2596 RET_LABEL:;
2597 return var;
2598 }
2599 /* method abstract_collection#CoupleMapIterator#key for (self: CoupleMapIterator[nullable Object, nullable Object]): nullable Object */
2600 val* standard__abstract_collection___standard__abstract_collection__CoupleMapIterator___MapIterator__key(val* self) {
2601 val* var /* : nullable Object */;
2602 val* var1 /* : Iterator[Couple[nullable Object, nullable Object]] */;
2603 val* var2 /* : nullable Object */;
2604 val* var3 /* : nullable Object */;
2605 val* var5 /* : nullable Object */;
2606 var1 = self->attrs[COLOR_standard__abstract_collection__CoupleMapIterator___iter].val; /* _iter on <self:CoupleMapIterator[nullable Object, nullable Object]> */
2607 if (unlikely(var1 == NULL)) {
2608 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _iter");
2609 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 977);
2610 show_backtrace(1);
2611 }
2612 {
2613 var2 = ((val* (*)(val* self))(var1->class->vft[COLOR_standard__abstract_collection__Iterator__item]))(var1) /* item on <var1:Iterator[Couple[nullable Object, nullable Object]]>*/;
2614 }
2615 {
2616 { /* Inline abstract_collection#Couple#first (var2) on <var2:nullable Object(Couple[nullable Object, nullable Object])> */
2617 var5 = var2->attrs[COLOR_standard__abstract_collection__Couple___first].val; /* _first on <var2:nullable Object(Couple[nullable Object, nullable Object])> */
2618 var3 = var5;
2619 RET_LABEL4:(void)0;
2620 }
2621 }
2622 var = var3;
2623 goto RET_LABEL;
2624 RET_LABEL:;
2625 return var;
2626 }
2627 /* method abstract_collection#CoupleMapIterator#is_ok for (self: CoupleMapIterator[nullable Object, nullable Object]): Bool */
2628 short int standard__abstract_collection___standard__abstract_collection__CoupleMapIterator___MapIterator__is_ok(val* self) {
2629 short int var /* : Bool */;
2630 val* var1 /* : Iterator[Couple[nullable Object, nullable Object]] */;
2631 short int var2 /* : Bool */;
2632 var1 = self->attrs[COLOR_standard__abstract_collection__CoupleMapIterator___iter].val; /* _iter on <self:CoupleMapIterator[nullable Object, nullable Object]> */
2633 if (unlikely(var1 == NULL)) {
2634 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _iter");
2635 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 979);
2636 show_backtrace(1);
2637 }
2638 {
2639 var2 = ((short int (*)(val* self))(var1->class->vft[COLOR_standard__abstract_collection__Iterator__is_ok]))(var1) /* is_ok on <var1:Iterator[Couple[nullable Object, nullable Object]]>*/;
2640 }
2641 var = var2;
2642 goto RET_LABEL;
2643 RET_LABEL:;
2644 return var;
2645 }
2646 /* method abstract_collection#CoupleMapIterator#next for (self: CoupleMapIterator[nullable Object, nullable Object]) */
2647 void standard__abstract_collection___standard__abstract_collection__CoupleMapIterator___MapIterator__next(val* self) {
2648 val* var /* : Iterator[Couple[nullable Object, nullable Object]] */;
2649 var = self->attrs[COLOR_standard__abstract_collection__CoupleMapIterator___iter].val; /* _iter on <self:CoupleMapIterator[nullable Object, nullable Object]> */
2650 if (unlikely(var == NULL)) {
2651 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _iter");
2652 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 983);
2653 show_backtrace(1);
2654 }
2655 {
2656 ((void (*)(val* self))(var->class->vft[COLOR_standard__abstract_collection__Iterator__next]))(var) /* next on <var:Iterator[Couple[nullable Object, nullable Object]]>*/;
2657 }
2658 RET_LABEL:;
2659 }
2660 /* method abstract_collection#CoupleMapIterator#iter= for (self: CoupleMapIterator[nullable Object, nullable Object], Iterator[Couple[nullable Object, nullable Object]]) */
2661 void standard__abstract_collection___standard__abstract_collection__CoupleMapIterator___iter_61d(val* self, val* p0) {
2662 short int var /* : Bool */;
2663 int cltype;
2664 int idtype;
2665 const struct type* type_struct;
2666 const char* var_class_name;
2667 /* Covariant cast for argument 0 (iter) <p0:Iterator[Couple[nullable Object, nullable Object]]> isa Iterator[Couple[K, V]] */
2668 /* <p0:Iterator[Couple[nullable Object, nullable Object]]> isa Iterator[Couple[K, V]] */
2669 type_struct = self->type->resolution_table->types[COLOR_standard__Iterator__standard__Couple__standard__abstract_collection__CoupleMapIterator___35dK__standard__abstract_collection__CoupleMapIterator___35dV];
2670 cltype = type_struct->color;
2671 idtype = type_struct->id;
2672 if(cltype >= p0->type->table_size) {
2673 var = 0;
2674 } else {
2675 var = p0->type->type_table[cltype] == idtype;
2676 }
2677 if (unlikely(!var)) {
2678 var_class_name = p0 == NULL ? "null" : p0->type->name;
2679 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "Iterator[Couple[K, V]]", var_class_name);
2680 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 986);
2681 show_backtrace(1);
2682 }
2683 self->attrs[COLOR_standard__abstract_collection__CoupleMapIterator___iter].val = p0; /* _iter on <self:CoupleMapIterator[nullable Object, nullable Object]> */
2684 RET_LABEL:;
2685 }
2686 /* method abstract_collection#CoupleMapIterator#init for (self: CoupleMapIterator[nullable Object, nullable Object]) */
2687 void standard__abstract_collection___standard__abstract_collection__CoupleMapIterator___standard__kernel__Object__init(val* self) {
2688 {
2689 ((void (*)(val* self))(self->class->vft[COLOR_standard__abstract_collection___standard__abstract_collection__CoupleMapIterator___standard__kernel__Object__init]))(self) /* init on <self:CoupleMapIterator[nullable Object, nullable Object]>*/;
2690 }
2691 RET_LABEL:;
2692 }
2693 /* method abstract_collection#Couple#first for (self: Couple[nullable Object, nullable Object]): nullable Object */
2694 val* standard___standard__Couple___first(val* self) {
2695 val* var /* : nullable Object */;
2696 val* var1 /* : nullable Object */;
2697 var1 = self->attrs[COLOR_standard__abstract_collection__Couple___first].val; /* _first on <self:Couple[nullable Object, nullable Object]> */
2698 var = var1;
2699 RET_LABEL:;
2700 return var;
2701 }
2702 /* method abstract_collection#Couple#first= for (self: Couple[nullable Object, nullable Object], nullable Object) */
2703 void standard___standard__Couple___first_61d(val* self, val* p0) {
2704 short int var /* : Bool */;
2705 int cltype;
2706 int idtype;
2707 const struct type* type_struct;
2708 short int is_nullable;
2709 const char* var_class_name;
2710 /* Covariant cast for argument 0 (first) <p0:nullable Object> isa F */
2711 /* <p0:nullable Object> isa F */
2712 type_struct = self->type->resolution_table->types[COLOR_standard__Couple___35dF];
2713 cltype = type_struct->color;
2714 idtype = type_struct->id;
2715 is_nullable = type_struct->is_nullable;
2716 if(p0 == NULL) {
2717 var = is_nullable;
2718 } else {
2719 if(cltype >= p0->type->table_size) {
2720 var = 0;
2721 } else {
2722 var = p0->type->type_table[cltype] == idtype;
2723 }
2724 }
2725 if (unlikely(!var)) {
2726 var_class_name = p0 == NULL ? "null" : p0->type->name;
2727 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "F", var_class_name);
2728 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 994);
2729 show_backtrace(1);
2730 }
2731 self->attrs[COLOR_standard__abstract_collection__Couple___first].val = p0; /* _first on <self:Couple[nullable Object, nullable Object]> */
2732 RET_LABEL:;
2733 }
2734 /* method abstract_collection#Couple#second for (self: Couple[nullable Object, nullable Object]): nullable Object */
2735 val* standard___standard__Couple___second(val* self) {
2736 val* var /* : nullable Object */;
2737 val* var1 /* : nullable Object */;
2738 var1 = self->attrs[COLOR_standard__abstract_collection__Couple___second].val; /* _second on <self:Couple[nullable Object, nullable Object]> */
2739 var = var1;
2740 RET_LABEL:;
2741 return var;
2742 }
2743 /* method abstract_collection#Couple#second= for (self: Couple[nullable Object, nullable Object], nullable Object) */
2744 void standard___standard__Couple___second_61d(val* self, val* p0) {
2745 short int var /* : Bool */;
2746 int cltype;
2747 int idtype;
2748 const struct type* type_struct;
2749 short int is_nullable;
2750 const char* var_class_name;
2751 /* Covariant cast for argument 0 (second) <p0:nullable Object> isa S */
2752 /* <p0:nullable Object> isa S */
2753 type_struct = self->type->resolution_table->types[COLOR_standard__Couple___35dS];
2754 cltype = type_struct->color;
2755 idtype = type_struct->id;
2756 is_nullable = type_struct->is_nullable;
2757 if(p0 == NULL) {
2758 var = is_nullable;
2759 } else {
2760 if(cltype >= p0->type->table_size) {
2761 var = 0;
2762 } else {
2763 var = p0->type->type_table[cltype] == idtype;
2764 }
2765 }
2766 if (unlikely(!var)) {
2767 var_class_name = p0 == NULL ? "null" : p0->type->name;
2768 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "S", var_class_name);
2769 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 997);
2770 show_backtrace(1);
2771 }
2772 self->attrs[COLOR_standard__abstract_collection__Couple___second].val = p0; /* _second on <self:Couple[nullable Object, nullable Object]> */
2773 RET_LABEL:;
2774 }
2775 /* method abstract_collection#Couple#init for (self: Couple[nullable Object, nullable Object]) */
2776 void standard___standard__Couple___standard__kernel__Object__init(val* self) {
2777 {
2778 ((void (*)(val* self))(self->class->vft[COLOR_standard___standard__Couple___standard__kernel__Object__init]))(self) /* init on <self:Couple[nullable Object, nullable Object]>*/;
2779 }
2780 RET_LABEL:;
2781 }