c_src/list.sep.1.c

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