c_src/standard__list.sep.1.c

   1 #include "standard__list.sep.0.h"
   2 /* method list#List#[] for (self: List[nullable Object], Int): nullable Object */
   3 val* standard___standard__List___standard__abstract_collection__SequenceRead___91d_93d(val* self, long p0) {
   4 val* var /* : nullable Object */;
   5 long var_index /* var index: Int */;
   6 val* var1 /* : nullable ListNode[nullable Object] */;
   7 val* var2 /* : nullable Object */;
   8 val* var4 /* : nullable Object */;
   9 var_index = p0;
  10 {
  11 var1 = standard___standard__List___get_node(self, var_index);
  12 }
  13 if (var1 == NULL) {
  14 PRINT_ERROR("Runtime error: %s", "Receiver is null");
  15 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 24);
  16 show_backtrace(1);
  17 } else {
  18 { /* Inline abstract_collection#Container#item (var1) on <var1:nullable ListNode[nullable Object]> */
  19 if (unlikely(var1 == NULL)) {
  20 PRINT_ERROR("Runtime error: %s", "Receiver is null");
  21 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 232);
  22 show_backtrace(1);
  23 }
  24 var4 = var1->attrs[COLOR_standard__abstract_collection__Container___item].val; /* _item on <var1:nullable ListNode[nullable Object]> */
  25 var2 = var4;
  26 RET_LABEL3:(void)0;
  27 }
  28 }
  29 var = var2;
  30 goto RET_LABEL;
  31 RET_LABEL:;
  32 return var;
  33 }
  34 /* method list#List#[]= for (self: List[nullable Object], Int, nullable Object) */
  35 void standard___standard__List___standard__abstract_collection__Sequence___91d_93d_61d(val* self, long p0, val* p1) {
  36 short int var /* : Bool */;
  37 int cltype;
  38 int idtype;
  39 const struct type* type_struct;
  40 short int is_nullable;
  41 const char* var_class_name;
  42 long var_index /* var index: Int */;
  43 val* var_item /* var item: nullable Object */;
  44 val* var1 /* : nullable ListNode[nullable Object] */;
  45 short int var3 /* : Bool */;
  46 int cltype4;
  47 int idtype5;
  48 const struct type* type_struct6;
  49 short int is_nullable7;
  50 const char* var_class_name8;
  51 /* Covariant cast for argument 1 (item) <p1:nullable Object> isa E */
  52 /* <p1:nullable Object> isa E */
  53 type_struct = self->type->resolution_table->types[COLOR_standard__List___35dE];
  54 cltype = type_struct->color;
  55 idtype = type_struct->id;
  56 is_nullable = type_struct->is_nullable;
  57 if(p1 == NULL) {
  58 var = is_nullable;
  59 } else {
  60 if(cltype >= p1->type->table_size) {
  61 var = 0;
  62 } else {
  63 var = p1->type->type_table[cltype] == idtype;
  64 }
  65 }
  66 if (unlikely(!var)) {
  67 var_class_name = p1 == NULL ? "null" : p1->type->name;
  68 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
  69 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 26);
  70 show_backtrace(1);
  71 }
  72 var_index = p0;
  73 var_item = p1;
  74 {
  75 var1 = standard___standard__List___get_node(self, var_index);
  76 }
  77 if (var1 == NULL) {
  78 PRINT_ERROR("Runtime error: %s", "Receiver is null");
  79 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 26);
  80 show_backtrace(1);
  81 } else {
  82 { /* Inline abstract_collection#Container#item= (var1,var_item) on <var1:nullable ListNode[nullable Object]> */
  83 /* Covariant cast for argument 0 (item) <var_item:nullable Object> isa E */
  84 /* <var_item:nullable Object> isa E */
  85 type_struct6 = var1->type->resolution_table->types[COLOR_standard__Container___35dE];
  86 cltype4 = type_struct6->color;
  87 idtype5 = type_struct6->id;
  88 is_nullable7 = type_struct6->is_nullable;
  89 if(var_item == NULL) {
  90 var3 = is_nullable7;
  91 } else {
  92 if(cltype4 >= var_item->type->table_size) {
  93 var3 = 0;
  94 } else {
  95 var3 = var_item->type->type_table[cltype4] == idtype5;
  96 }
  97 }
  98 if (unlikely(!var3)) {
  99 var_class_name8 = var_item == NULL ? "null" : var_item->type->name;
 100 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name8);
 101 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 232);
 102 show_backtrace(1);
 103 }
 104 if (unlikely(var1 == NULL)) {
 105 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 106 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 232);
 107 show_backtrace(1);
 108 }
 109 var1->attrs[COLOR_standard__abstract_collection__Container___item].val = var_item; /* _item on <var1:nullable ListNode[nullable Object]> */
 110 RET_LABEL2:(void)0;
 111 }
 112 }
 113 RET_LABEL:;
 114 }
 115 /* method list#List#first for (self: List[nullable Object]): nullable Object */
 116 val* standard___standard__List___standard__abstract_collection__Collection__first(val* self) {
 117 val* var /* : nullable Object */;
 118 val* var1 /* : nullable ListNode[nullable Object] */;
 119 val* var2 /* : nullable Object */;
 120 val* var4 /* : nullable Object */;
 121 var1 = self->attrs[COLOR_standard__list__List___head].val; /* _head on <self:List[nullable Object]> */
 122 if (var1 == NULL) {
 123 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 124 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 29);
 125 show_backtrace(1);
 126 } else {
 127 { /* Inline abstract_collection#Container#item (var1) on <var1:nullable ListNode[nullable Object]> */
 128 if (unlikely(var1 == NULL)) {
 129 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 130 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 232);
 131 show_backtrace(1);
 132 }
 133 var4 = var1->attrs[COLOR_standard__abstract_collection__Container___item].val; /* _item on <var1:nullable ListNode[nullable Object]> */
 134 var2 = var4;
 135 RET_LABEL3:(void)0;
 136 }
 137 }
 138 var = var2;
 139 goto RET_LABEL;
 140 RET_LABEL:;
 141 return var;
 142 }
 143 /* method list#List#first= for (self: List[nullable Object], nullable Object) */
 144 void standard___standard__List___standard__abstract_collection__Sequence__first_61d(val* self, val* p0) {
 145 short int var /* : Bool */;
 146 int cltype;
 147 int idtype;
 148 const struct type* type_struct;
 149 short int is_nullable;
 150 const char* var_class_name;
 151 val* var_e /* var e: nullable Object */;
 152 val* var1 /* : nullable ListNode[nullable Object] */;
 153 short int var3 /* : Bool */;
 154 int cltype4;
 155 int idtype5;
 156 const struct type* type_struct6;
 157 short int is_nullable7;
 158 const char* var_class_name8;
 159 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa E */
 160 /* <p0:nullable Object> isa E */
 161 type_struct = self->type->resolution_table->types[COLOR_standard__List___35dE];
 162 cltype = type_struct->color;
 163 idtype = type_struct->id;
 164 is_nullable = type_struct->is_nullable;
 165 if(p0 == NULL) {
 166 var = is_nullable;
 167 } else {
 168 if(cltype >= p0->type->table_size) {
 169 var = 0;
 170 } else {
 171 var = p0->type->type_table[cltype] == idtype;
 172 }
 173 }
 174 if (unlikely(!var)) {
 175 var_class_name = p0 == NULL ? "null" : p0->type->name;
 176 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
 177 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 31);
 178 show_backtrace(1);
 179 }
 180 var_e = p0;
 181 var1 = self->attrs[COLOR_standard__list__List___head].val; /* _head on <self:List[nullable Object]> */
 182 if (var1 == NULL) {
 183 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 184 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 32);
 185 show_backtrace(1);
 186 } else {
 187 { /* Inline abstract_collection#Container#item= (var1,var_e) on <var1:nullable ListNode[nullable Object]> */
 188 /* Covariant cast for argument 0 (item) <var_e:nullable Object> isa E */
 189 /* <var_e:nullable Object> isa E */
 190 type_struct6 = var1->type->resolution_table->types[COLOR_standard__Container___35dE];
 191 cltype4 = type_struct6->color;
 192 idtype5 = type_struct6->id;
 193 is_nullable7 = type_struct6->is_nullable;
 194 if(var_e == NULL) {
 195 var3 = is_nullable7;
 196 } else {
 197 if(cltype4 >= var_e->type->table_size) {
 198 var3 = 0;
 199 } else {
 200 var3 = var_e->type->type_table[cltype4] == idtype5;
 201 }
 202 }
 203 if (unlikely(!var3)) {
 204 var_class_name8 = var_e == NULL ? "null" : var_e->type->name;
 205 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name8);
 206 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 232);
 207 show_backtrace(1);
 208 }
 209 if (unlikely(var1 == NULL)) {
 210 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 211 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 232);
 212 show_backtrace(1);
 213 }
 214 var1->attrs[COLOR_standard__abstract_collection__Container___item].val = var_e; /* _item on <var1:nullable ListNode[nullable Object]> */
 215 RET_LABEL2:(void)0;
 216 }
 217 }
 218 RET_LABEL:;
 219 }
 220 /* method list#List#last for (self: List[nullable Object]): nullable Object */
 221 val* standard___standard__List___standard__abstract_collection__SequenceRead__last(val* self) {
 222 val* var /* : nullable Object */;
 223 val* var1 /* : nullable ListNode[nullable Object] */;
 224 val* var2 /* : nullable Object */;
 225 val* var4 /* : nullable Object */;
 226 var1 = self->attrs[COLOR_standard__list__List___tail].val; /* _tail on <self:List[nullable Object]> */
 227 if (var1 == NULL) {
 228 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 229 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 35);
 230 show_backtrace(1);
 231 } else {
 232 { /* Inline abstract_collection#Container#item (var1) on <var1:nullable ListNode[nullable Object]> */
 233 if (unlikely(var1 == NULL)) {
 234 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 235 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 232);
 236 show_backtrace(1);
 237 }
 238 var4 = var1->attrs[COLOR_standard__abstract_collection__Container___item].val; /* _item on <var1:nullable ListNode[nullable Object]> */
 239 var2 = var4;
 240 RET_LABEL3:(void)0;
 241 }
 242 }
 243 var = var2;
 244 goto RET_LABEL;
 245 RET_LABEL:;
 246 return var;
 247 }
 248 /* method list#List#is_empty for (self: List[nullable Object]): Bool */
 249 short int standard___standard__List___standard__abstract_collection__Collection__is_empty(val* self) {
 250 short int var /* : Bool */;
 251 val* var1 /* : nullable ListNode[nullable Object] */;
 252 val* var2 /* : null */;
 253 short int var3 /* : Bool */;
 254 short int var4 /* : Bool */;
 255 val* var_other /* var other: nullable Object */;
 256 short int var6 /* : Bool */;
 257 short int var8 /* : Bool */;
 258 var1 = self->attrs[COLOR_standard__list__List___head].val; /* _head on <self:List[nullable Object]> */
 259 var2 = NULL;
 260 if (var1 == NULL) {
 261 var3 = 1; /* is null */
 262 } else {
 263 var3 = 0; /* arg is null but recv is not */
 264 }
 265 if (0) {
 266 { /* Inline kernel#Object#== (var1,var2) on <var1:nullable ListNode[nullable Object]> */
 267 var_other = var2;
 268 {
 269 { /* Inline kernel#Object#is_same_instance (var1,var_other) on <var1:nullable ListNode[nullable Object](ListNode[nullable Object])> */
 270 var8 = var1 == var_other;
 271 var6 = var8;
 272 goto RET_LABEL7;
 273 RET_LABEL7:(void)0;
 274 }
 275 }
 276 var4 = var6;
 277 goto RET_LABEL5;
 278 RET_LABEL5:(void)0;
 279 }
 280 var3 = var4;
 281 }
 282 var = var3;
 283 goto RET_LABEL;
 284 RET_LABEL:;
 285 return var;
 286 }
 287 /* method list#List#length for (self: List[nullable Object]): Int */
 288 long standard___standard__List___standard__abstract_collection__Collection__length(val* self) {
 289 long var /* : Int */;
 290 long var1 /* : Int */;
 291 long var_l /* var l: Int */;
 292 val* var2 /* : nullable ListNode[nullable Object] */;
 293 val* var_t /* var t: nullable ListNode[nullable Object] */;
 294 val* var3 /* : null */;
 295 short int var4 /* : Bool */;
 296 short int var5 /* : Bool */;
 297 val* var_other /* var other: nullable Object */;
 298 short int var7 /* : Bool */;
 299 short int var8 /* : Bool */;
 300 long var9 /* : Int */;
 301 long var10 /* : Int */;
 302 short int var12 /* : Bool */;
 303 int cltype;
 304 int idtype;
 305 const char* var_class_name;
 306 long var13 /* : Int */;
 307 val* var14 /* : nullable ListNode[nullable Object] */;
 308 val* var16 /* : nullable ListNode[nullable Object] */;
 309 var1 = 0;
 310 var_l = var1;
 311 var2 = self->attrs[COLOR_standard__list__List___head].val; /* _head on <self:List[nullable Object]> */
 312 var_t = var2;
 313 for(;;) {
 314 var3 = NULL;
 315 if (var_t == NULL) {
 316 var4 = 0; /* is null */
 317 } else {
 318 var4 = 1; /* arg is null and recv is not */
 319 }
 320 if (0) {
 321 { /* Inline kernel#Object#!= (var_t,var3) on <var_t:nullable ListNode[nullable Object]> */
 322 var_other = var3;
 323 {
 324 var7 = ((short int (*)(val* self, val* p0))(var_t->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_t, var_other) /* == on <var_t:nullable ListNode[nullable Object](ListNode[nullable Object])>*/;
 325 }
 326 var8 = !var7;
 327 var5 = var8;
 328 goto RET_LABEL6;
 329 RET_LABEL6:(void)0;
 330 }
 331 var4 = var5;
 332 }
 333 if (var4){
 334 var9 = 1;
 335 {
 336 { /* Inline kernel#Int#+ (var_l,var9) on <var_l:Int> */
 337 /* Covariant cast for argument 0 (i) <var9:Int> isa OTHER */
 338 /* <var9:Int> isa OTHER */
 339 var12 = 1; /* easy <var9:Int> isa OTHER*/
 340 if (unlikely(!var12)) {
 341 var_class_name = type_standard__Int.name;
 342 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
 343 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413);
 344 show_backtrace(1);
 345 }
 346 var13 = var_l + var9;
 347 var10 = var13;
 348 goto RET_LABEL11;
 349 RET_LABEL11:(void)0;
 350 }
 351 }
 352 var_l = var10;
 353 {
 354 { /* Inline list#ListNode#next (var_t) on <var_t:nullable ListNode[nullable Object](ListNode[nullable Object])> */
 355 var16 = var_t->attrs[COLOR_standard__list__ListNode___next].val; /* _next on <var_t:nullable ListNode[nullable Object](ListNode[nullable Object])> */
 356 var14 = var16;
 357 RET_LABEL15:(void)0;
 358 }
 359 }
 360 var_t = var14;
 361 } else {
 362 goto BREAK_label;
 363 }
 364 }
 365 BREAK_label: (void)0;
 366 var = var_l;
 367 goto RET_LABEL;
 368 RET_LABEL:;
 369 return var;
 370 }
 371 /* method list#List#has for (self: List[nullable Object], nullable Object): Bool */
 372 short int standard___standard__List___standard__abstract_collection__Collection__has(val* self, val* p0) {
 373 short int var /* : Bool */;
 374 short int var1 /* : Bool */;
 375 int cltype;
 376 int idtype;
 377 const struct type* type_struct;
 378 short int is_nullable;
 379 const char* var_class_name;
 380 val* var_e /* var e: nullable Object */;
 381 val* var2 /* : nullable ListNode[nullable Object] */;
 382 val* var3 /* : nullable ListNode[nullable Object] */;
 383 val* var4 /* : null */;
 384 short int var5 /* : Bool */;
 385 short int var6 /* : Bool */;
 386 val* var_other /* var other: nullable Object */;
 387 short int var8 /* : Bool */;
 388 short int var9 /* : Bool */;
 389 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa E */
 390 /* <p0:nullable Object> isa E */
 391 type_struct = self->type->resolution_table->types[COLOR_standard__List___35dE];
 392 cltype = type_struct->color;
 393 idtype = type_struct->id;
 394 is_nullable = type_struct->is_nullable;
 395 if(p0 == NULL) {
 396 var1 = is_nullable;
 397 } else {
 398 if(cltype >= p0->type->table_size) {
 399 var1 = 0;
 400 } else {
 401 var1 = p0->type->type_table[cltype] == idtype;
 402 }
 403 }
 404 if (unlikely(!var1)) {
 405 var_class_name = p0 == NULL ? "null" : p0->type->name;
 406 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
 407 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 57);
 408 show_backtrace(1);
 409 }
 410 var_e = p0;
 411 var2 = self->attrs[COLOR_standard__list__List___head].val; /* _head on <self:List[nullable Object]> */
 412 {
 413 var3 = standard___standard__List___search_node_after(self, var_e, var2);
 414 }
 415 var4 = NULL;
 416 if (var3 == NULL) {
 417 var5 = 0; /* is null */
 418 } else {
 419 var5 = 1; /* arg is null and recv is not */
 420 }
 421 if (0) {
 422 { /* Inline kernel#Object#!= (var3,var4) on <var3:nullable ListNode[nullable Object]> */
 423 var_other = var4;
 424 {
 425 var8 = ((short int (*)(val* self, val* p0))(var3->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var3, var_other) /* == on <var3:nullable ListNode[nullable Object](ListNode[nullable Object])>*/;
 426 }
 427 var9 = !var8;
 428 var6 = var9;
 429 goto RET_LABEL7;
 430 RET_LABEL7:(void)0;
 431 }
 432 var5 = var6;
 433 }
 434 var = var5;
 435 goto RET_LABEL;
 436 RET_LABEL:;
 437 return var;
 438 }
 439 /* method list#List#push for (self: List[nullable Object], nullable Object) */
 440 void standard___standard__List___standard__abstract_collection__Sequence__push(val* self, val* p0) {
 441 short int var /* : Bool */;
 442 int cltype;
 443 int idtype;
 444 const struct type* type_struct;
 445 short int is_nullable;
 446 const char* var_class_name;
 447 val* var_e /* var e: nullable Object */;
 448 val* var1 /* : ListNode[nullable Object] */;
 449 val* var_node /* var node: ListNode[nullable Object] */;
 450 val* var2 /* : nullable ListNode[nullable Object] */;
 451 val* var3 /* : null */;
 452 short int var4 /* : Bool */;
 453 short int var5 /* : Bool */;
 454 val* var_other /* var other: nullable Object */;
 455 short int var7 /* : Bool */;
 456 short int var9 /* : Bool */;
 457 val* var10 /* : nullable ListNode[nullable Object] */;
 458 short int var12 /* : Bool */;
 459 int cltype13;
 460 int idtype14;
 461 const struct type* type_struct15;
 462 const char* var_class_name16;
 463 val* var17 /* : nullable ListNode[nullable Object] */;
 464 short int var19 /* : Bool */;
 465 int cltype20;
 466 int idtype21;
 467 const struct type* type_struct22;
 468 const char* var_class_name23;
 469 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa E */
 470 /* <p0:nullable Object> isa E */
 471 type_struct = self->type->resolution_table->types[COLOR_standard__List___35dE];
 472 cltype = type_struct->color;
 473 idtype = type_struct->id;
 474 is_nullable = type_struct->is_nullable;
 475 if(p0 == NULL) {
 476 var = is_nullable;
 477 } else {
 478 if(cltype >= p0->type->table_size) {
 479 var = 0;
 480 } else {
 481 var = p0->type->type_table[cltype] == idtype;
 482 }
 483 }
 484 if (unlikely(!var)) {
 485 var_class_name = p0 == NULL ? "null" : p0->type->name;
 486 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
 487 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 95);
 488 show_backtrace(1);
 489 }
 490 var_e = p0;
 491 var1 = NEW_standard__list__ListNode(self->type->resolution_table->types[COLOR_standard__list__ListNode__standard__List___35dE]);
 492 {
 493 ((void (*)(val* self, val* p0))(var1->class->vft[COLOR_standard__abstract_collection__Container__item_61d]))(var1, var_e) /* item= on <var1:ListNode[nullable Object]>*/;
 494 }
 495 {
 496 ((void (*)(val* self))(var1->class->vft[COLOR_standard__kernel__Object__init]))(var1) /* init on <var1:ListNode[nullable Object]>*/;
 497 }
 498 var_node = var1;
 499 var2 = self->attrs[COLOR_standard__list__List___tail].val; /* _tail on <self:List[nullable Object]> */
 500 var3 = NULL;
 501 if (var2 == NULL) {
 502 var4 = 1; /* is null */
 503 } else {
 504 var4 = 0; /* arg is null but recv is not */
 505 }
 506 if (0) {
 507 { /* Inline kernel#Object#== (var2,var3) on <var2:nullable ListNode[nullable Object]> */
 508 var_other = var3;
 509 {
 510 { /* Inline kernel#Object#is_same_instance (var2,var_other) on <var2:nullable ListNode[nullable Object](ListNode[nullable Object])> */
 511 var9 = var2 == var_other;
 512 var7 = var9;
 513 goto RET_LABEL8;
 514 RET_LABEL8:(void)0;
 515 }
 516 }
 517 var5 = var7;
 518 goto RET_LABEL6;
 519 RET_LABEL6:(void)0;
 520 }
 521 var4 = var5;
 522 }
 523 if (var4){
 524 self->attrs[COLOR_standard__list__List___head].val = var_node; /* _head on <self:List[nullable Object]> */
 525 } else {
 526 var10 = self->attrs[COLOR_standard__list__List___tail].val; /* _tail on <self:List[nullable Object]> */
 527 if (var10 == NULL) {
 528 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 529 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 102);
 530 show_backtrace(1);
 531 } else {
 532 { /* Inline list#ListNode#next= (var10,var_node) on <var10:nullable ListNode[nullable Object]> */
 533 /* Covariant cast for argument 0 (next) <var_node:ListNode[nullable Object]> isa nullable ListNode[E] */
 534 /* <var_node:ListNode[nullable Object]> isa nullable ListNode[E] */
 535 type_struct15 = var10->type->resolution_table->types[COLOR_nullable__standard__list__ListNode__standard__list__ListNode___35dE];
 536 cltype13 = type_struct15->color;
 537 idtype14 = type_struct15->id;
 538 if(cltype13 >= var_node->type->table_size) {
 539 var12 = 0;
 540 } else {
 541 var12 = var_node->type->type_table[cltype13] == idtype14;
 542 }
 543 if (unlikely(!var12)) {
 544 var_class_name16 = var_node == NULL ? "null" : var_node->type->name;
 545 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[E]", var_class_name16);
 546 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 341);
 547 show_backtrace(1);
 548 }
 549 if (unlikely(var10 == NULL)) {
 550 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 551 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 341);
 552 show_backtrace(1);
 553 }
 554 var10->attrs[COLOR_standard__list__ListNode___next].val = var_node; /* _next on <var10:nullable ListNode[nullable Object]> */
 555 RET_LABEL11:(void)0;
 556 }
 557 }
 558 var17 = self->attrs[COLOR_standard__list__List___tail].val; /* _tail on <self:List[nullable Object]> */
 559 {
 560 { /* Inline list#ListNode#prev= (var_node,var17) on <var_node:ListNode[nullable Object]> */
 561 /* Covariant cast for argument 0 (prev) <var17:nullable ListNode[nullable Object]> isa nullable ListNode[E] */
 562 /* <var17:nullable ListNode[nullable Object]> isa nullable ListNode[E] */
 563 type_struct22 = var_node->type->resolution_table->types[COLOR_nullable__standard__list__ListNode__standard__list__ListNode___35dE];
 564 cltype20 = type_struct22->color;
 565 idtype21 = type_struct22->id;
 566 if(var17 == NULL) {
 567 var19 = 1;
 568 } else {
 569 if(cltype20 >= var17->type->table_size) {
 570 var19 = 0;
 571 } else {
 572 var19 = var17->type->type_table[cltype20] == idtype21;
 573 }
 574 }
 575 if (unlikely(!var19)) {
 576 var_class_name23 = var17 == NULL ? "null" : var17->type->name;
 577 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[E]", var_class_name23);
 578 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 344);
 579 show_backtrace(1);
 580 }
 581 var_node->attrs[COLOR_standard__list__ListNode___prev].val = var17; /* _prev on <var_node:ListNode[nullable Object]> */
 582 RET_LABEL18:(void)0;
 583 }
 584 }
 585 }
 586 self->attrs[COLOR_standard__list__List___tail].val = var_node; /* _tail on <self:List[nullable Object]> */
 587 RET_LABEL:;
 588 }
 589 /* method list#List#unshift for (self: List[nullable Object], nullable Object) */
 590 void standard___standard__List___standard__abstract_collection__Sequence__unshift(val* self, val* p0) {
 591 short int var /* : Bool */;
 592 int cltype;
 593 int idtype;
 594 const struct type* type_struct;
 595 short int is_nullable;
 596 const char* var_class_name;
 597 val* var_e /* var e: nullable Object */;
 598 val* var1 /* : ListNode[nullable Object] */;
 599 val* var_node /* var node: ListNode[nullable Object] */;
 600 val* var2 /* : nullable ListNode[nullable Object] */;
 601 val* var3 /* : null */;
 602 short int var4 /* : Bool */;
 603 short int var5 /* : Bool */;
 604 val* var_other /* var other: nullable Object */;
 605 short int var7 /* : Bool */;
 606 short int var9 /* : Bool */;
 607 val* var10 /* : nullable ListNode[nullable Object] */;
 608 short int var12 /* : Bool */;
 609 int cltype13;
 610 int idtype14;
 611 const struct type* type_struct15;
 612 const char* var_class_name16;
 613 val* var17 /* : nullable ListNode[nullable Object] */;
 614 short int var19 /* : Bool */;
 615 int cltype20;
 616 int idtype21;
 617 const struct type* type_struct22;
 618 const char* var_class_name23;
 619 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa E */
 620 /* <p0:nullable Object> isa E */
 621 type_struct = self->type->resolution_table->types[COLOR_standard__List___35dE];
 622 cltype = type_struct->color;
 623 idtype = type_struct->id;
 624 is_nullable = type_struct->is_nullable;
 625 if(p0 == NULL) {
 626 var = is_nullable;
 627 } else {
 628 if(cltype >= p0->type->table_size) {
 629 var = 0;
 630 } else {
 631 var = p0->type->type_table[cltype] == idtype;
 632 }
 633 }
 634 if (unlikely(!var)) {
 635 var_class_name = p0 == NULL ? "null" : p0->type->name;
 636 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
 637 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 108);
 638 show_backtrace(1);
 639 }
 640 var_e = p0;
 641 var1 = NEW_standard__list__ListNode(self->type->resolution_table->types[COLOR_standard__list__ListNode__standard__List___35dE]);
 642 {
 643 ((void (*)(val* self, val* p0))(var1->class->vft[COLOR_standard__abstract_collection__Container__item_61d]))(var1, var_e) /* item= on <var1:ListNode[nullable Object]>*/;
 644 }
 645 {
 646 ((void (*)(val* self))(var1->class->vft[COLOR_standard__kernel__Object__init]))(var1) /* init on <var1:ListNode[nullable Object]>*/;
 647 }
 648 var_node = var1;
 649 var2 = self->attrs[COLOR_standard__list__List___head].val; /* _head on <self:List[nullable Object]> */
 650 var3 = NULL;
 651 if (var2 == NULL) {
 652 var4 = 1; /* is null */
 653 } else {
 654 var4 = 0; /* arg is null but recv is not */
 655 }
 656 if (0) {
 657 { /* Inline kernel#Object#== (var2,var3) on <var2:nullable ListNode[nullable Object]> */
 658 var_other = var3;
 659 {
 660 { /* Inline kernel#Object#is_same_instance (var2,var_other) on <var2:nullable ListNode[nullable Object](ListNode[nullable Object])> */
 661 var9 = var2 == var_other;
 662 var7 = var9;
 663 goto RET_LABEL8;
 664 RET_LABEL8:(void)0;
 665 }
 666 }
 667 var5 = var7;
 668 goto RET_LABEL6;
 669 RET_LABEL6:(void)0;
 670 }
 671 var4 = var5;
 672 }
 673 if (var4){
 674 self->attrs[COLOR_standard__list__List___tail].val = var_node; /* _tail on <self:List[nullable Object]> */
 675 } else {
 676 var10 = self->attrs[COLOR_standard__list__List___head].val; /* _head on <self:List[nullable Object]> */
 677 {
 678 { /* Inline list#ListNode#next= (var_node,var10) on <var_node:ListNode[nullable Object]> */
 679 /* Covariant cast for argument 0 (next) <var10:nullable ListNode[nullable Object]> isa nullable ListNode[E] */
 680 /* <var10:nullable ListNode[nullable Object]> isa nullable ListNode[E] */
 681 type_struct15 = var_node->type->resolution_table->types[COLOR_nullable__standard__list__ListNode__standard__list__ListNode___35dE];
 682 cltype13 = type_struct15->color;
 683 idtype14 = type_struct15->id;
 684 if(var10 == NULL) {
 685 var12 = 1;
 686 } else {
 687 if(cltype13 >= var10->type->table_size) {
 688 var12 = 0;
 689 } else {
 690 var12 = var10->type->type_table[cltype13] == idtype14;
 691 }
 692 }
 693 if (unlikely(!var12)) {
 694 var_class_name16 = var10 == NULL ? "null" : var10->type->name;
 695 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[E]", var_class_name16);
 696 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 341);
 697 show_backtrace(1);
 698 }
 699 var_node->attrs[COLOR_standard__list__ListNode___next].val = var10; /* _next on <var_node:ListNode[nullable Object]> */
 700 RET_LABEL11:(void)0;
 701 }
 702 }
 703 var17 = self->attrs[COLOR_standard__list__List___head].val; /* _head on <self:List[nullable Object]> */
 704 if (var17 == NULL) {
 705 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 706 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 116);
 707 show_backtrace(1);
 708 } else {
 709 { /* Inline list#ListNode#prev= (var17,var_node) on <var17:nullable ListNode[nullable Object]> */
 710 /* Covariant cast for argument 0 (prev) <var_node:ListNode[nullable Object]> isa nullable ListNode[E] */
 711 /* <var_node:ListNode[nullable Object]> isa nullable ListNode[E] */
 712 type_struct22 = var17->type->resolution_table->types[COLOR_nullable__standard__list__ListNode__standard__list__ListNode___35dE];
 713 cltype20 = type_struct22->color;
 714 idtype21 = type_struct22->id;
 715 if(cltype20 >= var_node->type->table_size) {
 716 var19 = 0;
 717 } else {
 718 var19 = var_node->type->type_table[cltype20] == idtype21;
 719 }
 720 if (unlikely(!var19)) {
 721 var_class_name23 = var_node == NULL ? "null" : var_node->type->name;
 722 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[E]", var_class_name23);
 723 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 344);
 724 show_backtrace(1);
 725 }
 726 if (unlikely(var17 == NULL)) {
 727 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 728 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 344);
 729 show_backtrace(1);
 730 }
 731 var17->attrs[COLOR_standard__list__ListNode___prev].val = var_node; /* _prev on <var17:nullable ListNode[nullable Object]> */
 732 RET_LABEL18:(void)0;
 733 }
 734 }
 735 }
 736 self->attrs[COLOR_standard__list__List___head].val = var_node; /* _head on <self:List[nullable Object]> */
 737 RET_LABEL:;
 738 }
 739 /* method list#List#insert for (self: List[nullable Object], nullable Object, Int) */
 740 void standard___standard__List___standard__abstract_collection__Sequence__insert(val* self, val* p0, long p1) {
 741 short int var /* : Bool */;
 742 int cltype;
 743 int idtype;
 744 const struct type* type_struct;
 745 short int is_nullable;
 746 const char* var_class_name;
 747 val* var_e /* var e: nullable Object */;
 748 long var_i /* var i: Int */;
 749 val* var1 /* : nullable ListNode[nullable Object] */;
 750 val* var_node /* var node: nullable ListNode[nullable Object] */;
 751 val* var2 /* : null */;
 752 short int var3 /* : Bool */;
 753 short int var4 /* : Bool */;
 754 val* var_other /* var other: nullable Object */;
 755 short int var6 /* : Bool */;
 756 short int var8 /* : Bool */;
 757 val* var9 /* : ListNode[nullable Object] */;
 758 val* var_nnode /* var nnode: ListNode[nullable Object] */;
 759 val* var10 /* : nullable ListNode[nullable Object] */;
 760 val* var12 /* : nullable ListNode[nullable Object] */;
 761 val* var_next /* var next: nullable ListNode[nullable Object] */;
 762 val* var13 /* : null */;
 763 short int var14 /* : Bool */;
 764 short int var15 /* : Bool */;
 765 short int var17 /* : Bool */;
 766 short int var19 /* : Bool */;
 767 short int var21 /* : Bool */;
 768 int cltype22;
 769 int idtype23;
 770 const struct type* type_struct24;
 771 const char* var_class_name25;
 772 short int var27 /* : Bool */;
 773 int cltype28;
 774 int idtype29;
 775 const struct type* type_struct30;
 776 const char* var_class_name31;
 777 short int var33 /* : Bool */;
 778 int cltype34;
 779 int idtype35;
 780 const struct type* type_struct36;
 781 const char* var_class_name37;
 782 short int var39 /* : Bool */;
 783 int cltype40;
 784 int idtype41;
 785 const struct type* type_struct42;
 786 const char* var_class_name43;
 787 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa E */
 788 /* <p0:nullable Object> isa E */
 789 type_struct = self->type->resolution_table->types[COLOR_standard__List___35dE];
 790 cltype = type_struct->color;
 791 idtype = type_struct->id;
 792 is_nullable = type_struct->is_nullable;
 793 if(p0 == NULL) {
 794 var = is_nullable;
 795 } else {
 796 if(cltype >= p0->type->table_size) {
 797 var = 0;
 798 } else {
 799 var = p0->type->type_table[cltype] == idtype;
 800 }
 801 }
 802 if (unlikely(!var)) {
 803 var_class_name = p0 == NULL ? "null" : p0->type->name;
 804 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
 805 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 121);
 806 show_backtrace(1);
 807 }
 808 var_e = p0;
 809 var_i = p1;
 810 {
 811 var1 = standard___standard__List___get_node(self, var_i);
 812 }
 813 var_node = var1;
 814 var2 = NULL;
 815 if (var_node == NULL) {
 816 var3 = 1; /* is null */
 817 } else {
 818 var3 = 0; /* arg is null but recv is not */
 819 }
 820 if (0) {
 821 { /* Inline kernel#Object#== (var_node,var2) on <var_node:nullable ListNode[nullable Object]> */
 822 var_other = var2;
 823 {
 824 { /* Inline kernel#Object#is_same_instance (var_node,var_other) on <var_node:nullable ListNode[nullable Object](ListNode[nullable Object])> */
 825 var8 = var_node == var_other;
 826 var6 = var8;
 827 goto RET_LABEL7;
 828 RET_LABEL7:(void)0;
 829 }
 830 }
 831 var4 = var6;
 832 goto RET_LABEL5;
 833 RET_LABEL5:(void)0;
 834 }
 835 var3 = var4;
 836 }
 837 if (var3){
 838 {
 839 standard___standard__List___standard__abstract_collection__Sequence__push(self, var_e); /* Direct call list#List#push on <self:List[nullable Object]>*/
 840 }
 841 goto RET_LABEL;
 842 } else {
 843 }
 844 var9 = NEW_standard__list__ListNode(self->type->resolution_table->types[COLOR_standard__list__ListNode__standard__List___35dE]);
 845 {
 846 ((void (*)(val* self, val* p0))(var9->class->vft[COLOR_standard__abstract_collection__Container__item_61d]))(var9, var_e) /* item= on <var9:ListNode[nullable Object]>*/;
 847 }
 848 {
 849 ((void (*)(val* self))(var9->class->vft[COLOR_standard__kernel__Object__init]))(var9) /* init on <var9:ListNode[nullable Object]>*/;
 850 }
 851 var_nnode = var9;
 852 {
 853 { /* Inline list#ListNode#next (var_node) on <var_node:nullable ListNode[nullable Object](ListNode[nullable Object])> */
 854 var12 = var_node->attrs[COLOR_standard__list__ListNode___next].val; /* _next on <var_node:nullable ListNode[nullable Object](ListNode[nullable Object])> */
 855 var10 = var12;
 856 RET_LABEL11:(void)0;
 857 }
 858 }
 859 var_next = var10;
 860 var13 = NULL;
 861 if (var_next == NULL) {
 862 var14 = 1; /* is null */
 863 } else {
 864 var14 = 0; /* arg is null but recv is not */
 865 }
 866 if (0) {
 867 { /* Inline kernel#Object#== (var_next,var13) on <var_next:nullable ListNode[nullable Object]> */
 868 var_other = var13;
 869 {
 870 { /* Inline kernel#Object#is_same_instance (var_next,var_other) on <var_next:nullable ListNode[nullable Object](ListNode[nullable Object])> */
 871 var19 = var_next == var_other;
 872 var17 = var19;
 873 goto RET_LABEL18;
 874 RET_LABEL18:(void)0;
 875 }
 876 }
 877 var15 = var17;
 878 goto RET_LABEL16;
 879 RET_LABEL16:(void)0;
 880 }
 881 var14 = var15;
 882 }
 883 if (var14){
 884 self->attrs[COLOR_standard__list__List___tail].val = var_nnode; /* _tail on <self:List[nullable Object]> */
 885 } else {
 886 {
 887 { /* Inline list#ListNode#prev= (var_next,var_nnode) on <var_next:nullable ListNode[nullable Object](ListNode[nullable Object])> */
 888 /* Covariant cast for argument 0 (prev) <var_nnode:ListNode[nullable Object]> isa nullable ListNode[E] */
 889 /* <var_nnode:ListNode[nullable Object]> isa nullable ListNode[E] */
 890 type_struct24 = var_next->type->resolution_table->types[COLOR_nullable__standard__list__ListNode__standard__list__ListNode___35dE];
 891 cltype22 = type_struct24->color;
 892 idtype23 = type_struct24->id;
 893 if(cltype22 >= var_nnode->type->table_size) {
 894 var21 = 0;
 895 } else {
 896 var21 = var_nnode->type->type_table[cltype22] == idtype23;
 897 }
 898 if (unlikely(!var21)) {
 899 var_class_name25 = var_nnode == NULL ? "null" : var_nnode->type->name;
 900 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[E]", var_class_name25);
 901 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 344);
 902 show_backtrace(1);
 903 }
 904 var_next->attrs[COLOR_standard__list__ListNode___prev].val = var_nnode; /* _prev on <var_next:nullable ListNode[nullable Object](ListNode[nullable Object])> */
 905 RET_LABEL20:(void)0;
 906 }
 907 }
 908 }
 909 {
 910 { /* Inline list#ListNode#prev= (var_nnode,var_node) on <var_nnode:ListNode[nullable Object]> */
 911 /* Covariant cast for argument 0 (prev) <var_node:nullable ListNode[nullable Object](ListNode[nullable Object])> isa nullable ListNode[E] */
 912 /* <var_node:nullable ListNode[nullable Object](ListNode[nullable Object])> isa nullable ListNode[E] */
 913 type_struct30 = var_nnode->type->resolution_table->types[COLOR_nullable__standard__list__ListNode__standard__list__ListNode___35dE];
 914 cltype28 = type_struct30->color;
 915 idtype29 = type_struct30->id;
 916 if(cltype28 >= var_node->type->table_size) {
 917 var27 = 0;
 918 } else {
 919 var27 = var_node->type->type_table[cltype28] == idtype29;
 920 }
 921 if (unlikely(!var27)) {
 922 var_class_name31 = var_node == NULL ? "null" : var_node->type->name;
 923 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[E]", var_class_name31);
 924 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 344);
 925 show_backtrace(1);
 926 }
 927 var_nnode->attrs[COLOR_standard__list__ListNode___prev].val = var_node; /* _prev on <var_nnode:ListNode[nullable Object]> */
 928 RET_LABEL26:(void)0;
 929 }
 930 }
 931 {
 932 { /* Inline list#ListNode#next= (var_nnode,var_next) on <var_nnode:ListNode[nullable Object]> */
 933 /* Covariant cast for argument 0 (next) <var_next:nullable ListNode[nullable Object]> isa nullable ListNode[E] */
 934 /* <var_next:nullable ListNode[nullable Object]> isa nullable ListNode[E] */
 935 type_struct36 = var_nnode->type->resolution_table->types[COLOR_nullable__standard__list__ListNode__standard__list__ListNode___35dE];
 936 cltype34 = type_struct36->color;
 937 idtype35 = type_struct36->id;
 938 if(var_next == NULL) {
 939 var33 = 1;
 940 } else {
 941 if(cltype34 >= var_next->type->table_size) {
 942 var33 = 0;
 943 } else {
 944 var33 = var_next->type->type_table[cltype34] == idtype35;
 945 }
 946 }
 947 if (unlikely(!var33)) {
 948 var_class_name37 = var_next == NULL ? "null" : var_next->type->name;
 949 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[E]", var_class_name37);
 950 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 341);
 951 show_backtrace(1);
 952 }
 953 var_nnode->attrs[COLOR_standard__list__ListNode___next].val = var_next; /* _next on <var_nnode:ListNode[nullable Object]> */
 954 RET_LABEL32:(void)0;
 955 }
 956 }
 957 {
 958 { /* Inline list#ListNode#next= (var_node,var_nnode) on <var_node:nullable ListNode[nullable Object](ListNode[nullable Object])> */
 959 /* Covariant cast for argument 0 (next) <var_nnode:ListNode[nullable Object]> isa nullable ListNode[E] */
 960 /* <var_nnode:ListNode[nullable Object]> isa nullable ListNode[E] */
 961 type_struct42 = var_node->type->resolution_table->types[COLOR_nullable__standard__list__ListNode__standard__list__ListNode___35dE];
 962 cltype40 = type_struct42->color;
 963 idtype41 = type_struct42->id;
 964 if(cltype40 >= var_nnode->type->table_size) {
 965 var39 = 0;
 966 } else {
 967 var39 = var_nnode->type->type_table[cltype40] == idtype41;
 968 }
 969 if (unlikely(!var39)) {
 970 var_class_name43 = var_nnode == NULL ? "null" : var_nnode->type->name;
 971 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[E]", var_class_name43);
 972 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 341);
 973 show_backtrace(1);
 974 }
 975 var_node->attrs[COLOR_standard__list__ListNode___next].val = var_nnode; /* _next on <var_node:nullable ListNode[nullable Object](ListNode[nullable Object])> */
 976 RET_LABEL38:(void)0;
 977 }
 978 }
 979 RET_LABEL:;
 980 }
 981 /* method list#List#pop for (self: List[nullable Object]): nullable Object */
 982 val* standard___standard__List___standard__abstract_collection__Sequence__pop(val* self) {
 983 val* var /* : nullable Object */;
 984 val* var1 /* : nullable ListNode[nullable Object] */;
 985 val* var_node /* var node: nullable ListNode[nullable Object] */;
 986 val* var2 /* : nullable ListNode[nullable Object] */;
 987 val* var4 /* : nullable ListNode[nullable Object] */;
 988 val* var5 /* : null */;
 989 short int var7 /* : Bool */;
 990 int cltype;
 991 int idtype;
 992 const char* var_class_name;
 993 val* var8 /* : nullable ListNode[nullable Object] */;
 994 val* var9 /* : null */;
 995 short int var10 /* : Bool */;
 996 short int var11 /* : Bool */;
 997 val* var_other /* var other: nullable Object */;
 998 short int var13 /* : Bool */;
 999 short int var15 /* : Bool */;
1000 val* var16 /* : null */;
1001 val* var17 /* : nullable ListNode[nullable Object] */;
1002 val* var18 /* : null */;
1003 short int var20 /* : Bool */;
1004 int cltype21;
1005 int idtype22;
1006 const char* var_class_name23;
1007 val* var24 /* : nullable Object */;
1008 val* var26 /* : nullable Object */;
1009 var1 = self->attrs[COLOR_standard__list__List___tail].val; /* _tail on <self:List[nullable Object]> */
1010 var_node = var1;
1011 if (var_node == NULL) {
1012 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1013 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 162);
1014 show_backtrace(1);
1015 } else {
1016 { /* Inline list#ListNode#prev (var_node) on <var_node:nullable ListNode[nullable Object]> */
1017 if (unlikely(var_node == NULL)) {
1018 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1019 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 344);
1020 show_backtrace(1);
1021 }
1022 var4 = var_node->attrs[COLOR_standard__list__ListNode___prev].val; /* _prev on <var_node:nullable ListNode[nullable Object]> */
1023 var2 = var4;
1024 RET_LABEL3:(void)0;
1025 }
1026 }
1027 self->attrs[COLOR_standard__list__List___tail].val = var2; /* _tail on <self:List[nullable Object]> */
1028 var5 = NULL;
1029 if (var_node == NULL) {
1030 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1031 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 163);
1032 show_backtrace(1);
1033 } else {
1034 { /* Inline list#ListNode#prev= (var_node,var5) on <var_node:nullable ListNode[nullable Object]> */
1035 /* Covariant cast for argument 0 (prev) <var5:null> isa nullable ListNode[E] */
1036 /* <var5:null> isa nullable ListNode[E] */
1037 var7 = 1; /* easy <var5:null> isa nullable ListNode[E]*/
1038 if (unlikely(!var7)) {
1039 var_class_name = var5 == NULL ? "null" : var5->type->name;
1040 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[E]", var_class_name);
1041 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 344);
1042 show_backtrace(1);
1043 }
1044 if (unlikely(var_node == NULL)) {
1045 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1046 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 344);
1047 show_backtrace(1);
1048 }
1049 var_node->attrs[COLOR_standard__list__ListNode___prev].val = var5; /* _prev on <var_node:nullable ListNode[nullable Object]> */
1050 RET_LABEL6:(void)0;
1051 }
1052 }
1053 var8 = self->attrs[COLOR_standard__list__List___tail].val; /* _tail on <self:List[nullable Object]> */
1054 var9 = NULL;
1055 if (var8 == NULL) {
1056 var10 = 1; /* is null */
1057 } else {
1058 var10 = 0; /* arg is null but recv is not */
1059 }
1060 if (0) {
1061 { /* Inline kernel#Object#== (var8,var9) on <var8:nullable ListNode[nullable Object]> */
1062 var_other = var9;
1063 {
1064 { /* Inline kernel#Object#is_same_instance (var8,var_other) on <var8:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1065 var15 = var8 == var_other;
1066 var13 = var15;
1067 goto RET_LABEL14;
1068 RET_LABEL14:(void)0;
1069 }
1070 }
1071 var11 = var13;
1072 goto RET_LABEL12;
1073 RET_LABEL12:(void)0;
1074 }
1075 var10 = var11;
1076 }
1077 if (var10){
1078 var16 = NULL;
1079 self->attrs[COLOR_standard__list__List___head].val = var16; /* _head on <self:List[nullable Object]> */
1080 } else {
1081 var17 = self->attrs[COLOR_standard__list__List___tail].val; /* _tail on <self:List[nullable Object]> */
1082 var18 = NULL;
1083 if (var17 == NULL) {
1084 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1085 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 167);
1086 show_backtrace(1);
1087 } else {
1088 { /* Inline list#ListNode#next= (var17,var18) on <var17:nullable ListNode[nullable Object]> */
1089 /* Covariant cast for argument 0 (next) <var18:null> isa nullable ListNode[E] */
1090 /* <var18:null> isa nullable ListNode[E] */
1091 var20 = 1; /* easy <var18:null> isa nullable ListNode[E]*/
1092 if (unlikely(!var20)) {
1093 var_class_name23 = var18 == NULL ? "null" : var18->type->name;
1094 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[E]", var_class_name23);
1095 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 341);
1096 show_backtrace(1);
1097 }
1098 if (unlikely(var17 == NULL)) {
1099 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1100 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 341);
1101 show_backtrace(1);
1102 }
1103 var17->attrs[COLOR_standard__list__ListNode___next].val = var18; /* _next on <var17:nullable ListNode[nullable Object]> */
1104 RET_LABEL19:(void)0;
1105 }
1106 }
1107 }
1108 if (var_node == NULL) {
1109 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1110 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 169);
1111 show_backtrace(1);
1112 } else {
1113 { /* Inline abstract_collection#Container#item (var_node) on <var_node:nullable ListNode[nullable Object]> */
1114 if (unlikely(var_node == NULL)) {
1115 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1116 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 232);
1117 show_backtrace(1);
1118 }
1119 var26 = var_node->attrs[COLOR_standard__abstract_collection__Container___item].val; /* _item on <var_node:nullable ListNode[nullable Object]> */
1120 var24 = var26;
1121 RET_LABEL25:(void)0;
1122 }
1123 }
1124 var = var24;
1125 goto RET_LABEL;
1126 RET_LABEL:;
1127 return var;
1128 }
1129 /* method list#List#shift for (self: List[nullable Object]): nullable Object */
1130 val* standard___standard__List___standard__abstract_collection__Sequence__shift(val* self) {
1131 val* var /* : nullable Object */;
1132 val* var1 /* : nullable ListNode[nullable Object] */;
1133 val* var_node /* var node: nullable ListNode[nullable Object] */;
1134 val* var2 /* : nullable ListNode[nullable Object] */;
1135 val* var4 /* : nullable ListNode[nullable Object] */;
1136 val* var5 /* : null */;
1137 short int var7 /* : Bool */;
1138 int cltype;
1139 int idtype;
1140 const char* var_class_name;
1141 val* var8 /* : nullable ListNode[nullable Object] */;
1142 val* var9 /* : null */;
1143 short int var10 /* : Bool */;
1144 short int var11 /* : Bool */;
1145 val* var_other /* var other: nullable Object */;
1146 short int var13 /* : Bool */;
1147 short int var15 /* : Bool */;
1148 val* var16 /* : null */;
1149 val* var17 /* : nullable ListNode[nullable Object] */;
1150 val* var18 /* : null */;
1151 short int var20 /* : Bool */;
1152 int cltype21;
1153 int idtype22;
1154 const char* var_class_name23;
1155 val* var24 /* : nullable Object */;
1156 val* var26 /* : nullable Object */;
1157 var1 = self->attrs[COLOR_standard__list__List___head].val; /* _head on <self:List[nullable Object]> */
1158 var_node = var1;
1159 if (var_node == NULL) {
1160 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1161 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 176);
1162 show_backtrace(1);
1163 } else {
1164 { /* Inline list#ListNode#next (var_node) on <var_node:nullable ListNode[nullable Object]> */
1165 if (unlikely(var_node == NULL)) {
1166 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1167 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 341);
1168 show_backtrace(1);
1169 }
1170 var4 = var_node->attrs[COLOR_standard__list__ListNode___next].val; /* _next on <var_node:nullable ListNode[nullable Object]> */
1171 var2 = var4;
1172 RET_LABEL3:(void)0;
1173 }
1174 }
1175 self->attrs[COLOR_standard__list__List___head].val = var2; /* _head on <self:List[nullable Object]> */
1176 var5 = NULL;
1177 if (var_node == NULL) {
1178 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1179 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 177);
1180 show_backtrace(1);
1181 } else {
1182 { /* Inline list#ListNode#next= (var_node,var5) on <var_node:nullable ListNode[nullable Object]> */
1183 /* Covariant cast for argument 0 (next) <var5:null> isa nullable ListNode[E] */
1184 /* <var5:null> isa nullable ListNode[E] */
1185 var7 = 1; /* easy <var5:null> isa nullable ListNode[E]*/
1186 if (unlikely(!var7)) {
1187 var_class_name = var5 == NULL ? "null" : var5->type->name;
1188 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[E]", var_class_name);
1189 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 341);
1190 show_backtrace(1);
1191 }
1192 if (unlikely(var_node == NULL)) {
1193 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1194 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 341);
1195 show_backtrace(1);
1196 }
1197 var_node->attrs[COLOR_standard__list__ListNode___next].val = var5; /* _next on <var_node:nullable ListNode[nullable Object]> */
1198 RET_LABEL6:(void)0;
1199 }
1200 }
1201 var8 = self->attrs[COLOR_standard__list__List___head].val; /* _head on <self:List[nullable Object]> */
1202 var9 = NULL;
1203 if (var8 == NULL) {
1204 var10 = 1; /* is null */
1205 } else {
1206 var10 = 0; /* arg is null but recv is not */
1207 }
1208 if (0) {
1209 { /* Inline kernel#Object#== (var8,var9) on <var8:nullable ListNode[nullable Object]> */
1210 var_other = var9;
1211 {
1212 { /* Inline kernel#Object#is_same_instance (var8,var_other) on <var8:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1213 var15 = var8 == var_other;
1214 var13 = var15;
1215 goto RET_LABEL14;
1216 RET_LABEL14:(void)0;
1217 }
1218 }
1219 var11 = var13;
1220 goto RET_LABEL12;
1221 RET_LABEL12:(void)0;
1222 }
1223 var10 = var11;
1224 }
1225 if (var10){
1226 var16 = NULL;
1227 self->attrs[COLOR_standard__list__List___tail].val = var16; /* _tail on <self:List[nullable Object]> */
1228 } else {
1229 var17 = self->attrs[COLOR_standard__list__List___head].val; /* _head on <self:List[nullable Object]> */
1230 var18 = NULL;
1231 if (var17 == NULL) {
1232 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1233 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 181);
1234 show_backtrace(1);
1235 } else {
1236 { /* Inline list#ListNode#prev= (var17,var18) on <var17:nullable ListNode[nullable Object]> */
1237 /* Covariant cast for argument 0 (prev) <var18:null> isa nullable ListNode[E] */
1238 /* <var18:null> isa nullable ListNode[E] */
1239 var20 = 1; /* easy <var18:null> isa nullable ListNode[E]*/
1240 if (unlikely(!var20)) {
1241 var_class_name23 = var18 == NULL ? "null" : var18->type->name;
1242 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[E]", var_class_name23);
1243 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 344);
1244 show_backtrace(1);
1245 }
1246 if (unlikely(var17 == NULL)) {
1247 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1248 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 344);
1249 show_backtrace(1);
1250 }
1251 var17->attrs[COLOR_standard__list__ListNode___prev].val = var18; /* _prev on <var17:nullable ListNode[nullable Object]> */
1252 RET_LABEL19:(void)0;
1253 }
1254 }
1255 }
1256 if (var_node == NULL) {
1257 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1258 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 183);
1259 show_backtrace(1);
1260 } else {
1261 { /* Inline abstract_collection#Container#item (var_node) on <var_node:nullable ListNode[nullable Object]> */
1262 if (unlikely(var_node == NULL)) {
1263 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1264 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 232);
1265 show_backtrace(1);
1266 }
1267 var26 = var_node->attrs[COLOR_standard__abstract_collection__Container___item].val; /* _item on <var_node:nullable ListNode[nullable Object]> */
1268 var24 = var26;
1269 RET_LABEL25:(void)0;
1270 }
1271 }
1272 var = var24;
1273 goto RET_LABEL;
1274 RET_LABEL:;
1275 return var;
1276 }
1277 /* method list#List#remove for (self: List[nullable Object], nullable Object) */
1278 void standard___standard__List___standard__abstract_collection__RemovableCollection__remove(val* self, val* p0) {
1279 short int var /* : Bool */;
1280 int cltype;
1281 int idtype;
1282 const struct type* type_struct;
1283 short int is_nullable;
1284 const char* var_class_name;
1285 val* var_e /* var e: nullable Object */;
1286 val* var1 /* : nullable ListNode[nullable Object] */;
1287 val* var2 /* : nullable ListNode[nullable Object] */;
1288 val* var_node /* var node: nullable ListNode[nullable Object] */;
1289 val* var3 /* : null */;
1290 short int var4 /* : Bool */;
1291 short int var5 /* : Bool */;
1292 val* var_other /* var other: nullable Object */;
1293 short int var7 /* : Bool */;
1294 short int var8 /* : Bool */;
1295 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa E */
1296 /* <p0:nullable Object> isa E */
1297 type_struct = self->type->resolution_table->types[COLOR_standard__List___35dE];
1298 cltype = type_struct->color;
1299 idtype = type_struct->id;
1300 is_nullable = type_struct->is_nullable;
1301 if(p0 == NULL) {
1302 var = is_nullable;
1303 } else {
1304 if(cltype >= p0->type->table_size) {
1305 var = 0;
1306 } else {
1307 var = p0->type->type_table[cltype] == idtype;
1308 }
1309 }
1310 if (unlikely(!var)) {
1311 var_class_name = p0 == NULL ? "null" : p0->type->name;
1312 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
1313 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 186);
1314 show_backtrace(1);
1315 }
1316 var_e = p0;
1317 var1 = self->attrs[COLOR_standard__list__List___head].val; /* _head on <self:List[nullable Object]> */
1318 {
1319 var2 = standard___standard__List___search_node_after(self, var_e, var1);
1320 }
1321 var_node = var2;
1322 var3 = NULL;
1323 if (var_node == NULL) {
1324 var4 = 0; /* is null */
1325 } else {
1326 var4 = 1; /* arg is null and recv is not */
1327 }
1328 if (0) {
1329 { /* Inline kernel#Object#!= (var_node,var3) on <var_node:nullable ListNode[nullable Object]> */
1330 var_other = var3;
1331 {
1332 var7 = ((short int (*)(val* self, val* p0))(var_node->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_node, var_other) /* == on <var_node:nullable ListNode[nullable Object](ListNode[nullable Object])>*/;
1333 }
1334 var8 = !var7;
1335 var5 = var8;
1336 goto RET_LABEL6;
1337 RET_LABEL6:(void)0;
1338 }
1339 var4 = var5;
1340 }
1341 if (var4){
1342 {
1343 standard___standard__List___remove_node(self, var_node); /* Direct call list#List#remove_node on <self:List[nullable Object]>*/
1344 }
1345 } else {
1346 }
1347 RET_LABEL:;
1348 }
1349 /* method list#List#remove_at for (self: List[nullable Object], Int) */
1350 void standard___standard__List___standard__abstract_collection__Sequence__remove_at(val* self, long p0) {
1351 long var_i /* var i: Int */;
1352 val* var /* : nullable ListNode[nullable Object] */;
1353 val* var_node /* var node: nullable ListNode[nullable Object] */;
1354 val* var1 /* : null */;
1355 short int var2 /* : Bool */;
1356 short int var3 /* : Bool */;
1357 val* var_other /* var other: nullable Object */;
1358 short int var5 /* : Bool */;
1359 short int var6 /* : Bool */;
1360 var_i = p0;
1361 {
1362 var = standard___standard__List___get_node(self, var_i);
1363 }
1364 var_node = var;
1365 var1 = NULL;
1366 if (var_node == NULL) {
1367 var2 = 0; /* is null */
1368 } else {
1369 var2 = 1; /* arg is null and recv is not */
1370 }
1371 if (0) {
1372 { /* Inline kernel#Object#!= (var_node,var1) on <var_node:nullable ListNode[nullable Object]> */
1373 var_other = var1;
1374 {
1375 var5 = ((short int (*)(val* self, val* p0))(var_node->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_node, var_other) /* == on <var_node:nullable ListNode[nullable Object](ListNode[nullable Object])>*/;
1376 }
1377 var6 = !var5;
1378 var3 = var6;
1379 goto RET_LABEL4;
1380 RET_LABEL4:(void)0;
1381 }
1382 var2 = var3;
1383 }
1384 if (var2){
1385 {
1386 standard___standard__List___remove_node(self, var_node); /* Direct call list#List#remove_node on <self:List[nullable Object]>*/
1387 }
1388 } else {
1389 }
1390 RET_LABEL:;
1391 }
1392 /* method list#List#clear for (self: List[nullable Object]) */
1393 void standard___standard__List___standard__abstract_collection__RemovableCollection__clear(val* self) {
1394 val* var /* : null */;
1395 val* var1 /* : null */;
1396 var = NULL;
1397 self->attrs[COLOR_standard__list__List___head].val = var; /* _head on <self:List[nullable Object]> */
1398 var1 = NULL;
1399 self->attrs[COLOR_standard__list__List___tail].val = var1; /* _tail on <self:List[nullable Object]> */
1400 RET_LABEL:;
1401 }
1402 /* method list#List#iterator for (self: List[nullable Object]): ListIterator[nullable Object] */
1403 val* standard___standard__List___standard__abstract_collection__Collection__iterator(val* self) {
1404 val* var /* : ListIterator[nullable Object] */;
1405 val* var1 /* : ListIterator[nullable Object] */;
1406 var1 = NEW_standard__ListIterator(self->type->resolution_table->types[COLOR_standard__ListIterator__standard__List___35dE]);
1407 {
1408 ((void (*)(val* self, val* p0))(var1->class->vft[COLOR_standard__list__ListIterator__list_61d]))(var1, self) /* list= on <var1:ListIterator[nullable Object]>*/;
1409 }
1410 {
1411 ((void (*)(val* self))(var1->class->vft[COLOR_standard__kernel__Object__init]))(var1) /* init on <var1:ListIterator[nullable Object]>*/;
1412 }
1413 var = var1;
1414 goto RET_LABEL;
1415 RET_LABEL:;
1416 return var;
1417 }
1418 /* method list#List#init for (self: List[nullable Object]) */
1419 void standard___standard__List___standard__kernel__Object__init(val* self) {
1420 RET_LABEL:;
1421 }
1422 /* method list#List#get_node for (self: List[nullable Object], Int): nullable ListNode[nullable Object] */
1423 val* standard___standard__List___get_node(val* self, long p0) {
1424 val* var /* : nullable ListNode[nullable Object] */;
1425 long var_i /* var i: Int */;
1426 val* var1 /* : nullable ListNode[nullable Object] */;
1427 val* var_n /* var n: nullable ListNode[nullable Object] */;
1428 long var2 /* : Int */;
1429 short int var3 /* : Bool */;
1430 short int var5 /* : Bool */;
1431 int cltype;
1432 int idtype;
1433 const char* var_class_name;
1434 short int var6 /* : Bool */;
1435 val* var7 /* : null */;
1436 short int var8 /* : Bool */;
1437 val* var9 /* : null */;
1438 short int var10 /* : Bool */;
1439 short int var11 /* : Bool */;
1440 val* var_other /* var other: nullable Object */;
1441 short int var13 /* : Bool */;
1442 short int var14 /* : Bool */;
1443 short int var_ /* var : Bool */;
1444 long var15 /* : Int */;
1445 short int var16 /* : Bool */;
1446 short int var18 /* : Bool */;
1447 int cltype19;
1448 int idtype20;
1449 const char* var_class_name21;
1450 short int var22 /* : Bool */;
1451 val* var23 /* : nullable ListNode[nullable Object] */;
1452 val* var25 /* : nullable ListNode[nullable Object] */;
1453 long var26 /* : Int */;
1454 long var27 /* : Int */;
1455 short int var29 /* : Bool */;
1456 int cltype30;
1457 int idtype31;
1458 const char* var_class_name32;
1459 long var33 /* : Int */;
1460 var_i = p0;
1461 var1 = self->attrs[COLOR_standard__list__List___head].val; /* _head on <self:List[nullable Object]> */
1462 var_n = var1;
1463 var2 = 0;
1464 {
1465 { /* Inline kernel#Int#< (var_i,var2) on <var_i:Int> */
1466 /* Covariant cast for argument 0 (i) <var2:Int> isa OTHER */
1467 /* <var2:Int> isa OTHER */
1468 var5 = 1; /* easy <var2:Int> isa OTHER*/
1469 if (unlikely(!var5)) {
1470 var_class_name = type_standard__Int.name;
1471 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
1472 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 410);
1473 show_backtrace(1);
1474 }
1475 var6 = var_i < var2;
1476 var3 = var6;
1477 goto RET_LABEL4;
1478 RET_LABEL4:(void)0;
1479 }
1480 }
1481 if (var3){
1482 var7 = NULL;
1483 var = var7;
1484 goto RET_LABEL;
1485 } else {
1486 }
1487 for(;;) {
1488 var9 = NULL;
1489 if (var_n == NULL) {
1490 var10 = 0; /* is null */
1491 } else {
1492 var10 = 1; /* arg is null and recv is not */
1493 }
1494 if (0) {
1495 { /* Inline kernel#Object#!= (var_n,var9) on <var_n:nullable ListNode[nullable Object]> */
1496 var_other = var9;
1497 {
1498 var13 = ((short int (*)(val* self, val* p0))(var_n->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_n, var_other) /* == on <var_n:nullable ListNode[nullable Object](ListNode[nullable Object])>*/;
1499 }
1500 var14 = !var13;
1501 var11 = var14;
1502 goto RET_LABEL12;
1503 RET_LABEL12:(void)0;
1504 }
1505 var10 = var11;
1506 }
1507 var_ = var10;
1508 if (var10){
1509 var15 = 0;
1510 {
1511 { /* Inline kernel#Int#> (var_i,var15) on <var_i:Int> */
1512 /* Covariant cast for argument 0 (i) <var15:Int> isa OTHER */
1513 /* <var15:Int> isa OTHER */
1514 var18 = 1; /* easy <var15:Int> isa OTHER*/
1515 if (unlikely(!var18)) {
1516 var_class_name21 = type_standard__Int.name;
1517 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name21);
1518 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 412);
1519 show_backtrace(1);
1520 }
1521 var22 = var_i > var15;
1522 var16 = var22;
1523 goto RET_LABEL17;
1524 RET_LABEL17:(void)0;
1525 }
1526 }
1527 var8 = var16;
1528 } else {
1529 var8 = var_;
1530 }
1531 if (var8){
1532 {
1533 { /* Inline list#ListNode#next (var_n) on <var_n:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1534 var25 = var_n->attrs[COLOR_standard__list__ListNode___next].val; /* _next on <var_n:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1535 var23 = var25;
1536 RET_LABEL24:(void)0;
1537 }
1538 }
1539 var_n = var23;
1540 var26 = 1;
1541 {
1542 { /* Inline kernel#Int#- (var_i,var26) on <var_i:Int> */
1543 /* Covariant cast for argument 0 (i) <var26:Int> isa OTHER */
1544 /* <var26:Int> isa OTHER */
1545 var29 = 1; /* easy <var26:Int> isa OTHER*/
1546 if (unlikely(!var29)) {
1547 var_class_name32 = type_standard__Int.name;
1548 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name32);
1549 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 416);
1550 show_backtrace(1);
1551 }
1552 var33 = var_i - var26;
1553 var27 = var33;
1554 goto RET_LABEL28;
1555 RET_LABEL28:(void)0;
1556 }
1557 }
1558 var_i = var27;
1559 } else {
1560 goto BREAK_label;
1561 }
1562 }
1563 BREAK_label: (void)0;
1564 var = var_n;
1565 goto RET_LABEL;
1566 RET_LABEL:;
1567 return var;
1568 }
1569 /* method list#List#search_node_after for (self: List[nullable Object], nullable Object, nullable ListNode[nullable Object]): nullable ListNode[nullable Object] */
1570 val* standard___standard__List___search_node_after(val* self, val* p0, val* p1) {
1571 val* var /* : nullable ListNode[nullable Object] */;
1572 short int var1 /* : Bool */;
1573 int cltype;
1574 int idtype;
1575 const struct type* type_struct;
1576 short int is_nullable;
1577 const char* var_class_name;
1578 short int var2 /* : Bool */;
1579 int cltype3;
1580 int idtype4;
1581 const struct type* type_struct5;
1582 const char* var_class_name6;
1583 val* var_e /* var e: nullable Object */;
1584 val* var_after /* var after: nullable ListNode[nullable Object] */;
1585 val* var_n /* var n: nullable ListNode[nullable Object] */;
1586 short int var7 /* : Bool */;
1587 val* var8 /* : null */;
1588 short int var9 /* : Bool */;
1589 short int var10 /* : Bool */;
1590 val* var_other /* var other: nullable Object */;
1591 short int var12 /* : Bool */;
1592 short int var13 /* : Bool */;
1593 short int var_ /* var : Bool */;
1594 val* var14 /* : nullable Object */;
1595 val* var16 /* : nullable Object */;
1596 short int var17 /* : Bool */;
1597 short int var18 /* : Bool */;
1598 val* var19 /* : nullable ListNode[nullable Object] */;
1599 val* var21 /* : nullable ListNode[nullable Object] */;
1600 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa E */
1601 /* <p0:nullable Object> isa E */
1602 type_struct = self->type->resolution_table->types[COLOR_standard__List___35dE];
1603 cltype = type_struct->color;
1604 idtype = type_struct->id;
1605 is_nullable = type_struct->is_nullable;
1606 if(p0 == NULL) {
1607 var1 = is_nullable;
1608 } else {
1609 if(cltype >= p0->type->table_size) {
1610 var1 = 0;
1611 } else {
1612 var1 = p0->type->type_table[cltype] == idtype;
1613 }
1614 }
1615 if (unlikely(!var1)) {
1616 var_class_name = p0 == NULL ? "null" : p0->type->name;
1617 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "E", var_class_name);
1618 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 234);
1619 show_backtrace(1);
1620 }
1621 /* Covariant cast for argument 1 (after) <p1:nullable ListNode[nullable Object]> isa nullable ListNode[E] */
1622 /* <p1:nullable ListNode[nullable Object]> isa nullable ListNode[E] */
1623 type_struct5 = self->type->resolution_table->types[COLOR_nullable__standard__list__ListNode__standard__List___35dE];
1624 cltype3 = type_struct5->color;
1625 idtype4 = type_struct5->id;
1626 if(p1 == NULL) {
1627 var2 = 1;
1628 } else {
1629 if(cltype3 >= p1->type->table_size) {
1630 var2 = 0;
1631 } else {
1632 var2 = p1->type->type_table[cltype3] == idtype4;
1633 }
1634 }
1635 if (unlikely(!var2)) {
1636 var_class_name6 = p1 == NULL ? "null" : p1->type->name;
1637 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[E]", var_class_name6);
1638 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 234);
1639 show_backtrace(1);
1640 }
1641 var_e = p0;
1642 var_after = p1;
1643 var_n = var_after;
1644 for(;;) {
1645 var8 = NULL;
1646 if (var_n == NULL) {
1647 var9 = 0; /* is null */
1648 } else {
1649 var9 = 1; /* arg is null and recv is not */
1650 }
1651 if (0) {
1652 { /* Inline kernel#Object#!= (var_n,var8) on <var_n:nullable ListNode[nullable Object]> */
1653 var_other = var8;
1654 {
1655 var12 = ((short int (*)(val* self, val* p0))(var_n->class->vft[COLOR_standard__kernel__Object___61d_61d]))(var_n, var_other) /* == on <var_n:nullable ListNode[nullable Object](ListNode[nullable Object])>*/;
1656 }
1657 var13 = !var12;
1658 var10 = var13;
1659 goto RET_LABEL11;
1660 RET_LABEL11:(void)0;
1661 }
1662 var9 = var10;
1663 }
1664 var_ = var9;
1665 if (var9){
1666 {
1667 { /* Inline abstract_collection#Container#item (var_n) on <var_n:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1668 var16 = var_n->attrs[COLOR_standard__abstract_collection__Container___item].val; /* _item on <var_n:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1669 var14 = var16;
1670 RET_LABEL15:(void)0;
1671 }
1672 }
1673 if (var14 == NULL) {
1674 var17 = (var_e != NULL);
1675 } else {
1676 var18 = ((short int (*)(val* self, val* p0))(var14->class->vft[COLOR_standard__kernel__Object___33d_61d]))(var14, var_e) /* != on <var14:nullable Object>*/;
1677 var17 = var18;
1678 }
1679 var7 = var17;
1680 } else {
1681 var7 = var_;
1682 }
1683 if (var7){
1684 {
1685 { /* Inline list#ListNode#next (var_n) on <var_n:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1686 var21 = var_n->attrs[COLOR_standard__list__ListNode___next].val; /* _next on <var_n:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1687 var19 = var21;
1688 RET_LABEL20:(void)0;
1689 }
1690 }
1691 var_n = var19;
1692 } else {
1693 goto BREAK_label;
1694 }
1695 }
1696 BREAK_label: (void)0;
1697 var = var_n;
1698 goto RET_LABEL;
1699 RET_LABEL:;
1700 return var;
1701 }
1702 /* method list#List#remove_node for (self: List[nullable Object], ListNode[nullable Object]) */
1703 void standard___standard__List___remove_node(val* self, val* p0) {
1704 short int var /* : Bool */;
1705 int cltype;
1706 int idtype;
1707 const struct type* type_struct;
1708 const char* var_class_name;
1709 val* var_node /* var node: ListNode[nullable Object] */;
1710 val* var1 /* : nullable ListNode[nullable Object] */;
1711 val* var3 /* : nullable ListNode[nullable Object] */;
1712 val* var4 /* : null */;
1713 short int var5 /* : Bool */;
1714 short int var6 /* : Bool */;
1715 val* var_other /* var other: nullable Object */;
1716 short int var8 /* : Bool */;
1717 short int var10 /* : Bool */;
1718 val* var11 /* : nullable ListNode[nullable Object] */;
1719 val* var13 /* : nullable ListNode[nullable Object] */;
1720 val* var14 /* : nullable ListNode[nullable Object] */;
1721 val* var16 /* : nullable ListNode[nullable Object] */;
1722 val* var17 /* : null */;
1723 short int var18 /* : Bool */;
1724 short int var19 /* : Bool */;
1725 short int var21 /* : Bool */;
1726 short int var23 /* : Bool */;
1727 val* var24 /* : null */;
1728 val* var25 /* : nullable ListNode[nullable Object] */;
1729 val* var27 /* : nullable ListNode[nullable Object] */;
1730 val* var28 /* : null */;
1731 short int var30 /* : Bool */;
1732 int cltype31;
1733 int idtype32;
1734 const char* var_class_name33;
1735 val* var34 /* : nullable ListNode[nullable Object] */;
1736 val* var36 /* : nullable ListNode[nullable Object] */;
1737 val* var37 /* : null */;
1738 short int var38 /* : Bool */;
1739 short int var39 /* : Bool */;
1740 short int var41 /* : Bool */;
1741 short int var43 /* : Bool */;
1742 val* var44 /* : nullable ListNode[nullable Object] */;
1743 val* var46 /* : nullable ListNode[nullable Object] */;
1744 val* var47 /* : nullable ListNode[nullable Object] */;
1745 val* var49 /* : nullable ListNode[nullable Object] */;
1746 val* var50 /* : null */;
1747 short int var52 /* : Bool */;
1748 int cltype53;
1749 int idtype54;
1750 const char* var_class_name55;
1751 val* var56 /* : nullable ListNode[nullable Object] */;
1752 val* var58 /* : nullable ListNode[nullable Object] */;
1753 val* var59 /* : nullable ListNode[nullable Object] */;
1754 val* var61 /* : nullable ListNode[nullable Object] */;
1755 short int var63 /* : Bool */;
1756 int cltype64;
1757 int idtype65;
1758 const struct type* type_struct66;
1759 const char* var_class_name67;
1760 val* var68 /* : nullable ListNode[nullable Object] */;
1761 val* var70 /* : nullable ListNode[nullable Object] */;
1762 val* var71 /* : nullable ListNode[nullable Object] */;
1763 val* var73 /* : nullable ListNode[nullable Object] */;
1764 short int var75 /* : Bool */;
1765 int cltype76;
1766 int idtype77;
1767 const struct type* type_struct78;
1768 const char* var_class_name79;
1769 /* Covariant cast for argument 0 (node) <p0:ListNode[nullable Object]> isa ListNode[E] */
1770 /* <p0:ListNode[nullable Object]> isa ListNode[E] */
1771 type_struct = self->type->resolution_table->types[COLOR_standard__list__ListNode__standard__List___35dE];
1772 cltype = type_struct->color;
1773 idtype = type_struct->id;
1774 if(cltype >= p0->type->table_size) {
1775 var = 0;
1776 } else {
1777 var = p0->type->type_table[cltype] == idtype;
1778 }
1779 if (unlikely(!var)) {
1780 var_class_name = p0 == NULL ? "null" : p0->type->name;
1781 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "ListNode[E]", var_class_name);
1782 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 242);
1783 show_backtrace(1);
1784 }
1785 var_node = p0;
1786 {
1787 { /* Inline list#ListNode#prev (var_node) on <var_node:ListNode[nullable Object]> */
1788 var3 = var_node->attrs[COLOR_standard__list__ListNode___prev].val; /* _prev on <var_node:ListNode[nullable Object]> */
1789 var1 = var3;
1790 RET_LABEL2:(void)0;
1791 }
1792 }
1793 var4 = NULL;
1794 if (var1 == NULL) {
1795 var5 = 1; /* is null */
1796 } else {
1797 var5 = 0; /* arg is null but recv is not */
1798 }
1799 if (0) {
1800 { /* Inline kernel#Object#== (var1,var4) on <var1:nullable ListNode[nullable Object]> */
1801 var_other = var4;
1802 {
1803 { /* Inline kernel#Object#is_same_instance (var1,var_other) on <var1:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1804 var10 = var1 == var_other;
1805 var8 = var10;
1806 goto RET_LABEL9;
1807 RET_LABEL9:(void)0;
1808 }
1809 }
1810 var6 = var8;
1811 goto RET_LABEL7;
1812 RET_LABEL7:(void)0;
1813 }
1814 var5 = var6;
1815 }
1816 if (var5){
1817 {
1818 { /* Inline list#ListNode#next (var_node) on <var_node:ListNode[nullable Object]> */
1819 var13 = var_node->attrs[COLOR_standard__list__ListNode___next].val; /* _next on <var_node:ListNode[nullable Object]> */
1820 var11 = var13;
1821 RET_LABEL12:(void)0;
1822 }
1823 }
1824 self->attrs[COLOR_standard__list__List___head].val = var11; /* _head on <self:List[nullable Object]> */
1825 {
1826 { /* Inline list#ListNode#next (var_node) on <var_node:ListNode[nullable Object]> */
1827 var16 = var_node->attrs[COLOR_standard__list__ListNode___next].val; /* _next on <var_node:ListNode[nullable Object]> */
1828 var14 = var16;
1829 RET_LABEL15:(void)0;
1830 }
1831 }
1832 var17 = NULL;
1833 if (var14 == NULL) {
1834 var18 = 1; /* is null */
1835 } else {
1836 var18 = 0; /* arg is null but recv is not */
1837 }
1838 if (0) {
1839 { /* Inline kernel#Object#== (var14,var17) on <var14:nullable ListNode[nullable Object]> */
1840 var_other = var17;
1841 {
1842 { /* Inline kernel#Object#is_same_instance (var14,var_other) on <var14:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1843 var23 = var14 == var_other;
1844 var21 = var23;
1845 goto RET_LABEL22;
1846 RET_LABEL22:(void)0;
1847 }
1848 }
1849 var19 = var21;
1850 goto RET_LABEL20;
1851 RET_LABEL20:(void)0;
1852 }
1853 var18 = var19;
1854 }
1855 if (var18){
1856 var24 = NULL;
1857 self->attrs[COLOR_standard__list__List___tail].val = var24; /* _tail on <self:List[nullable Object]> */
1858 } else {
1859 {
1860 { /* Inline list#ListNode#next (var_node) on <var_node:ListNode[nullable Object]> */
1861 var27 = var_node->attrs[COLOR_standard__list__ListNode___next].val; /* _next on <var_node:ListNode[nullable Object]> */
1862 var25 = var27;
1863 RET_LABEL26:(void)0;
1864 }
1865 }
1866 var28 = NULL;
1867 if (var25 == NULL) {
1868 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1869 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 250);
1870 show_backtrace(1);
1871 } else {
1872 { /* Inline list#ListNode#prev= (var25,var28) on <var25:nullable ListNode[nullable Object]> */
1873 /* Covariant cast for argument 0 (prev) <var28:null> isa nullable ListNode[E] */
1874 /* <var28:null> isa nullable ListNode[E] */
1875 var30 = 1; /* easy <var28:null> isa nullable ListNode[E]*/
1876 if (unlikely(!var30)) {
1877 var_class_name33 = var28 == NULL ? "null" : var28->type->name;
1878 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[E]", var_class_name33);
1879 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 344);
1880 show_backtrace(1);
1881 }
1882 if (unlikely(var25 == NULL)) {
1883 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1884 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 344);
1885 show_backtrace(1);
1886 }
1887 var25->attrs[COLOR_standard__list__ListNode___prev].val = var28; /* _prev on <var25:nullable ListNode[nullable Object]> */
1888 RET_LABEL29:(void)0;
1889 }
1890 }
1891 }
1892 } else {
1893 {
1894 { /* Inline list#ListNode#next (var_node) on <var_node:ListNode[nullable Object]> */
1895 var36 = var_node->attrs[COLOR_standard__list__ListNode___next].val; /* _next on <var_node:ListNode[nullable Object]> */
1896 var34 = var36;
1897 RET_LABEL35:(void)0;
1898 }
1899 }
1900 var37 = NULL;
1901 if (var34 == NULL) {
1902 var38 = 1; /* is null */
1903 } else {
1904 var38 = 0; /* arg is null but recv is not */
1905 }
1906 if (0) {
1907 { /* Inline kernel#Object#== (var34,var37) on <var34:nullable ListNode[nullable Object]> */
1908 var_other = var37;
1909 {
1910 { /* Inline kernel#Object#is_same_instance (var34,var_other) on <var34:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1911 var43 = var34 == var_other;
1912 var41 = var43;
1913 goto RET_LABEL42;
1914 RET_LABEL42:(void)0;
1915 }
1916 }
1917 var39 = var41;
1918 goto RET_LABEL40;
1919 RET_LABEL40:(void)0;
1920 }
1921 var38 = var39;
1922 }
1923 if (var38){
1924 {
1925 { /* Inline list#ListNode#prev (var_node) on <var_node:ListNode[nullable Object]> */
1926 var46 = var_node->attrs[COLOR_standard__list__ListNode___prev].val; /* _prev on <var_node:ListNode[nullable Object]> */
1927 var44 = var46;
1928 RET_LABEL45:(void)0;
1929 }
1930 }
1931 self->attrs[COLOR_standard__list__List___tail].val = var44; /* _tail on <self:List[nullable Object]> */
1932 {
1933 { /* Inline list#ListNode#prev (var_node) on <var_node:ListNode[nullable Object]> */
1934 var49 = var_node->attrs[COLOR_standard__list__ListNode___prev].val; /* _prev on <var_node:ListNode[nullable Object]> */
1935 var47 = var49;
1936 RET_LABEL48:(void)0;
1937 }
1938 }
1939 var50 = NULL;
1940 if (var47 == NULL) {
1941 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1942 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 254);
1943 show_backtrace(1);
1944 } else {
1945 { /* Inline list#ListNode#next= (var47,var50) on <var47:nullable ListNode[nullable Object]> */
1946 /* Covariant cast for argument 0 (next) <var50:null> isa nullable ListNode[E] */
1947 /* <var50:null> isa nullable ListNode[E] */
1948 var52 = 1; /* easy <var50:null> isa nullable ListNode[E]*/
1949 if (unlikely(!var52)) {
1950 var_class_name55 = var50 == NULL ? "null" : var50->type->name;
1951 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[E]", var_class_name55);
1952 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 341);
1953 show_backtrace(1);
1954 }
1955 if (unlikely(var47 == NULL)) {
1956 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1957 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 341);
1958 show_backtrace(1);
1959 }
1960 var47->attrs[COLOR_standard__list__ListNode___next].val = var50; /* _next on <var47:nullable ListNode[nullable Object]> */
1961 RET_LABEL51:(void)0;
1962 }
1963 }
1964 } else {
1965 {
1966 { /* Inline list#ListNode#prev (var_node) on <var_node:ListNode[nullable Object]> */
1967 var58 = var_node->attrs[COLOR_standard__list__ListNode___prev].val; /* _prev on <var_node:ListNode[nullable Object]> */
1968 var56 = var58;
1969 RET_LABEL57:(void)0;
1970 }
1971 }
1972 {
1973 { /* Inline list#ListNode#next (var_node) on <var_node:ListNode[nullable Object]> */
1974 var61 = var_node->attrs[COLOR_standard__list__ListNode___next].val; /* _next on <var_node:ListNode[nullable Object]> */
1975 var59 = var61;
1976 RET_LABEL60:(void)0;
1977 }
1978 }
1979 if (var56 == NULL) {
1980 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1981 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 256);
1982 show_backtrace(1);
1983 } else {
1984 { /* Inline list#ListNode#next= (var56,var59) on <var56:nullable ListNode[nullable Object]> */
1985 /* Covariant cast for argument 0 (next) <var59:nullable ListNode[nullable Object]> isa nullable ListNode[E] */
1986 /* <var59:nullable ListNode[nullable Object]> isa nullable ListNode[E] */
1987 type_struct66 = var56->type->resolution_table->types[COLOR_nullable__standard__list__ListNode__standard__list__ListNode___35dE];
1988 cltype64 = type_struct66->color;
1989 idtype65 = type_struct66->id;
1990 if(var59 == NULL) {
1991 var63 = 1;
1992 } else {
1993 if(cltype64 >= var59->type->table_size) {
1994 var63 = 0;
1995 } else {
1996 var63 = var59->type->type_table[cltype64] == idtype65;
1997 }
1998 }
1999 if (unlikely(!var63)) {
2000 var_class_name67 = var59 == NULL ? "null" : var59->type->name;
2001 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[E]", var_class_name67);
2002 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 341);
2003 show_backtrace(1);
2004 }
2005 if (unlikely(var56 == NULL)) {
2006 PRINT_ERROR("Runtime error: %s", "Receiver is null");
2007 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 341);
2008 show_backtrace(1);
2009 }
2010 var56->attrs[COLOR_standard__list__ListNode___next].val = var59; /* _next on <var56:nullable ListNode[nullable Object]> */
2011 RET_LABEL62:(void)0;
2012 }
2013 }
2014 {
2015 { /* Inline list#ListNode#next (var_node) on <var_node:ListNode[nullable Object]> */
2016 var70 = var_node->attrs[COLOR_standard__list__ListNode___next].val; /* _next on <var_node:ListNode[nullable Object]> */
2017 var68 = var70;
2018 RET_LABEL69:(void)0;
2019 }
2020 }
2021 {
2022 { /* Inline list#ListNode#prev (var_node) on <var_node:ListNode[nullable Object]> */
2023 var73 = var_node->attrs[COLOR_standard__list__ListNode___prev].val; /* _prev on <var_node:ListNode[nullable Object]> */
2024 var71 = var73;
2025 RET_LABEL72:(void)0;
2026 }
2027 }
2028 if (var68 == NULL) {
2029 PRINT_ERROR("Runtime error: %s", "Receiver is null");
2030 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 257);
2031 show_backtrace(1);
2032 } else {
2033 { /* Inline list#ListNode#prev= (var68,var71) on <var68:nullable ListNode[nullable Object]> */
2034 /* Covariant cast for argument 0 (prev) <var71:nullable ListNode[nullable Object]> isa nullable ListNode[E] */
2035 /* <var71:nullable ListNode[nullable Object]> isa nullable ListNode[E] */
2036 type_struct78 = var68->type->resolution_table->types[COLOR_nullable__standard__list__ListNode__standard__list__ListNode___35dE];
2037 cltype76 = type_struct78->color;
2038 idtype77 = type_struct78->id;
2039 if(var71 == NULL) {
2040 var75 = 1;
2041 } else {
2042 if(cltype76 >= var71->type->table_size) {
2043 var75 = 0;
2044 } else {
2045 var75 = var71->type->type_table[cltype76] == idtype77;
2046 }
2047 }
2048 if (unlikely(!var75)) {
2049 var_class_name79 = var71 == NULL ? "null" : var71->type->name;
2050 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[E]", var_class_name79);
2051 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 344);
2052 show_backtrace(1);
2053 }
2054 if (unlikely(var68 == NULL)) {
2055 PRINT_ERROR("Runtime error: %s", "Receiver is null");
2056 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 344);
2057 show_backtrace(1);
2058 }
2059 var68->attrs[COLOR_standard__list__ListNode___prev].val = var71; /* _prev on <var68:nullable ListNode[nullable Object]> */
2060 RET_LABEL74:(void)0;
2061 }
2062 }
2063 }
2064 }
2065 RET_LABEL:;
2066 }
2067 /* method list#ListIterator#item for (self: ListIterator[nullable Object]): nullable Object */
2068 val* standard___standard__ListIterator___standard__abstract_collection__Iterator__item(val* self) {
2069 val* var /* : nullable Object */;
2070 val* var1 /* : nullable ListNode[nullable Object] */;
2071 val* var2 /* : nullable Object */;
2072 val* var4 /* : nullable Object */;
2073 var1 = self->attrs[COLOR_standard__list__ListIterator___node].val; /* _node on <self:ListIterator[nullable Object]> */
2074 if (var1 == NULL) {
2075 PRINT_ERROR("Runtime error: %s", "Receiver is null");
2076 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 279);
2077 show_backtrace(1);
2078 } else {
2079 { /* Inline abstract_collection#Container#item (var1) on <var1:nullable ListNode[nullable Object]> */
2080 if (unlikely(var1 == NULL)) {
2081 PRINT_ERROR("Runtime error: %s", "Receiver is null");
2082 PRINT_ERROR(" (%s:%d)\n", FILE_standard__abstract_collection, 232);
2083 show_backtrace(1);
2084 }
2085 var4 = var1->attrs[COLOR_standard__abstract_collection__Container___item].val; /* _item on <var1:nullable ListNode[nullable Object]> */
2086 var2 = var4;
2087 RET_LABEL3:(void)0;
2088 }
2089 }
2090 var = var2;
2091 goto RET_LABEL;
2092 RET_LABEL:;
2093 return var;
2094 }
2095 /* method list#ListIterator#is_ok for (self: ListIterator[nullable Object]): Bool */
2096 short int standard___standard__ListIterator___standard__abstract_collection__Iterator__is_ok(val* self) {
2097 short int var /* : Bool */;
2098 val* var1 /* : nullable ListNode[nullable Object] */;
2099 val* var2 /* : null */;
2100 short int var3 /* : Bool */;
2101 short int var4 /* : Bool */;
2102 val* var_other /* var other: nullable Object */;
2103 short int var6 /* : Bool */;
2104 short int var8 /* : Bool */;
2105 short int var9 /* : Bool */;
2106 var1 = self->attrs[COLOR_standard__list__ListIterator___node].val; /* _node on <self:ListIterator[nullable Object]> */
2107 var2 = NULL;
2108 if (var1 == NULL) {
2109 var3 = 1; /* is null */
2110 } else {
2111 var3 = 0; /* arg is null but recv is not */
2112 }
2113 if (0) {
2114 { /* Inline kernel#Object#== (var1,var2) on <var1:nullable ListNode[nullable Object]> */
2115 var_other = var2;
2116 {
2117 { /* Inline kernel#Object#is_same_instance (var1,var_other) on <var1:nullable ListNode[nullable Object](ListNode[nullable Object])> */
2118 var8 = var1 == var_other;
2119 var6 = var8;
2120 goto RET_LABEL7;
2121 RET_LABEL7:(void)0;
2122 }
2123 }
2124 var4 = var6;
2125 goto RET_LABEL5;
2126 RET_LABEL5:(void)0;
2127 }
2128 var3 = var4;
2129 }
2130 var9 = !var3;
2131 var = var9;
2132 goto RET_LABEL;
2133 RET_LABEL:;
2134 return var;
2135 }
2136 /* method list#ListIterator#next for (self: ListIterator[nullable Object]) */
2137 void standard___standard__ListIterator___standard__abstract_collection__Iterator__next(val* self) {
2138 val* var /* : nullable ListNode[nullable Object] */;
2139 val* var1 /* : nullable ListNode[nullable Object] */;
2140 val* var3 /* : nullable ListNode[nullable Object] */;
2141 val* var_ /* var : ListIterator[nullable Object] */;
2142 long var4 /* : Int */;
2143 long var5 /* : Int */;
2144 long var6 /* : Int */;
2145 short int var8 /* : Bool */;
2146 int cltype;
2147 int idtype;
2148 const char* var_class_name;
2149 long var9 /* : Int */;
2150 var = self->attrs[COLOR_standard__list__ListIterator___node].val; /* _node on <self:ListIterator[nullable Object]> */
2151 if (var == NULL) {
2152 PRINT_ERROR("Runtime error: %s", "Receiver is null");
2153 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 288);
2154 show_backtrace(1);
2155 } else {
2156 { /* Inline list#ListNode#next (var) on <var:nullable ListNode[nullable Object]> */
2157 if (unlikely(var == NULL)) {
2158 PRINT_ERROR("Runtime error: %s", "Receiver is null");
2159 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 341);
2160 show_backtrace(1);
2161 }
2162 var3 = var->attrs[COLOR_standard__list__ListNode___next].val; /* _next on <var:nullable ListNode[nullable Object]> */
2163 var1 = var3;
2164 RET_LABEL2:(void)0;
2165 }
2166 }
2167 self->attrs[COLOR_standard__list__ListIterator___node].val = var1; /* _node on <self:ListIterator[nullable Object]> */
2168 var_ = self;
2169 var4 = var_->attrs[COLOR_standard__list__ListIterator___index].l; /* _index on <var_:ListIterator[nullable Object]> */
2170 var5 = 1;
2171 {
2172 { /* Inline kernel#Int#+ (var4,var5) on <var4:Int> */
2173 /* Covariant cast for argument 0 (i) <var5:Int> isa OTHER */
2174 /* <var5:Int> isa OTHER */
2175 var8 = 1; /* easy <var5:Int> isa OTHER*/
2176 if (unlikely(!var8)) {
2177 var_class_name = type_standard__Int.name;
2178 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
2179 PRINT_ERROR(" (%s:%d)\n", FILE_standard__kernel, 413);
2180 show_backtrace(1);
2181 }
2182 var9 = var4 + var5;
2183 var6 = var9;
2184 goto RET_LABEL7;
2185 RET_LABEL7:(void)0;
2186 }
2187 }
2188 var_->attrs[COLOR_standard__list__ListIterator___index].l = var6; /* _index on <var_:ListIterator[nullable Object]> */
2189 RET_LABEL:;
2190 }
2191 /* method list#ListIterator#init for (self: ListIterator[nullable Object]) */
2192 void standard___standard__ListIterator___standard__kernel__Object__init(val* self) {
2193 val* var /* : List[nullable Object] */;
2194 val* var1 /* : nullable ListNode[nullable Object] */;
2195 var = self->attrs[COLOR_standard__list__ListIterator___list].val; /* _list on <self:ListIterator[nullable Object]> */
2196 if (unlikely(var == NULL)) {
2197 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _list");
2198 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 295);
2199 show_backtrace(1);
2200 }
2201 var1 = var->attrs[COLOR_standard__list__List___head].val; /* _head on <var:List[nullable Object]> */
2202 self->attrs[COLOR_standard__list__ListIterator___node].val = var1; /* _node on <self:ListIterator[nullable Object]> */
2203 RET_LABEL:;
2204 }
2205 /* method list#ListIterator#list= for (self: ListIterator[nullable Object], List[nullable Object]) */
2206 void standard___standard__ListIterator___list_61d(val* self, val* p0) {
2207 short int var /* : Bool */;
2208 int cltype;
2209 int idtype;
2210 const struct type* type_struct;
2211 const char* var_class_name;
2212 /* Covariant cast for argument 0 (list) <p0:List[nullable Object]> isa List[E] */
2213 /* <p0:List[nullable Object]> isa List[E] */
2214 type_struct = self->type->resolution_table->types[COLOR_standard__List__standard__ListIterator___35dE];
2215 cltype = type_struct->color;
2216 idtype = type_struct->id;
2217 if(cltype >= p0->type->table_size) {
2218 var = 0;
2219 } else {
2220 var = p0->type->type_table[cltype] == idtype;
2221 }
2222 if (unlikely(!var)) {
2223 var_class_name = p0 == NULL ? "null" : p0->type->name;
2224 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "List[E]", var_class_name);
2225 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 298);
2226 show_backtrace(1);
2227 }
2228 self->attrs[COLOR_standard__list__ListIterator___list].val = p0; /* _list on <self:ListIterator[nullable Object]> */
2229 RET_LABEL:;
2230 }
2231 /* method list#ListIterator#index for (self: ListIterator[nullable Object]): Int */
2232 long standard___standard__ListIterator___standard__abstract_collection__IndexedIterator__index(val* self) {
2233 long var /* : Int */;
2234 long var1 /* : Int */;
2235 var1 = self->attrs[COLOR_standard__list__ListIterator___index].l; /* _index on <self:ListIterator[nullable Object]> */
2236 var = var1;
2237 RET_LABEL:;
2238 return var;
2239 }
2240 /* method list#ListNode#next for (self: ListNode[nullable Object]): nullable ListNode[nullable Object] */
2241 val* standard__list___standard__list__ListNode___next(val* self) {
2242 val* var /* : nullable ListNode[nullable Object] */;
2243 val* var1 /* : nullable ListNode[nullable Object] */;
2244 var1 = self->attrs[COLOR_standard__list__ListNode___next].val; /* _next on <self:ListNode[nullable Object]> */
2245 var = var1;
2246 RET_LABEL:;
2247 return var;
2248 }
2249 /* method list#ListNode#next= for (self: ListNode[nullable Object], nullable ListNode[nullable Object]) */
2250 void standard__list___standard__list__ListNode___next_61d(val* self, val* p0) {
2251 short int var /* : Bool */;
2252 int cltype;
2253 int idtype;
2254 const struct type* type_struct;
2255 const char* var_class_name;
2256 /* Covariant cast for argument 0 (next) <p0:nullable ListNode[nullable Object]> isa nullable ListNode[E] */
2257 /* <p0:nullable ListNode[nullable Object]> isa nullable ListNode[E] */
2258 type_struct = self->type->resolution_table->types[COLOR_nullable__standard__list__ListNode__standard__list__ListNode___35dE];
2259 cltype = type_struct->color;
2260 idtype = type_struct->id;
2261 if(p0 == NULL) {
2262 var = 1;
2263 } else {
2264 if(cltype >= p0->type->table_size) {
2265 var = 0;
2266 } else {
2267 var = p0->type->type_table[cltype] == idtype;
2268 }
2269 }
2270 if (unlikely(!var)) {
2271 var_class_name = p0 == NULL ? "null" : p0->type->name;
2272 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[E]", var_class_name);
2273 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 341);
2274 show_backtrace(1);
2275 }
2276 self->attrs[COLOR_standard__list__ListNode___next].val = p0; /* _next on <self:ListNode[nullable Object]> */
2277 RET_LABEL:;
2278 }
2279 /* method list#ListNode#prev for (self: ListNode[nullable Object]): nullable ListNode[nullable Object] */
2280 val* standard__list___standard__list__ListNode___prev(val* self) {
2281 val* var /* : nullable ListNode[nullable Object] */;
2282 val* var1 /* : nullable ListNode[nullable Object] */;
2283 var1 = self->attrs[COLOR_standard__list__ListNode___prev].val; /* _prev on <self:ListNode[nullable Object]> */
2284 var = var1;
2285 RET_LABEL:;
2286 return var;
2287 }
2288 /* method list#ListNode#prev= for (self: ListNode[nullable Object], nullable ListNode[nullable Object]) */
2289 void standard__list___standard__list__ListNode___prev_61d(val* self, val* p0) {
2290 short int var /* : Bool */;
2291 int cltype;
2292 int idtype;
2293 const struct type* type_struct;
2294 const char* var_class_name;
2295 /* Covariant cast for argument 0 (prev) <p0:nullable ListNode[nullable Object]> isa nullable ListNode[E] */
2296 /* <p0:nullable ListNode[nullable Object]> isa nullable ListNode[E] */
2297 type_struct = self->type->resolution_table->types[COLOR_nullable__standard__list__ListNode__standard__list__ListNode___35dE];
2298 cltype = type_struct->color;
2299 idtype = type_struct->id;
2300 if(p0 == NULL) {
2301 var = 1;
2302 } else {
2303 if(cltype >= p0->type->table_size) {
2304 var = 0;
2305 } else {
2306 var = p0->type->type_table[cltype] == idtype;
2307 }
2308 }
2309 if (unlikely(!var)) {
2310 var_class_name = p0 == NULL ? "null" : p0->type->name;
2311 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[E]", var_class_name);
2312 PRINT_ERROR(" (%s:%d)\n", FILE_standard__list, 344);
2313 show_backtrace(1);
2314 }
2315 self->attrs[COLOR_standard__list__ListNode___prev].val = p0; /* _prev on <self:ListNode[nullable Object]> */
2316 RET_LABEL:;
2317 }