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