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", 22);
  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", 190);
  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 Sequence#0 */
  61 /* <p1:nullable Object> isa Sequence#0 */
  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`", "Sequence#0", var_class_name);
  78 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 24);
  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", 24);
  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 Container#0 */
  93 /* <var_item:nullable Object> isa Container#0 */
  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`", "Container#0", var_class_name8);
 110 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 190);
 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", 190);
 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", 27);
 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", 190);
 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 Sequence#0 */
 183 /* <p0:nullable Object> isa Sequence#0 */
 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`", "Sequence#0", var_class_name);
 200 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 29);
 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", 30);
 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 Container#0 */
 212 /* <var_e:nullable Object> isa Container#0 */
 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`", "Container#0", var_class_name8);
 229 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 190);
 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", 190);
 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", 33);
 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", 190);
 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) break;
 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", 328);
 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 CONTINUE_label: (void)0;
 410 }
 411 BREAK_label: (void)0;
 412 var = var_l;
 413 goto RET_LABEL;
 414 RET_LABEL:;
 415 return var;
 416 }
 417 /* method list#List#length for (self: Object): Int */
 418 long VIRTUAL_list__List__length(val* self) {
 419 long var /* : Int */;
 420 long var1 /* : Int */;
 421 var1 = list__List__length(self);
 422 var = var1;
 423 RET_LABEL:;
 424 return var;
 425 }
 426 /* method list#List#has for (self: List[nullable Object], nullable Object): Bool */
 427 short int list__List__has(val* self, val* p0) {
 428 short int var /* : Bool */;
 429 short int var1 /* : Bool */;
 430 int cltype;
 431 int idtype;
 432 const struct type* type_struct;
 433 short int is_nullable;
 434 const char* var_class_name;
 435 val* var_e /* var e: nullable Object */;
 436 val* var2 /* : nullable ListNode[nullable Object] */;
 437 val* var3 /* : nullable ListNode[nullable Object] */;
 438 val* var4 /* : null */;
 439 short int var5 /* : Bool */;
 440 short int var6 /* : Bool */;
 441 val* var_other /* var other: nullable Object */;
 442 short int var8 /* : Bool */;
 443 short int var9 /* : Bool */;
 444 short int var10 /* : Bool */;
 445 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa Collection#0 */
 446 /* <p0:nullable Object> isa Collection#0 */
 447 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Collection_FT0];
 448 cltype = type_struct->color;
 449 idtype = type_struct->id;
 450 is_nullable = type_struct->is_nullable;
 451 if(p0 == NULL) {
 452 var1 = is_nullable;
 453 } else {
 454 if(cltype >= p0->type->table_size) {
 455 var1 = 0;
 456 } else {
 457 var1 = p0->type->type_table[cltype] == idtype;
 458 }
 459 }
 460 if (unlikely(!var1)) {
 461 var_class_name = p0 == NULL ? "null" : p0->type->name;
 462 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "Collection#0", var_class_name);
 463 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 55);
 464 show_backtrace(1);
 465 }
 466 var_e = p0;
 467 var2 = self->attrs[COLOR_list__List___head].val; /* _head on <self:List[nullable Object]> */
 468 {
 469 var3 = list__List__search_node_after(self, var_e, var2);
 470 }
 471 var4 = NULL;
 472 if (var3 == NULL) {
 473 var5 = 0; /* is null */
 474 } else {
 475 var5 = 1; /* arg is null and recv is not */
 476 }
 477 if (0) {
 478 { /* Inline kernel#Object#!= (var3,var4) on <var3:nullable ListNode[nullable Object]> */
 479 var_other = var4;
 480 {
 481 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])>*/;
 482 var8 = var9;
 483 }
 484 var10 = !var8;
 485 var6 = var10;
 486 goto RET_LABEL7;
 487 RET_LABEL7:(void)0;
 488 }
 489 var5 = var6;
 490 }
 491 var = var5;
 492 goto RET_LABEL;
 493 RET_LABEL:;
 494 return var;
 495 }
 496 /* method list#List#has for (self: Object, nullable Object): Bool */
 497 short int VIRTUAL_list__List__has(val* self, val* p0) {
 498 short int var /* : Bool */;
 499 short int var1 /* : Bool */;
 500 var1 = list__List__has(self, p0);
 501 var = var1;
 502 RET_LABEL:;
 503 return var;
 504 }
 505 /* method list#List#push for (self: List[nullable Object], nullable Object) */
 506 void list__List__push(val* self, val* p0) {
 507 short int var /* : Bool */;
 508 int cltype;
 509 int idtype;
 510 const struct type* type_struct;
 511 short int is_nullable;
 512 const char* var_class_name;
 513 val* var_e /* var e: nullable Object */;
 514 val* var1 /* : ListNode[nullable Object] */;
 515 val* var_node /* var node: ListNode[nullable Object] */;
 516 val* var2 /* : nullable ListNode[nullable Object] */;
 517 val* var3 /* : null */;
 518 short int var4 /* : Bool */;
 519 short int var5 /* : Bool */;
 520 val* var_other /* var other: nullable Object */;
 521 short int var7 /* : Bool */;
 522 short int var9 /* : Bool */;
 523 val* var10 /* : nullable ListNode[nullable Object] */;
 524 short int var12 /* : Bool */;
 525 int cltype13;
 526 int idtype14;
 527 const struct type* type_struct15;
 528 const char* var_class_name16;
 529 val* var17 /* : nullable ListNode[nullable Object] */;
 530 short int var19 /* : Bool */;
 531 int cltype20;
 532 int idtype21;
 533 const struct type* type_struct22;
 534 const char* var_class_name23;
 535 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa Sequence#0 */
 536 /* <p0:nullable Object> isa Sequence#0 */
 537 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Sequence_FT0];
 538 cltype = type_struct->color;
 539 idtype = type_struct->id;
 540 is_nullable = type_struct->is_nullable;
 541 if(p0 == NULL) {
 542 var = is_nullable;
 543 } else {
 544 if(cltype >= p0->type->table_size) {
 545 var = 0;
 546 } else {
 547 var = p0->type->type_table[cltype] == idtype;
 548 }
 549 }
 550 if (unlikely(!var)) {
 551 var_class_name = p0 == NULL ? "null" : p0->type->name;
 552 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "Sequence#0", var_class_name);
 553 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 93);
 554 show_backtrace(1);
 555 }
 556 var_e = p0;
 557 var1 = NEW_list__ListNode(self->type->resolution_table->types[COLOR_list__ListNodelist__List_FT0]);
 558 {
 559 list__ListNode__init(var1, var_e); /* Direct call list#ListNode#init on <var1:ListNode[nullable Object]>*/
 560 }
 561 var_node = var1;
 562 var2 = self->attrs[COLOR_list__List___tail].val; /* _tail on <self:List[nullable Object]> */
 563 var3 = NULL;
 564 if (var2 == NULL) {
 565 var4 = 1; /* is null */
 566 } else {
 567 var4 = 0; /* arg is null but recv is not */
 568 }
 569 if (0) {
 570 { /* Inline kernel#Object#== (var2,var3) on <var2:nullable ListNode[nullable Object]> */
 571 var_other = var3;
 572 {
 573 { /* Inline kernel#Object#is_same_instance (var2,var_other) on <var2:nullable ListNode[nullable Object](ListNode[nullable Object])> */
 574 var9 = var2 == var_other;
 575 var7 = var9;
 576 goto RET_LABEL8;
 577 RET_LABEL8:(void)0;
 578 }
 579 }
 580 var5 = var7;
 581 goto RET_LABEL6;
 582 RET_LABEL6:(void)0;
 583 }
 584 var4 = var5;
 585 }
 586 if (var4){
 587 self->attrs[COLOR_list__List___head].val = var_node; /* _head on <self:List[nullable Object]> */
 588 } else {
 589 var10 = self->attrs[COLOR_list__List___tail].val; /* _tail on <self:List[nullable Object]> */
 590 if (var10 == NULL) {
 591 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 592 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 100);
 593 show_backtrace(1);
 594 } else {
 595 { /* Inline list#ListNode#next= (var10,var_node) on <var10:nullable ListNode[nullable Object]> */
 596 /* Covariant cast for argument 0 (next) <var_node:ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
 597 /* <var_node:ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
 598 type_struct15 = var10->type->resolution_table->types[COLOR_nullable_list__ListNodelist__ListNode_FT0];
 599 cltype13 = type_struct15->color;
 600 idtype14 = type_struct15->id;
 601 if(cltype13 >= var_node->type->table_size) {
 602 var12 = 0;
 603 } else {
 604 var12 = var_node->type->type_table[cltype13] == idtype14;
 605 }
 606 if (unlikely(!var12)) {
 607 var_class_name16 = var_node == NULL ? "null" : var_node->type->name;
 608 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[ListNode#0]", var_class_name16);
 609 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 346);
 610 show_backtrace(1);
 611 }
 612 if (unlikely(var10 == NULL)) {
 613 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 614 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 346);
 615 show_backtrace(1);
 616 }
 617 var10->attrs[COLOR_list__ListNode___next].val = var_node; /* _next on <var10:nullable ListNode[nullable Object]> */
 618 RET_LABEL11:(void)0;
 619 }
 620 }
 621 var17 = self->attrs[COLOR_list__List___tail].val; /* _tail on <self:List[nullable Object]> */
 622 {
 623 { /* Inline list#ListNode#prev= (var_node,var17) on <var_node:ListNode[nullable Object]> */
 624 /* Covariant cast for argument 0 (prev) <var17:nullable ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
 625 /* <var17:nullable ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
 626 type_struct22 = var_node->type->resolution_table->types[COLOR_nullable_list__ListNodelist__ListNode_FT0];
 627 cltype20 = type_struct22->color;
 628 idtype21 = type_struct22->id;
 629 if(var17 == NULL) {
 630 var19 = 1;
 631 } else {
 632 if(cltype20 >= var17->type->table_size) {
 633 var19 = 0;
 634 } else {
 635 var19 = var17->type->type_table[cltype20] == idtype21;
 636 }
 637 }
 638 if (unlikely(!var19)) {
 639 var_class_name23 = var17 == NULL ? "null" : var17->type->name;
 640 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[ListNode#0]", var_class_name23);
 641 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 349);
 642 show_backtrace(1);
 643 }
 644 var_node->attrs[COLOR_list__ListNode___prev].val = var17; /* _prev on <var_node:ListNode[nullable Object]> */
 645 RET_LABEL18:(void)0;
 646 }
 647 }
 648 }
 649 self->attrs[COLOR_list__List___tail].val = var_node; /* _tail on <self:List[nullable Object]> */
 650 RET_LABEL:;
 651 }
 652 /* method list#List#push for (self: Object, nullable Object) */
 653 void VIRTUAL_list__List__push(val* self, val* p0) {
 654 list__List__push(self, p0); /* Direct call list#List#push on <self:Object(List[nullable Object])>*/
 655 RET_LABEL:;
 656 }
 657 /* method list#List#unshift for (self: List[nullable Object], nullable Object) */
 658 void list__List__unshift(val* self, val* p0) {
 659 short int var /* : Bool */;
 660 int cltype;
 661 int idtype;
 662 const struct type* type_struct;
 663 short int is_nullable;
 664 const char* var_class_name;
 665 val* var_e /* var e: nullable Object */;
 666 val* var1 /* : ListNode[nullable Object] */;
 667 val* var_node /* var node: ListNode[nullable Object] */;
 668 val* var2 /* : nullable ListNode[nullable Object] */;
 669 val* var3 /* : null */;
 670 short int var4 /* : Bool */;
 671 short int var5 /* : Bool */;
 672 val* var_other /* var other: nullable Object */;
 673 short int var7 /* : Bool */;
 674 short int var9 /* : Bool */;
 675 val* var10 /* : nullable ListNode[nullable Object] */;
 676 short int var12 /* : Bool */;
 677 int cltype13;
 678 int idtype14;
 679 const struct type* type_struct15;
 680 const char* var_class_name16;
 681 val* var17 /* : nullable ListNode[nullable Object] */;
 682 short int var19 /* : Bool */;
 683 int cltype20;
 684 int idtype21;
 685 const struct type* type_struct22;
 686 const char* var_class_name23;
 687 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa Sequence#0 */
 688 /* <p0:nullable Object> isa Sequence#0 */
 689 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__Sequence_FT0];
 690 cltype = type_struct->color;
 691 idtype = type_struct->id;
 692 is_nullable = type_struct->is_nullable;
 693 if(p0 == NULL) {
 694 var = is_nullable;
 695 } else {
 696 if(cltype >= p0->type->table_size) {
 697 var = 0;
 698 } else {
 699 var = p0->type->type_table[cltype] == idtype;
 700 }
 701 }
 702 if (unlikely(!var)) {
 703 var_class_name = p0 == NULL ? "null" : p0->type->name;
 704 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "Sequence#0", var_class_name);
 705 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 106);
 706 show_backtrace(1);
 707 }
 708 var_e = p0;
 709 var1 = NEW_list__ListNode(self->type->resolution_table->types[COLOR_list__ListNodelist__List_FT0]);
 710 {
 711 list__ListNode__init(var1, var_e); /* Direct call list#ListNode#init on <var1:ListNode[nullable Object]>*/
 712 }
 713 var_node = var1;
 714 var2 = self->attrs[COLOR_list__List___head].val; /* _head on <self:List[nullable Object]> */
 715 var3 = NULL;
 716 if (var2 == NULL) {
 717 var4 = 1; /* is null */
 718 } else {
 719 var4 = 0; /* arg is null but recv is not */
 720 }
 721 if (0) {
 722 { /* Inline kernel#Object#== (var2,var3) on <var2:nullable ListNode[nullable Object]> */
 723 var_other = var3;
 724 {
 725 { /* Inline kernel#Object#is_same_instance (var2,var_other) on <var2:nullable ListNode[nullable Object](ListNode[nullable Object])> */
 726 var9 = var2 == var_other;
 727 var7 = var9;
 728 goto RET_LABEL8;
 729 RET_LABEL8:(void)0;
 730 }
 731 }
 732 var5 = var7;
 733 goto RET_LABEL6;
 734 RET_LABEL6:(void)0;
 735 }
 736 var4 = var5;
 737 }
 738 if (var4){
 739 self->attrs[COLOR_list__List___tail].val = var_node; /* _tail on <self:List[nullable Object]> */
 740 } else {
 741 var10 = self->attrs[COLOR_list__List___head].val; /* _head on <self:List[nullable Object]> */
 742 {
 743 { /* Inline list#ListNode#next= (var_node,var10) on <var_node:ListNode[nullable Object]> */
 744 /* Covariant cast for argument 0 (next) <var10:nullable ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
 745 /* <var10:nullable ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
 746 type_struct15 = var_node->type->resolution_table->types[COLOR_nullable_list__ListNodelist__ListNode_FT0];
 747 cltype13 = type_struct15->color;
 748 idtype14 = type_struct15->id;
 749 if(var10 == NULL) {
 750 var12 = 1;
 751 } else {
 752 if(cltype13 >= var10->type->table_size) {
 753 var12 = 0;
 754 } else {
 755 var12 = var10->type->type_table[cltype13] == idtype14;
 756 }
 757 }
 758 if (unlikely(!var12)) {
 759 var_class_name16 = var10 == NULL ? "null" : var10->type->name;
 760 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[ListNode#0]", var_class_name16);
 761 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 346);
 762 show_backtrace(1);
 763 }
 764 var_node->attrs[COLOR_list__ListNode___next].val = var10; /* _next on <var_node:ListNode[nullable Object]> */
 765 RET_LABEL11:(void)0;
 766 }
 767 }
 768 var17 = self->attrs[COLOR_list__List___head].val; /* _head on <self:List[nullable Object]> */
 769 if (var17 == NULL) {
 770 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 771 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 114);
 772 show_backtrace(1);
 773 } else {
 774 { /* Inline list#ListNode#prev= (var17,var_node) on <var17:nullable ListNode[nullable Object]> */
 775 /* Covariant cast for argument 0 (prev) <var_node:ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
 776 /* <var_node:ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
 777 type_struct22 = var17->type->resolution_table->types[COLOR_nullable_list__ListNodelist__ListNode_FT0];
 778 cltype20 = type_struct22->color;
 779 idtype21 = type_struct22->id;
 780 if(cltype20 >= var_node->type->table_size) {
 781 var19 = 0;
 782 } else {
 783 var19 = var_node->type->type_table[cltype20] == idtype21;
 784 }
 785 if (unlikely(!var19)) {
 786 var_class_name23 = var_node == NULL ? "null" : var_node->type->name;
 787 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[ListNode#0]", var_class_name23);
 788 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 349);
 789 show_backtrace(1);
 790 }
 791 if (unlikely(var17 == NULL)) {
 792 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 793 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 349);
 794 show_backtrace(1);
 795 }
 796 var17->attrs[COLOR_list__ListNode___prev].val = var_node; /* _prev on <var17:nullable ListNode[nullable Object]> */
 797 RET_LABEL18:(void)0;
 798 }
 799 }
 800 }
 801 self->attrs[COLOR_list__List___head].val = var_node; /* _head on <self:List[nullable Object]> */
 802 RET_LABEL:;
 803 }
 804 /* method list#List#unshift for (self: Object, nullable Object) */
 805 void VIRTUAL_list__List__unshift(val* self, val* p0) {
 806 list__List__unshift(self, p0); /* Direct call list#List#unshift on <self:Object(List[nullable Object])>*/
 807 RET_LABEL:;
 808 }
 809 /* method list#List#pop for (self: List[nullable Object]): nullable Object */
 810 val* list__List__pop(val* self) {
 811 val* var /* : nullable Object */;
 812 val* var1 /* : nullable ListNode[nullable Object] */;
 813 val* var_node /* var node: nullable ListNode[nullable Object] */;
 814 val* var2 /* : nullable ListNode[nullable Object] */;
 815 val* var4 /* : nullable ListNode[nullable Object] */;
 816 val* var5 /* : null */;
 817 short int var7 /* : Bool */;
 818 int cltype;
 819 int idtype;
 820 const char* var_class_name;
 821 val* var8 /* : nullable ListNode[nullable Object] */;
 822 val* var9 /* : null */;
 823 short int var10 /* : Bool */;
 824 short int var11 /* : Bool */;
 825 val* var_other /* var other: nullable Object */;
 826 short int var13 /* : Bool */;
 827 short int var15 /* : Bool */;
 828 val* var16 /* : null */;
 829 val* var17 /* : nullable ListNode[nullable Object] */;
 830 val* var18 /* : null */;
 831 short int var20 /* : Bool */;
 832 int cltype21;
 833 int idtype22;
 834 const char* var_class_name23;
 835 val* var24 /* : nullable Object */;
 836 val* var26 /* : nullable Object */;
 837 var1 = self->attrs[COLOR_list__List___tail].val; /* _tail on <self:List[nullable Object]> */
 838 var_node = var1;
 839 if (var_node == NULL) {
 840 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 841 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 160);
 842 show_backtrace(1);
 843 } else {
 844 { /* Inline list#ListNode#prev (var_node) on <var_node:nullable ListNode[nullable Object]> */
 845 if (unlikely(var_node == NULL)) {
 846 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 847 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 349);
 848 show_backtrace(1);
 849 }
 850 var4 = var_node->attrs[COLOR_list__ListNode___prev].val; /* _prev on <var_node:nullable ListNode[nullable Object]> */
 851 var2 = var4;
 852 RET_LABEL3:(void)0;
 853 }
 854 }
 855 self->attrs[COLOR_list__List___tail].val = var2; /* _tail on <self:List[nullable Object]> */
 856 var5 = NULL;
 857 if (var_node == NULL) {
 858 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 859 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 161);
 860 show_backtrace(1);
 861 } else {
 862 { /* Inline list#ListNode#prev= (var_node,var5) on <var_node:nullable ListNode[nullable Object]> */
 863 /* Covariant cast for argument 0 (prev) <var5:null> isa nullable ListNode[ListNode#0] */
 864 /* <var5:null> isa nullable ListNode[ListNode#0] */
 865 var7 = 1; /* easy <var5:null> isa nullable ListNode[ListNode#0]*/
 866 if (unlikely(!var7)) {
 867 var_class_name = var5 == NULL ? "null" : var5->type->name;
 868 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[ListNode#0]", var_class_name);
 869 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 349);
 870 show_backtrace(1);
 871 }
 872 if (unlikely(var_node == NULL)) {
 873 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 874 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 349);
 875 show_backtrace(1);
 876 }
 877 var_node->attrs[COLOR_list__ListNode___prev].val = var5; /* _prev on <var_node:nullable ListNode[nullable Object]> */
 878 RET_LABEL6:(void)0;
 879 }
 880 }
 881 var8 = self->attrs[COLOR_list__List___tail].val; /* _tail on <self:List[nullable Object]> */
 882 var9 = NULL;
 883 if (var8 == NULL) {
 884 var10 = 1; /* is null */
 885 } else {
 886 var10 = 0; /* arg is null but recv is not */
 887 }
 888 if (0) {
 889 { /* Inline kernel#Object#== (var8,var9) on <var8:nullable ListNode[nullable Object]> */
 890 var_other = var9;
 891 {
 892 { /* Inline kernel#Object#is_same_instance (var8,var_other) on <var8:nullable ListNode[nullable Object](ListNode[nullable Object])> */
 893 var15 = var8 == var_other;
 894 var13 = var15;
 895 goto RET_LABEL14;
 896 RET_LABEL14:(void)0;
 897 }
 898 }
 899 var11 = var13;
 900 goto RET_LABEL12;
 901 RET_LABEL12:(void)0;
 902 }
 903 var10 = var11;
 904 }
 905 if (var10){
 906 var16 = NULL;
 907 self->attrs[COLOR_list__List___head].val = var16; /* _head on <self:List[nullable Object]> */
 908 } else {
 909 var17 = self->attrs[COLOR_list__List___tail].val; /* _tail on <self:List[nullable Object]> */
 910 var18 = NULL;
 911 if (var17 == NULL) {
 912 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 913 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 165);
 914 show_backtrace(1);
 915 } else {
 916 { /* Inline list#ListNode#next= (var17,var18) on <var17:nullable ListNode[nullable Object]> */
 917 /* Covariant cast for argument 0 (next) <var18:null> isa nullable ListNode[ListNode#0] */
 918 /* <var18:null> isa nullable ListNode[ListNode#0] */
 919 var20 = 1; /* easy <var18:null> isa nullable ListNode[ListNode#0]*/
 920 if (unlikely(!var20)) {
 921 var_class_name23 = var18 == NULL ? "null" : var18->type->name;
 922 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[ListNode#0]", var_class_name23);
 923 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 346);
 924 show_backtrace(1);
 925 }
 926 if (unlikely(var17 == NULL)) {
 927 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 928 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 346);
 929 show_backtrace(1);
 930 }
 931 var17->attrs[COLOR_list__ListNode___next].val = var18; /* _next on <var17:nullable ListNode[nullable Object]> */
 932 RET_LABEL19:(void)0;
 933 }
 934 }
 935 }
 936 if (var_node == NULL) {
 937 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 938 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 167);
 939 show_backtrace(1);
 940 } else {
 941 { /* Inline abstract_collection#Container#item (var_node) on <var_node:nullable ListNode[nullable Object]> */
 942 if (unlikely(var_node == NULL)) {
 943 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 944 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 190);
 945 show_backtrace(1);
 946 }
 947 var26 = var_node->attrs[COLOR_abstract_collection__Container___item].val; /* _item on <var_node:nullable ListNode[nullable Object]> */
 948 var24 = var26;
 949 RET_LABEL25:(void)0;
 950 }
 951 }
 952 var = var24;
 953 goto RET_LABEL;
 954 RET_LABEL:;
 955 return var;
 956 }
 957 /* method list#List#pop for (self: Object): nullable Object */
 958 val* VIRTUAL_list__List__pop(val* self) {
 959 val* var /* : nullable Object */;
 960 val* var1 /* : nullable Object */;
 961 var1 = list__List__pop(self);
 962 var = var1;
 963 RET_LABEL:;
 964 return var;
 965 }
 966 /* method list#List#shift for (self: List[nullable Object]): nullable Object */
 967 val* list__List__shift(val* self) {
 968 val* var /* : nullable Object */;
 969 val* var1 /* : nullable ListNode[nullable Object] */;
 970 val* var_node /* var node: nullable ListNode[nullable Object] */;
 971 val* var2 /* : nullable ListNode[nullable Object] */;
 972 val* var4 /* : nullable ListNode[nullable Object] */;
 973 val* var5 /* : null */;
 974 short int var7 /* : Bool */;
 975 int cltype;
 976 int idtype;
 977 const char* var_class_name;
 978 val* var8 /* : nullable ListNode[nullable Object] */;
 979 val* var9 /* : null */;
 980 short int var10 /* : Bool */;
 981 short int var11 /* : Bool */;
 982 val* var_other /* var other: nullable Object */;
 983 short int var13 /* : Bool */;
 984 short int var15 /* : Bool */;
 985 val* var16 /* : null */;
 986 val* var17 /* : nullable ListNode[nullable Object] */;
 987 val* var18 /* : null */;
 988 short int var20 /* : Bool */;
 989 int cltype21;
 990 int idtype22;
 991 const char* var_class_name23;
 992 val* var24 /* : nullable Object */;
 993 val* var26 /* : nullable Object */;
 994 var1 = self->attrs[COLOR_list__List___head].val; /* _head on <self:List[nullable Object]> */
 995 var_node = var1;
 996 if (var_node == NULL) {
 997 PRINT_ERROR("Runtime error: %s", "Receiver is null");
 998 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 174);
 999 show_backtrace(1);
1000 } else {
1001 { /* Inline list#ListNode#next (var_node) on <var_node:nullable ListNode[nullable Object]> */
1002 if (unlikely(var_node == NULL)) {
1003 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1004 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 346);
1005 show_backtrace(1);
1006 }
1007 var4 = var_node->attrs[COLOR_list__ListNode___next].val; /* _next on <var_node:nullable ListNode[nullable Object]> */
1008 var2 = var4;
1009 RET_LABEL3:(void)0;
1010 }
1011 }
1012 self->attrs[COLOR_list__List___head].val = var2; /* _head on <self:List[nullable Object]> */
1013 var5 = NULL;
1014 if (var_node == NULL) {
1015 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1016 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 175);
1017 show_backtrace(1);
1018 } else {
1019 { /* Inline list#ListNode#next= (var_node,var5) on <var_node:nullable ListNode[nullable Object]> */
1020 /* Covariant cast for argument 0 (next) <var5:null> isa nullable ListNode[ListNode#0] */
1021 /* <var5:null> isa nullable ListNode[ListNode#0] */
1022 var7 = 1; /* easy <var5:null> isa nullable ListNode[ListNode#0]*/
1023 if (unlikely(!var7)) {
1024 var_class_name = var5 == NULL ? "null" : var5->type->name;
1025 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[ListNode#0]", var_class_name);
1026 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 346);
1027 show_backtrace(1);
1028 }
1029 if (unlikely(var_node == NULL)) {
1030 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1031 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 346);
1032 show_backtrace(1);
1033 }
1034 var_node->attrs[COLOR_list__ListNode___next].val = var5; /* _next on <var_node:nullable ListNode[nullable Object]> */
1035 RET_LABEL6:(void)0;
1036 }
1037 }
1038 var8 = self->attrs[COLOR_list__List___head].val; /* _head on <self:List[nullable Object]> */
1039 var9 = NULL;
1040 if (var8 == NULL) {
1041 var10 = 1; /* is null */
1042 } else {
1043 var10 = 0; /* arg is null but recv is not */
1044 }
1045 if (0) {
1046 { /* Inline kernel#Object#== (var8,var9) on <var8:nullable ListNode[nullable Object]> */
1047 var_other = var9;
1048 {
1049 { /* Inline kernel#Object#is_same_instance (var8,var_other) on <var8:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1050 var15 = var8 == var_other;
1051 var13 = var15;
1052 goto RET_LABEL14;
1053 RET_LABEL14:(void)0;
1054 }
1055 }
1056 var11 = var13;
1057 goto RET_LABEL12;
1058 RET_LABEL12:(void)0;
1059 }
1060 var10 = var11;
1061 }
1062 if (var10){
1063 var16 = NULL;
1064 self->attrs[COLOR_list__List___tail].val = var16; /* _tail on <self:List[nullable Object]> */
1065 } else {
1066 var17 = self->attrs[COLOR_list__List___head].val; /* _head on <self:List[nullable Object]> */
1067 var18 = NULL;
1068 if (var17 == NULL) {
1069 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1070 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 179);
1071 show_backtrace(1);
1072 } else {
1073 { /* Inline list#ListNode#prev= (var17,var18) on <var17:nullable ListNode[nullable Object]> */
1074 /* Covariant cast for argument 0 (prev) <var18:null> isa nullable ListNode[ListNode#0] */
1075 /* <var18:null> isa nullable ListNode[ListNode#0] */
1076 var20 = 1; /* easy <var18:null> isa nullable ListNode[ListNode#0]*/
1077 if (unlikely(!var20)) {
1078 var_class_name23 = var18 == NULL ? "null" : var18->type->name;
1079 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[ListNode#0]", var_class_name23);
1080 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 349);
1081 show_backtrace(1);
1082 }
1083 if (unlikely(var17 == NULL)) {
1084 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1085 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 349);
1086 show_backtrace(1);
1087 }
1088 var17->attrs[COLOR_list__ListNode___prev].val = var18; /* _prev on <var17:nullable ListNode[nullable Object]> */
1089 RET_LABEL19:(void)0;
1090 }
1091 }
1092 }
1093 if (var_node == NULL) {
1094 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1095 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 181);
1096 show_backtrace(1);
1097 } else {
1098 { /* Inline abstract_collection#Container#item (var_node) on <var_node:nullable ListNode[nullable Object]> */
1099 if (unlikely(var_node == NULL)) {
1100 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1101 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 190);
1102 show_backtrace(1);
1103 }
1104 var26 = var_node->attrs[COLOR_abstract_collection__Container___item].val; /* _item on <var_node:nullable ListNode[nullable Object]> */
1105 var24 = var26;
1106 RET_LABEL25:(void)0;
1107 }
1108 }
1109 var = var24;
1110 goto RET_LABEL;
1111 RET_LABEL:;
1112 return var;
1113 }
1114 /* method list#List#shift for (self: Object): nullable Object */
1115 val* VIRTUAL_list__List__shift(val* self) {
1116 val* var /* : nullable Object */;
1117 val* var1 /* : nullable Object */;
1118 var1 = list__List__shift(self);
1119 var = var1;
1120 RET_LABEL:;
1121 return var;
1122 }
1123 /* method list#List#remove for (self: List[nullable Object], nullable Object) */
1124 void list__List__remove(val* self, val* p0) {
1125 short int var /* : Bool */;
1126 int cltype;
1127 int idtype;
1128 const struct type* type_struct;
1129 short int is_nullable;
1130 const char* var_class_name;
1131 val* var_e /* var e: nullable Object */;
1132 val* var1 /* : nullable ListNode[nullable Object] */;
1133 val* var2 /* : nullable ListNode[nullable Object] */;
1134 val* var_node /* var node: nullable ListNode[nullable Object] */;
1135 val* var3 /* : null */;
1136 short int var4 /* : Bool */;
1137 short int var5 /* : Bool */;
1138 val* var_other /* var other: nullable Object */;
1139 short int var7 /* : Bool */;
1140 short int var8 /* : Bool */;
1141 short int var9 /* : Bool */;
1142 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa RemovableCollection#0 */
1143 /* <p0:nullable Object> isa RemovableCollection#0 */
1144 type_struct = self->type->resolution_table->types[COLOR_abstract_collection__RemovableCollection_FT0];
1145 cltype = type_struct->color;
1146 idtype = type_struct->id;
1147 is_nullable = type_struct->is_nullable;
1148 if(p0 == NULL) {
1149 var = is_nullable;
1150 } else {
1151 if(cltype >= p0->type->table_size) {
1152 var = 0;
1153 } else {
1154 var = p0->type->type_table[cltype] == idtype;
1155 }
1156 }
1157 if (unlikely(!var)) {
1158 var_class_name = p0 == NULL ? "null" : p0->type->name;
1159 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "RemovableCollection#0", var_class_name);
1160 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 184);
1161 show_backtrace(1);
1162 }
1163 var_e = p0;
1164 var1 = self->attrs[COLOR_list__List___head].val; /* _head on <self:List[nullable Object]> */
1165 {
1166 var2 = list__List__search_node_after(self, var_e, var1);
1167 }
1168 var_node = var2;
1169 var3 = NULL;
1170 if (var_node == NULL) {
1171 var4 = 0; /* is null */
1172 } else {
1173 var4 = 1; /* arg is null and recv is not */
1174 }
1175 if (0) {
1176 { /* Inline kernel#Object#!= (var_node,var3) on <var_node:nullable ListNode[nullable Object]> */
1177 var_other = var3;
1178 {
1179 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])>*/;
1180 var7 = var8;
1181 }
1182 var9 = !var7;
1183 var5 = var9;
1184 goto RET_LABEL6;
1185 RET_LABEL6:(void)0;
1186 }
1187 var4 = var5;
1188 }
1189 if (var4){
1190 {
1191 list__List__remove_node(self, var_node); /* Direct call list#List#remove_node on <self:List[nullable Object]>*/
1192 }
1193 } else {
1194 }
1195 RET_LABEL:;
1196 }
1197 /* method list#List#remove for (self: Object, nullable Object) */
1198 void VIRTUAL_list__List__remove(val* self, val* p0) {
1199 list__List__remove(self, p0); /* Direct call list#List#remove on <self:Object(List[nullable Object])>*/
1200 RET_LABEL:;
1201 }
1202 /* method list#List#remove_at for (self: List[nullable Object], Int) */
1203 void list__List__remove_at(val* self, long p0) {
1204 long var_i /* var i: Int */;
1205 val* var /* : nullable ListNode[nullable Object] */;
1206 val* var_node /* var node: nullable ListNode[nullable Object] */;
1207 val* var1 /* : null */;
1208 short int var2 /* : Bool */;
1209 short int var3 /* : Bool */;
1210 val* var_other /* var other: nullable Object */;
1211 short int var5 /* : Bool */;
1212 short int var6 /* : Bool */;
1213 short int var7 /* : Bool */;
1214 var_i = p0;
1215 {
1216 var = list__List__get_node(self, var_i);
1217 }
1218 var_node = var;
1219 var1 = NULL;
1220 if (var_node == NULL) {
1221 var2 = 0; /* is null */
1222 } else {
1223 var2 = 1; /* arg is null and recv is not */
1224 }
1225 if (0) {
1226 { /* Inline kernel#Object#!= (var_node,var1) on <var_node:nullable ListNode[nullable Object]> */
1227 var_other = var1;
1228 {
1229 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])>*/;
1230 var5 = var6;
1231 }
1232 var7 = !var5;
1233 var3 = var7;
1234 goto RET_LABEL4;
1235 RET_LABEL4:(void)0;
1236 }
1237 var2 = var3;
1238 }
1239 if (var2){
1240 {
1241 list__List__remove_node(self, var_node); /* Direct call list#List#remove_node on <self:List[nullable Object]>*/
1242 }
1243 } else {
1244 }
1245 RET_LABEL:;
1246 }
1247 /* method list#List#remove_at for (self: Object, Int) */
1248 void VIRTUAL_list__List__remove_at(val* self, long p0) {
1249 list__List__remove_at(self, p0); /* Direct call list#List#remove_at on <self:Object(List[nullable Object])>*/
1250 RET_LABEL:;
1251 }
1252 /* method list#List#clear for (self: List[nullable Object]) */
1253 void list__List__clear(val* self) {
1254 val* var /* : null */;
1255 val* var1 /* : null */;
1256 var = NULL;
1257 self->attrs[COLOR_list__List___head].val = var; /* _head on <self:List[nullable Object]> */
1258 var1 = NULL;
1259 self->attrs[COLOR_list__List___tail].val = var1; /* _tail on <self:List[nullable Object]> */
1260 RET_LABEL:;
1261 }
1262 /* method list#List#clear for (self: Object) */
1263 void VIRTUAL_list__List__clear(val* self) {
1264 list__List__clear(self); /* Direct call list#List#clear on <self:Object(List[nullable Object])>*/
1265 RET_LABEL:;
1266 }
1267 /* method list#List#iterator for (self: List[nullable Object]): ListIterator[nullable Object] */
1268 val* list__List__iterator(val* self) {
1269 val* var /* : ListIterator[nullable Object] */;
1270 val* var1 /* : ListIterator[nullable Object] */;
1271 var1 = NEW_list__ListIterator(self->type->resolution_table->types[COLOR_list__ListIteratorlist__List_FT0]);
1272 {
1273 list__ListIterator__init(var1, self); /* Direct call list#ListIterator#init on <var1:ListIterator[nullable Object]>*/
1274 }
1275 var = var1;
1276 goto RET_LABEL;
1277 RET_LABEL:;
1278 return var;
1279 }
1280 /* method list#List#iterator for (self: Object): Iterator[nullable Object] */
1281 val* VIRTUAL_list__List__iterator(val* self) {
1282 val* var /* : Iterator[nullable Object] */;
1283 val* var1 /* : ListIterator[nullable Object] */;
1284 var1 = list__List__iterator(self);
1285 var = var1;
1286 RET_LABEL:;
1287 return var;
1288 }
1289 /* method list#List#init for (self: List[nullable Object]) */
1290 void list__List__init(val* self) {
1291 RET_LABEL:;
1292 }
1293 /* method list#List#init for (self: Object) */
1294 void VIRTUAL_list__List__init(val* self) {
1295 { /* Inline list#List#init (self) on <self:Object(List[nullable Object])> */
1296 RET_LABEL1:(void)0;
1297 }
1298 RET_LABEL:;
1299 }
1300 /* method list#List#get_node for (self: List[nullable Object], Int): nullable ListNode[nullable Object] */
1301 val* list__List__get_node(val* self, long p0) {
1302 val* var /* : nullable ListNode[nullable Object] */;
1303 long var_i /* var i: Int */;
1304 val* var1 /* : nullable ListNode[nullable Object] */;
1305 val* var_n /* var n: nullable ListNode[nullable Object] */;
1306 long var2 /* : Int */;
1307 short int var3 /* : Bool */;
1308 short int var5 /* : Bool */;
1309 int cltype;
1310 int idtype;
1311 const char* var_class_name;
1312 short int var6 /* : Bool */;
1313 val* var7 /* : null */;
1314 short int var8 /* : Bool */;
1315 val* var9 /* : null */;
1316 short int var10 /* : Bool */;
1317 short int var11 /* : Bool */;
1318 val* var_other /* var other: nullable Object */;
1319 short int var13 /* : Bool */;
1320 short int var14 /* : Bool */;
1321 short int var15 /* : Bool */;
1322 short int var_ /* var : Bool */;
1323 long var16 /* : Int */;
1324 short int var17 /* : Bool */;
1325 short int var19 /* : Bool */;
1326 int cltype20;
1327 int idtype21;
1328 const char* var_class_name22;
1329 short int var23 /* : Bool */;
1330 val* var24 /* : nullable ListNode[nullable Object] */;
1331 val* var26 /* : nullable ListNode[nullable Object] */;
1332 long var27 /* : Int */;
1333 long var28 /* : Int */;
1334 short int var30 /* : Bool */;
1335 int cltype31;
1336 int idtype32;
1337 const char* var_class_name33;
1338 long var34 /* : Int */;
1339 var_i = p0;
1340 var1 = self->attrs[COLOR_list__List___head].val; /* _head on <self:List[nullable Object]> */
1341 var_n = var1;
1342 var2 = 0;
1343 {
1344 { /* Inline kernel#Int#< (var_i,var2) on <var_i:Int> */
1345 /* Covariant cast for argument 0 (i) <var2:Int> isa OTHER */
1346 /* <var2:Int> isa OTHER */
1347 var5 = 1; /* easy <var2:Int> isa OTHER*/
1348 if (unlikely(!var5)) {
1349 var_class_name = type_kernel__Int.name;
1350 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
1351 PRINT_ERROR(" (%s:%d)\n", "lib/standard/kernel.nit", 325);
1352 show_backtrace(1);
1353 }
1354 var6 = var_i < var2;
1355 var3 = var6;
1356 goto RET_LABEL4;
1357 RET_LABEL4:(void)0;
1358 }
1359 }
1360 if (var3){
1361 var7 = NULL;
1362 var = var7;
1363 goto RET_LABEL;
1364 } else {
1365 }
1366 for(;;) {
1367 var9 = NULL;
1368 if (var_n == NULL) {
1369 var10 = 0; /* is null */
1370 } else {
1371 var10 = 1; /* arg is null and recv is not */
1372 }
1373 if (0) {
1374 { /* Inline kernel#Object#!= (var_n,var9) on <var_n:nullable ListNode[nullable Object]> */
1375 var_other = var9;
1376 {
1377 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])>*/;
1378 var13 = var14;
1379 }
1380 var15 = !var13;
1381 var11 = var15;
1382 goto RET_LABEL12;
1383 RET_LABEL12:(void)0;
1384 }
1385 var10 = var11;
1386 }
1387 var_ = var10;
1388 if (var10){
1389 var16 = 0;
1390 {
1391 { /* Inline kernel#Int#> (var_i,var16) on <var_i:Int> */
1392 /* Covariant cast for argument 0 (i) <var16:Int> isa OTHER */
1393 /* <var16:Int> isa OTHER */
1394 var19 = 1; /* easy <var16:Int> isa OTHER*/
1395 if (unlikely(!var19)) {
1396 var_class_name22 = type_kernel__Int.name;
1397 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name22);
1398 PRINT_ERROR(" (%s:%d)\n", "lib/standard/kernel.nit", 327);
1399 show_backtrace(1);
1400 }
1401 var23 = var_i > var16;
1402 var17 = var23;
1403 goto RET_LABEL18;
1404 RET_LABEL18:(void)0;
1405 }
1406 }
1407 var8 = var17;
1408 } else {
1409 var8 = var_;
1410 }
1411 if (!var8) break;
1412 {
1413 { /* Inline list#ListNode#next (var_n) on <var_n:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1414 var26 = var_n->attrs[COLOR_list__ListNode___next].val; /* _next on <var_n:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1415 var24 = var26;
1416 RET_LABEL25:(void)0;
1417 }
1418 }
1419 var_n = var24;
1420 var27 = 1;
1421 {
1422 { /* Inline kernel#Int#- (var_i,var27) on <var_i:Int> */
1423 /* Covariant cast for argument 0 (i) <var27:Int> isa OTHER */
1424 /* <var27:Int> isa OTHER */
1425 var30 = 1; /* easy <var27:Int> isa OTHER*/
1426 if (unlikely(!var30)) {
1427 var_class_name33 = type_kernel__Int.name;
1428 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name33);
1429 PRINT_ERROR(" (%s:%d)\n", "lib/standard/kernel.nit", 331);
1430 show_backtrace(1);
1431 }
1432 var34 = var_i - var27;
1433 var28 = var34;
1434 goto RET_LABEL29;
1435 RET_LABEL29:(void)0;
1436 }
1437 }
1438 var_i = var28;
1439 CONTINUE_label: (void)0;
1440 }
1441 BREAK_label: (void)0;
1442 var = var_n;
1443 goto RET_LABEL;
1444 RET_LABEL:;
1445 return var;
1446 }
1447 /* method list#List#get_node for (self: Object, Int): nullable ListNode[nullable Object] */
1448 val* VIRTUAL_list__List__get_node(val* self, long p0) {
1449 val* var /* : nullable ListNode[nullable Object] */;
1450 val* var1 /* : nullable ListNode[nullable Object] */;
1451 var1 = list__List__get_node(self, p0);
1452 var = var1;
1453 RET_LABEL:;
1454 return var;
1455 }
1456 /* method list#List#search_node_after for (self: List[nullable Object], nullable Object, nullable ListNode[nullable Object]): nullable ListNode[nullable Object] */
1457 val* list__List__search_node_after(val* self, val* p0, val* p1) {
1458 val* var /* : nullable ListNode[nullable Object] */;
1459 short int var1 /* : Bool */;
1460 int cltype;
1461 int idtype;
1462 const struct type* type_struct;
1463 short int is_nullable;
1464 const char* var_class_name;
1465 short int var2 /* : Bool */;
1466 int cltype3;
1467 int idtype4;
1468 const struct type* type_struct5;
1469 const char* var_class_name6;
1470 val* var_e /* var e: nullable Object */;
1471 val* var_after /* var after: nullable ListNode[nullable Object] */;
1472 val* var_n /* var n: nullable ListNode[nullable Object] */;
1473 short int var7 /* : Bool */;
1474 val* var8 /* : null */;
1475 short int var9 /* : Bool */;
1476 short int var10 /* : Bool */;
1477 val* var_other /* var other: nullable Object */;
1478 short int var12 /* : Bool */;
1479 short int var13 /* : Bool */;
1480 short int var14 /* : Bool */;
1481 short int var_ /* var : Bool */;
1482 val* var15 /* : nullable Object */;
1483 val* var17 /* : nullable Object */;
1484 short int var18 /* : Bool */;
1485 short int var19 /* : Bool */;
1486 val* var20 /* : nullable ListNode[nullable Object] */;
1487 val* var22 /* : nullable ListNode[nullable Object] */;
1488 /* Covariant cast for argument 0 (e) <p0:nullable Object> isa List#0 */
1489 /* <p0:nullable Object> isa List#0 */
1490 type_struct = self->type->resolution_table->types[COLOR_list__List_FT0];
1491 cltype = type_struct->color;
1492 idtype = type_struct->id;
1493 is_nullable = type_struct->is_nullable;
1494 if(p0 == NULL) {
1495 var1 = is_nullable;
1496 } else {
1497 if(cltype >= p0->type->table_size) {
1498 var1 = 0;
1499 } else {
1500 var1 = p0->type->type_table[cltype] == idtype;
1501 }
1502 }
1503 if (unlikely(!var1)) {
1504 var_class_name = p0 == NULL ? "null" : p0->type->name;
1505 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "List#0", var_class_name);
1506 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 232);
1507 show_backtrace(1);
1508 }
1509 /* Covariant cast for argument 1 (after) <p1:nullable ListNode[nullable Object]> isa nullable ListNode[List#0] */
1510 /* <p1:nullable ListNode[nullable Object]> isa nullable ListNode[List#0] */
1511 type_struct5 = self->type->resolution_table->types[COLOR_nullable_list__ListNodelist__List_FT0];
1512 cltype3 = type_struct5->color;
1513 idtype4 = type_struct5->id;
1514 if(p1 == NULL) {
1515 var2 = 1;
1516 } else {
1517 if(cltype3 >= p1->type->table_size) {
1518 var2 = 0;
1519 } else {
1520 var2 = p1->type->type_table[cltype3] == idtype4;
1521 }
1522 }
1523 if (unlikely(!var2)) {
1524 var_class_name6 = p1 == NULL ? "null" : p1->type->name;
1525 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[List#0]", var_class_name6);
1526 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 232);
1527 show_backtrace(1);
1528 }
1529 var_e = p0;
1530 var_after = p1;
1531 var_n = var_after;
1532 for(;;) {
1533 var8 = NULL;
1534 if (var_n == NULL) {
1535 var9 = 0; /* is null */
1536 } else {
1537 var9 = 1; /* arg is null and recv is not */
1538 }
1539 if (0) {
1540 { /* Inline kernel#Object#!= (var_n,var8) on <var_n:nullable ListNode[nullable Object]> */
1541 var_other = var8;
1542 {
1543 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])>*/;
1544 var12 = var13;
1545 }
1546 var14 = !var12;
1547 var10 = var14;
1548 goto RET_LABEL11;
1549 RET_LABEL11:(void)0;
1550 }
1551 var9 = var10;
1552 }
1553 var_ = var9;
1554 if (var9){
1555 {
1556 { /* Inline abstract_collection#Container#item (var_n) on <var_n:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1557 var17 = var_n->attrs[COLOR_abstract_collection__Container___item].val; /* _item on <var_n:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1558 var15 = var17;
1559 RET_LABEL16:(void)0;
1560 }
1561 }
1562 if (var15 == NULL) {
1563 var18 = (var_e != NULL);
1564 } else {
1565 var19 = ((short int (*)(val*, val*))(var15->class->vft[COLOR_kernel__Object___33d_61d]))(var15, var_e) /* != on <var15:nullable Object>*/;
1566 var18 = var19;
1567 }
1568 var7 = var18;
1569 } else {
1570 var7 = var_;
1571 }
1572 if (!var7) break;
1573 {
1574 { /* Inline list#ListNode#next (var_n) on <var_n:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1575 var22 = var_n->attrs[COLOR_list__ListNode___next].val; /* _next on <var_n:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1576 var20 = var22;
1577 RET_LABEL21:(void)0;
1578 }
1579 }
1580 var_n = var20;
1581 CONTINUE_label: (void)0;
1582 }
1583 BREAK_label: (void)0;
1584 var = var_n;
1585 goto RET_LABEL;
1586 RET_LABEL:;
1587 return var;
1588 }
1589 /* method list#List#search_node_after for (self: Object, nullable Object, nullable ListNode[nullable Object]): nullable ListNode[nullable Object] */
1590 val* VIRTUAL_list__List__search_node_after(val* self, val* p0, val* p1) {
1591 val* var /* : nullable ListNode[nullable Object] */;
1592 val* var1 /* : nullable ListNode[nullable Object] */;
1593 var1 = list__List__search_node_after(self, p0, p1);
1594 var = var1;
1595 RET_LABEL:;
1596 return var;
1597 }
1598 /* method list#List#remove_node for (self: List[nullable Object], ListNode[nullable Object]) */
1599 void list__List__remove_node(val* self, val* p0) {
1600 short int var /* : Bool */;
1601 int cltype;
1602 int idtype;
1603 const struct type* type_struct;
1604 const char* var_class_name;
1605 val* var_node /* var node: ListNode[nullable Object] */;
1606 val* var1 /* : nullable ListNode[nullable Object] */;
1607 val* var3 /* : nullable ListNode[nullable Object] */;
1608 val* var4 /* : null */;
1609 short int var5 /* : Bool */;
1610 short int var6 /* : Bool */;
1611 val* var_other /* var other: nullable Object */;
1612 short int var8 /* : Bool */;
1613 short int var10 /* : Bool */;
1614 val* var11 /* : nullable ListNode[nullable Object] */;
1615 val* var13 /* : nullable ListNode[nullable Object] */;
1616 val* var14 /* : nullable ListNode[nullable Object] */;
1617 val* var16 /* : nullable ListNode[nullable Object] */;
1618 val* var17 /* : null */;
1619 short int var18 /* : Bool */;
1620 short int var19 /* : Bool */;
1621 short int var21 /* : Bool */;
1622 short int var23 /* : Bool */;
1623 val* var24 /* : null */;
1624 val* var25 /* : nullable ListNode[nullable Object] */;
1625 val* var27 /* : nullable ListNode[nullable Object] */;
1626 val* var28 /* : null */;
1627 short int var30 /* : Bool */;
1628 int cltype31;
1629 int idtype32;
1630 const char* var_class_name33;
1631 val* var34 /* : nullable ListNode[nullable Object] */;
1632 val* var36 /* : nullable ListNode[nullable Object] */;
1633 val* var37 /* : null */;
1634 short int var38 /* : Bool */;
1635 short int var39 /* : Bool */;
1636 short int var41 /* : Bool */;
1637 short int var43 /* : Bool */;
1638 val* var44 /* : nullable ListNode[nullable Object] */;
1639 val* var46 /* : nullable ListNode[nullable Object] */;
1640 val* var47 /* : nullable ListNode[nullable Object] */;
1641 val* var49 /* : nullable ListNode[nullable Object] */;
1642 val* var50 /* : null */;
1643 short int var52 /* : Bool */;
1644 int cltype53;
1645 int idtype54;
1646 const char* var_class_name55;
1647 val* var56 /* : nullable ListNode[nullable Object] */;
1648 val* var58 /* : nullable ListNode[nullable Object] */;
1649 val* var59 /* : nullable ListNode[nullable Object] */;
1650 val* var61 /* : nullable ListNode[nullable Object] */;
1651 short int var63 /* : Bool */;
1652 int cltype64;
1653 int idtype65;
1654 const struct type* type_struct66;
1655 const char* var_class_name67;
1656 val* var68 /* : nullable ListNode[nullable Object] */;
1657 val* var70 /* : nullable ListNode[nullable Object] */;
1658 val* var71 /* : nullable ListNode[nullable Object] */;
1659 val* var73 /* : nullable ListNode[nullable Object] */;
1660 short int var75 /* : Bool */;
1661 int cltype76;
1662 int idtype77;
1663 const struct type* type_struct78;
1664 const char* var_class_name79;
1665 /* Covariant cast for argument 0 (node) <p0:ListNode[nullable Object]> isa ListNode[List#0] */
1666 /* <p0:ListNode[nullable Object]> isa ListNode[List#0] */
1667 type_struct = self->type->resolution_table->types[COLOR_list__ListNodelist__List_FT0];
1668 cltype = type_struct->color;
1669 idtype = type_struct->id;
1670 if(cltype >= p0->type->table_size) {
1671 var = 0;
1672 } else {
1673 var = p0->type->type_table[cltype] == idtype;
1674 }
1675 if (unlikely(!var)) {
1676 var_class_name = p0 == NULL ? "null" : p0->type->name;
1677 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "ListNode[List#0]", var_class_name);
1678 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 240);
1679 show_backtrace(1);
1680 }
1681 var_node = p0;
1682 {
1683 { /* Inline list#ListNode#prev (var_node) on <var_node:ListNode[nullable Object]> */
1684 var3 = var_node->attrs[COLOR_list__ListNode___prev].val; /* _prev on <var_node:ListNode[nullable Object]> */
1685 var1 = var3;
1686 RET_LABEL2:(void)0;
1687 }
1688 }
1689 var4 = NULL;
1690 if (var1 == NULL) {
1691 var5 = 1; /* is null */
1692 } else {
1693 var5 = 0; /* arg is null but recv is not */
1694 }
1695 if (0) {
1696 { /* Inline kernel#Object#== (var1,var4) on <var1:nullable ListNode[nullable Object]> */
1697 var_other = var4;
1698 {
1699 { /* Inline kernel#Object#is_same_instance (var1,var_other) on <var1:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1700 var10 = var1 == var_other;
1701 var8 = var10;
1702 goto RET_LABEL9;
1703 RET_LABEL9:(void)0;
1704 }
1705 }
1706 var6 = var8;
1707 goto RET_LABEL7;
1708 RET_LABEL7:(void)0;
1709 }
1710 var5 = var6;
1711 }
1712 if (var5){
1713 {
1714 { /* Inline list#ListNode#next (var_node) on <var_node:ListNode[nullable Object]> */
1715 var13 = var_node->attrs[COLOR_list__ListNode___next].val; /* _next on <var_node:ListNode[nullable Object]> */
1716 var11 = var13;
1717 RET_LABEL12:(void)0;
1718 }
1719 }
1720 self->attrs[COLOR_list__List___head].val = var11; /* _head on <self:List[nullable Object]> */
1721 {
1722 { /* Inline list#ListNode#next (var_node) on <var_node:ListNode[nullable Object]> */
1723 var16 = var_node->attrs[COLOR_list__ListNode___next].val; /* _next on <var_node:ListNode[nullable Object]> */
1724 var14 = var16;
1725 RET_LABEL15:(void)0;
1726 }
1727 }
1728 var17 = NULL;
1729 if (var14 == NULL) {
1730 var18 = 1; /* is null */
1731 } else {
1732 var18 = 0; /* arg is null but recv is not */
1733 }
1734 if (0) {
1735 { /* Inline kernel#Object#== (var14,var17) on <var14:nullable ListNode[nullable Object]> */
1736 var_other = var17;
1737 {
1738 { /* Inline kernel#Object#is_same_instance (var14,var_other) on <var14:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1739 var23 = var14 == var_other;
1740 var21 = var23;
1741 goto RET_LABEL22;
1742 RET_LABEL22:(void)0;
1743 }
1744 }
1745 var19 = var21;
1746 goto RET_LABEL20;
1747 RET_LABEL20:(void)0;
1748 }
1749 var18 = var19;
1750 }
1751 if (var18){
1752 var24 = NULL;
1753 self->attrs[COLOR_list__List___tail].val = var24; /* _tail on <self:List[nullable Object]> */
1754 } else {
1755 {
1756 { /* Inline list#ListNode#next (var_node) on <var_node:ListNode[nullable Object]> */
1757 var27 = var_node->attrs[COLOR_list__ListNode___next].val; /* _next on <var_node:ListNode[nullable Object]> */
1758 var25 = var27;
1759 RET_LABEL26:(void)0;
1760 }
1761 }
1762 var28 = NULL;
1763 if (var25 == NULL) {
1764 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1765 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 248);
1766 show_backtrace(1);
1767 } else {
1768 { /* Inline list#ListNode#prev= (var25,var28) on <var25:nullable ListNode[nullable Object]> */
1769 /* Covariant cast for argument 0 (prev) <var28:null> isa nullable ListNode[ListNode#0] */
1770 /* <var28:null> isa nullable ListNode[ListNode#0] */
1771 var30 = 1; /* easy <var28:null> isa nullable ListNode[ListNode#0]*/
1772 if (unlikely(!var30)) {
1773 var_class_name33 = var28 == NULL ? "null" : var28->type->name;
1774 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[ListNode#0]", var_class_name33);
1775 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 349);
1776 show_backtrace(1);
1777 }
1778 if (unlikely(var25 == NULL)) {
1779 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1780 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 349);
1781 show_backtrace(1);
1782 }
1783 var25->attrs[COLOR_list__ListNode___prev].val = var28; /* _prev on <var25:nullable ListNode[nullable Object]> */
1784 RET_LABEL29:(void)0;
1785 }
1786 }
1787 }
1788 } else {
1789 {
1790 { /* Inline list#ListNode#next (var_node) on <var_node:ListNode[nullable Object]> */
1791 var36 = var_node->attrs[COLOR_list__ListNode___next].val; /* _next on <var_node:ListNode[nullable Object]> */
1792 var34 = var36;
1793 RET_LABEL35:(void)0;
1794 }
1795 }
1796 var37 = NULL;
1797 if (var34 == NULL) {
1798 var38 = 1; /* is null */
1799 } else {
1800 var38 = 0; /* arg is null but recv is not */
1801 }
1802 if (0) {
1803 { /* Inline kernel#Object#== (var34,var37) on <var34:nullable ListNode[nullable Object]> */
1804 var_other = var37;
1805 {
1806 { /* Inline kernel#Object#is_same_instance (var34,var_other) on <var34:nullable ListNode[nullable Object](ListNode[nullable Object])> */
1807 var43 = var34 == var_other;
1808 var41 = var43;
1809 goto RET_LABEL42;
1810 RET_LABEL42:(void)0;
1811 }
1812 }
1813 var39 = var41;
1814 goto RET_LABEL40;
1815 RET_LABEL40:(void)0;
1816 }
1817 var38 = var39;
1818 }
1819 if (var38){
1820 {
1821 { /* Inline list#ListNode#prev (var_node) on <var_node:ListNode[nullable Object]> */
1822 var46 = var_node->attrs[COLOR_list__ListNode___prev].val; /* _prev on <var_node:ListNode[nullable Object]> */
1823 var44 = var46;
1824 RET_LABEL45:(void)0;
1825 }
1826 }
1827 self->attrs[COLOR_list__List___tail].val = var44; /* _tail on <self:List[nullable Object]> */
1828 {
1829 { /* Inline list#ListNode#prev (var_node) on <var_node:ListNode[nullable Object]> */
1830 var49 = var_node->attrs[COLOR_list__ListNode___prev].val; /* _prev on <var_node:ListNode[nullable Object]> */
1831 var47 = var49;
1832 RET_LABEL48:(void)0;
1833 }
1834 }
1835 var50 = NULL;
1836 if (var47 == NULL) {
1837 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1838 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 252);
1839 show_backtrace(1);
1840 } else {
1841 { /* Inline list#ListNode#next= (var47,var50) on <var47:nullable ListNode[nullable Object]> */
1842 /* Covariant cast for argument 0 (next) <var50:null> isa nullable ListNode[ListNode#0] */
1843 /* <var50:null> isa nullable ListNode[ListNode#0] */
1844 var52 = 1; /* easy <var50:null> isa nullable ListNode[ListNode#0]*/
1845 if (unlikely(!var52)) {
1846 var_class_name55 = var50 == NULL ? "null" : var50->type->name;
1847 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[ListNode#0]", var_class_name55);
1848 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 346);
1849 show_backtrace(1);
1850 }
1851 if (unlikely(var47 == NULL)) {
1852 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1853 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 346);
1854 show_backtrace(1);
1855 }
1856 var47->attrs[COLOR_list__ListNode___next].val = var50; /* _next on <var47:nullable ListNode[nullable Object]> */
1857 RET_LABEL51:(void)0;
1858 }
1859 }
1860 } else {
1861 {
1862 { /* Inline list#ListNode#prev (var_node) on <var_node:ListNode[nullable Object]> */
1863 var58 = var_node->attrs[COLOR_list__ListNode___prev].val; /* _prev on <var_node:ListNode[nullable Object]> */
1864 var56 = var58;
1865 RET_LABEL57:(void)0;
1866 }
1867 }
1868 {
1869 { /* Inline list#ListNode#next (var_node) on <var_node:ListNode[nullable Object]> */
1870 var61 = var_node->attrs[COLOR_list__ListNode___next].val; /* _next on <var_node:ListNode[nullable Object]> */
1871 var59 = var61;
1872 RET_LABEL60:(void)0;
1873 }
1874 }
1875 if (var56 == NULL) {
1876 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1877 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 254);
1878 show_backtrace(1);
1879 } else {
1880 { /* Inline list#ListNode#next= (var56,var59) on <var56:nullable ListNode[nullable Object]> */
1881 /* Covariant cast for argument 0 (next) <var59:nullable ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
1882 /* <var59:nullable ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
1883 type_struct66 = var56->type->resolution_table->types[COLOR_nullable_list__ListNodelist__ListNode_FT0];
1884 cltype64 = type_struct66->color;
1885 idtype65 = type_struct66->id;
1886 if(var59 == NULL) {
1887 var63 = 1;
1888 } else {
1889 if(cltype64 >= var59->type->table_size) {
1890 var63 = 0;
1891 } else {
1892 var63 = var59->type->type_table[cltype64] == idtype65;
1893 }
1894 }
1895 if (unlikely(!var63)) {
1896 var_class_name67 = var59 == NULL ? "null" : var59->type->name;
1897 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[ListNode#0]", var_class_name67);
1898 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 346);
1899 show_backtrace(1);
1900 }
1901 if (unlikely(var56 == NULL)) {
1902 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1903 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 346);
1904 show_backtrace(1);
1905 }
1906 var56->attrs[COLOR_list__ListNode___next].val = var59; /* _next on <var56:nullable ListNode[nullable Object]> */
1907 RET_LABEL62:(void)0;
1908 }
1909 }
1910 {
1911 { /* Inline list#ListNode#next (var_node) on <var_node:ListNode[nullable Object]> */
1912 var70 = var_node->attrs[COLOR_list__ListNode___next].val; /* _next on <var_node:ListNode[nullable Object]> */
1913 var68 = var70;
1914 RET_LABEL69:(void)0;
1915 }
1916 }
1917 {
1918 { /* Inline list#ListNode#prev (var_node) on <var_node:ListNode[nullable Object]> */
1919 var73 = var_node->attrs[COLOR_list__ListNode___prev].val; /* _prev on <var_node:ListNode[nullable Object]> */
1920 var71 = var73;
1921 RET_LABEL72:(void)0;
1922 }
1923 }
1924 if (var68 == NULL) {
1925 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1926 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 255);
1927 show_backtrace(1);
1928 } else {
1929 { /* Inline list#ListNode#prev= (var68,var71) on <var68:nullable ListNode[nullable Object]> */
1930 /* Covariant cast for argument 0 (prev) <var71:nullable ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
1931 /* <var71:nullable ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
1932 type_struct78 = var68->type->resolution_table->types[COLOR_nullable_list__ListNodelist__ListNode_FT0];
1933 cltype76 = type_struct78->color;
1934 idtype77 = type_struct78->id;
1935 if(var71 == NULL) {
1936 var75 = 1;
1937 } else {
1938 if(cltype76 >= var71->type->table_size) {
1939 var75 = 0;
1940 } else {
1941 var75 = var71->type->type_table[cltype76] == idtype77;
1942 }
1943 }
1944 if (unlikely(!var75)) {
1945 var_class_name79 = var71 == NULL ? "null" : var71->type->name;
1946 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[ListNode#0]", var_class_name79);
1947 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 349);
1948 show_backtrace(1);
1949 }
1950 if (unlikely(var68 == NULL)) {
1951 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1952 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 349);
1953 show_backtrace(1);
1954 }
1955 var68->attrs[COLOR_list__ListNode___prev].val = var71; /* _prev on <var68:nullable ListNode[nullable Object]> */
1956 RET_LABEL74:(void)0;
1957 }
1958 }
1959 }
1960 }
1961 RET_LABEL:;
1962 }
1963 /* method list#List#remove_node for (self: Object, ListNode[nullable Object]) */
1964 void VIRTUAL_list__List__remove_node(val* self, val* p0) {
1965 list__List__remove_node(self, p0); /* Direct call list#List#remove_node on <self:Object(List[nullable Object])>*/
1966 RET_LABEL:;
1967 }
1968 /* method list#ListIterator#item for (self: ListIterator[nullable Object]): nullable Object */
1969 val* list__ListIterator__item(val* self) {
1970 val* var /* : nullable Object */;
1971 val* var1 /* : nullable ListNode[nullable Object] */;
1972 val* var2 /* : nullable Object */;
1973 val* var4 /* : nullable Object */;
1974 var1 = self->attrs[COLOR_list__ListIterator___node].val; /* _node on <self:ListIterator[nullable Object]> */
1975 if (var1 == NULL) {
1976 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1977 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 277);
1978 show_backtrace(1);
1979 } else {
1980 { /* Inline abstract_collection#Container#item (var1) on <var1:nullable ListNode[nullable Object]> */
1981 if (unlikely(var1 == NULL)) {
1982 PRINT_ERROR("Runtime error: %s", "Receiver is null");
1983 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 190);
1984 show_backtrace(1);
1985 }
1986 var4 = var1->attrs[COLOR_abstract_collection__Container___item].val; /* _item on <var1:nullable ListNode[nullable Object]> */
1987 var2 = var4;
1988 RET_LABEL3:(void)0;
1989 }
1990 }
1991 var = var2;
1992 goto RET_LABEL;
1993 RET_LABEL:;
1994 return var;
1995 }
1996 /* method list#ListIterator#item for (self: Object): nullable Object */
1997 val* VIRTUAL_list__ListIterator__item(val* self) {
1998 val* var /* : nullable Object */;
1999 val* var1 /* : nullable Object */;
2000 var1 = list__ListIterator__item(self);
2001 var = var1;
2002 RET_LABEL:;
2003 return var;
2004 }
2005 /* method list#ListIterator#is_ok for (self: ListIterator[nullable Object]): Bool */
2006 short int list__ListIterator__is_ok(val* self) {
2007 short int var /* : Bool */;
2008 val* var1 /* : nullable ListNode[nullable Object] */;
2009 val* var2 /* : null */;
2010 short int var3 /* : Bool */;
2011 short int var4 /* : Bool */;
2012 val* var_other /* var other: nullable Object */;
2013 short int var6 /* : Bool */;
2014 short int var8 /* : Bool */;
2015 short int var9 /* : Bool */;
2016 var1 = self->attrs[COLOR_list__ListIterator___node].val; /* _node on <self:ListIterator[nullable Object]> */
2017 var2 = NULL;
2018 if (var1 == NULL) {
2019 var3 = 1; /* is null */
2020 } else {
2021 var3 = 0; /* arg is null but recv is not */
2022 }
2023 if (0) {
2024 { /* Inline kernel#Object#== (var1,var2) on <var1:nullable ListNode[nullable Object]> */
2025 var_other = var2;
2026 {
2027 { /* Inline kernel#Object#is_same_instance (var1,var_other) on <var1:nullable ListNode[nullable Object](ListNode[nullable Object])> */
2028 var8 = var1 == var_other;
2029 var6 = var8;
2030 goto RET_LABEL7;
2031 RET_LABEL7:(void)0;
2032 }
2033 }
2034 var4 = var6;
2035 goto RET_LABEL5;
2036 RET_LABEL5:(void)0;
2037 }
2038 var3 = var4;
2039 }
2040 var9 = !var3;
2041 var = var9;
2042 goto RET_LABEL;
2043 RET_LABEL:;
2044 return var;
2045 }
2046 /* method list#ListIterator#is_ok for (self: Object): Bool */
2047 short int VIRTUAL_list__ListIterator__is_ok(val* self) {
2048 short int var /* : Bool */;
2049 short int var1 /* : Bool */;
2050 var1 = list__ListIterator__is_ok(self);
2051 var = var1;
2052 RET_LABEL:;
2053 return var;
2054 }
2055 /* method list#ListIterator#next for (self: ListIterator[nullable Object]) */
2056 void list__ListIterator__next(val* self) {
2057 val* var /* : nullable ListNode[nullable Object] */;
2058 val* var1 /* : nullable ListNode[nullable Object] */;
2059 val* var3 /* : nullable ListNode[nullable Object] */;
2060 val* var_ /* var : ListIterator[nullable Object] */;
2061 long var4 /* : Int */;
2062 long var5 /* : Int */;
2063 long var6 /* : Int */;
2064 short int var8 /* : Bool */;
2065 int cltype;
2066 int idtype;
2067 const char* var_class_name;
2068 long var9 /* : Int */;
2069 var = self->attrs[COLOR_list__ListIterator___node].val; /* _node on <self:ListIterator[nullable Object]> */
2070 if (var == NULL) {
2071 PRINT_ERROR("Runtime error: %s", "Receiver is null");
2072 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 285);
2073 show_backtrace(1);
2074 } else {
2075 { /* Inline list#ListNode#next (var) on <var:nullable ListNode[nullable Object]> */
2076 if (unlikely(var == NULL)) {
2077 PRINT_ERROR("Runtime error: %s", "Receiver is null");
2078 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 346);
2079 show_backtrace(1);
2080 }
2081 var3 = var->attrs[COLOR_list__ListNode___next].val; /* _next on <var:nullable ListNode[nullable Object]> */
2082 var1 = var3;
2083 RET_LABEL2:(void)0;
2084 }
2085 }
2086 self->attrs[COLOR_list__ListIterator___node].val = var1; /* _node on <self:ListIterator[nullable Object]> */
2087 var_ = self;
2088 var4 = var_->attrs[COLOR_list__ListIterator___index].l; /* _index on <var_:ListIterator[nullable Object]> */
2089 var5 = 1;
2090 {
2091 { /* Inline kernel#Int#+ (var4,var5) on <var4:Int> */
2092 /* Covariant cast for argument 0 (i) <var5:Int> isa OTHER */
2093 /* <var5:Int> isa OTHER */
2094 var8 = 1; /* easy <var5:Int> isa OTHER*/
2095 if (unlikely(!var8)) {
2096 var_class_name = type_kernel__Int.name;
2097 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
2098 PRINT_ERROR(" (%s:%d)\n", "lib/standard/kernel.nit", 328);
2099 show_backtrace(1);
2100 }
2101 var9 = var4 + var5;
2102 var6 = var9;
2103 goto RET_LABEL7;
2104 RET_LABEL7:(void)0;
2105 }
2106 }
2107 var_->attrs[COLOR_list__ListIterator___index].l = var6; /* _index on <var_:ListIterator[nullable Object]> */
2108 RET_LABEL:;
2109 }
2110 /* method list#ListIterator#next for (self: Object) */
2111 void VIRTUAL_list__ListIterator__next(val* self) {
2112 list__ListIterator__next(self); /* Direct call list#ListIterator#next on <self:Object(ListIterator[nullable Object])>*/
2113 RET_LABEL:;
2114 }
2115 /* method list#ListIterator#init for (self: ListIterator[nullable Object], List[nullable Object]) */
2116 void list__ListIterator__init(val* self, val* p0) {
2117 short int var /* : Bool */;
2118 int cltype;
2119 int idtype;
2120 const struct type* type_struct;
2121 const char* var_class_name;
2122 val* var_list /* var list: List[nullable Object] */;
2123 val* var1 /* : nullable ListNode[nullable Object] */;
2124 long var2 /* : Int */;
2125 /* Covariant cast for argument 0 (list) <p0:List[nullable Object]> isa List[ListIterator#0] */
2126 /* <p0:List[nullable Object]> isa List[ListIterator#0] */
2127 type_struct = self->type->resolution_table->types[COLOR_list__Listlist__ListIterator_FT0];
2128 cltype = type_struct->color;
2129 idtype = type_struct->id;
2130 if(cltype >= p0->type->table_size) {
2131 var = 0;
2132 } else {
2133 var = p0->type->type_table[cltype] == idtype;
2134 }
2135 if (unlikely(!var)) {
2136 var_class_name = p0 == NULL ? "null" : p0->type->name;
2137 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "List[ListIterator#0]", var_class_name);
2138 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 289);
2139 show_backtrace(1);
2140 }
2141 var_list = p0;
2142 self->attrs[COLOR_list__ListIterator___list].val = var_list; /* _list on <self:ListIterator[nullable Object]> */
2143 var1 = var_list->attrs[COLOR_list__List___head].val; /* _head on <var_list:List[nullable Object]> */
2144 self->attrs[COLOR_list__ListIterator___node].val = var1; /* _node on <self:ListIterator[nullable Object]> */
2145 var2 = 0;
2146 self->attrs[COLOR_list__ListIterator___index].l = var2; /* _index on <self:ListIterator[nullable Object]> */
2147 RET_LABEL:;
2148 }
2149 /* method list#ListIterator#init for (self: Object, List[nullable Object]) */
2150 void VIRTUAL_list__ListIterator__init(val* self, val* p0) {
2151 list__ListIterator__init(self, p0); /* Direct call list#ListIterator#init on <self:Object(ListIterator[nullable Object])>*/
2152 RET_LABEL:;
2153 }
2154 /* method list#ListIterator#index for (self: ListIterator[nullable Object]): Int */
2155 long list__ListIterator__index(val* self) {
2156 long var /* : Int */;
2157 long var1 /* : Int */;
2158 var1 = self->attrs[COLOR_list__ListIterator___index].l; /* _index on <self:ListIterator[nullable Object]> */
2159 var = var1;
2160 goto RET_LABEL;
2161 RET_LABEL:;
2162 return var;
2163 }
2164 /* method list#ListIterator#index for (self: Object): Int */
2165 long VIRTUAL_list__ListIterator__index(val* self) {
2166 long var /* : Int */;
2167 long var1 /* : Int */;
2168 var1 = list__ListIterator__index(self);
2169 var = var1;
2170 RET_LABEL:;
2171 return var;
2172 }
2173 /* method list#ListNode#init for (self: ListNode[nullable Object], nullable Object) */
2174 void list__ListNode__init(val* self, val* p0) {
2175 short int var /* : Bool */;
2176 int cltype;
2177 int idtype;
2178 const struct type* type_struct;
2179 short int is_nullable;
2180 const char* var_class_name;
2181 val* var_i /* var i: nullable Object */;
2182 short int var2 /* : Bool */;
2183 int cltype3;
2184 int idtype4;
2185 const struct type* type_struct5;
2186 short int is_nullable6;
2187 const char* var_class_name7;
2188 /* Covariant cast for argument 0 (i) <p0:nullable Object> isa ListNode#0 */
2189 /* <p0:nullable Object> isa ListNode#0 */
2190 type_struct = self->type->resolution_table->types[COLOR_list__ListNode_FT0];
2191 cltype = type_struct->color;
2192 idtype = type_struct->id;
2193 is_nullable = type_struct->is_nullable;
2194 if(p0 == NULL) {
2195 var = is_nullable;
2196 } else {
2197 if(cltype >= p0->type->table_size) {
2198 var = 0;
2199 } else {
2200 var = p0->type->type_table[cltype] == idtype;
2201 }
2202 }
2203 if (unlikely(!var)) {
2204 var_class_name = p0 == NULL ? "null" : p0->type->name;
2205 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "ListNode#0", var_class_name);
2206 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 341);
2207 show_backtrace(1);
2208 }
2209 {
2210 abstract_collection__Container__init(self, p0); /* Direct call abstract_collection#Container#init on <self:ListNode[nullable Object]>*/
2211 }
2212 var_i = p0;
2213 {
2214 { /* Inline abstract_collection#Container#item= (self,var_i) on <self:ListNode[nullable Object]> */
2215 /* Covariant cast for argument 0 (item) <var_i:nullable Object> isa Container#0 */
2216 /* <var_i:nullable Object> isa Container#0 */
2217 type_struct5 = self->type->resolution_table->types[COLOR_abstract_collection__Container_FT0];
2218 cltype3 = type_struct5->color;
2219 idtype4 = type_struct5->id;
2220 is_nullable6 = type_struct5->is_nullable;
2221 if(var_i == NULL) {
2222 var2 = is_nullable6;
2223 } else {
2224 if(cltype3 >= var_i->type->table_size) {
2225 var2 = 0;
2226 } else {
2227 var2 = var_i->type->type_table[cltype3] == idtype4;
2228 }
2229 }
2230 if (unlikely(!var2)) {
2231 var_class_name7 = var_i == NULL ? "null" : var_i->type->name;
2232 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "Container#0", var_class_name7);
2233 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/abstract_collection.nit", 190);
2234 show_backtrace(1);
2235 }
2236 self->attrs[COLOR_abstract_collection__Container___item].val = var_i; /* _item on <self:ListNode[nullable Object]> */
2237 RET_LABEL1:(void)0;
2238 }
2239 }
2240 RET_LABEL:;
2241 }
2242 /* method list#ListNode#init for (self: Object, nullable Object) */
2243 void VIRTUAL_list__ListNode__init(val* self, val* p0) {
2244 list__ListNode__init(self, p0); /* Direct call list#ListNode#init on <self:Object(ListNode[nullable Object])>*/
2245 RET_LABEL:;
2246 }
2247 /* method list#ListNode#next for (self: ListNode[nullable Object]): nullable ListNode[nullable Object] */
2248 val* list__ListNode__next(val* self) {
2249 val* var /* : nullable ListNode[nullable Object] */;
2250 val* var1 /* : nullable ListNode[nullable Object] */;
2251 var1 = self->attrs[COLOR_list__ListNode___next].val; /* _next on <self:ListNode[nullable Object]> */
2252 var = var1;
2253 RET_LABEL:;
2254 return var;
2255 }
2256 /* method list#ListNode#next for (self: Object): nullable ListNode[nullable Object] */
2257 val* VIRTUAL_list__ListNode__next(val* self) {
2258 val* var /* : nullable ListNode[nullable Object] */;
2259 val* var1 /* : nullable ListNode[nullable Object] */;
2260 val* var3 /* : nullable ListNode[nullable Object] */;
2261 { /* Inline list#ListNode#next (self) on <self:Object(ListNode[nullable Object])> */
2262 var3 = self->attrs[COLOR_list__ListNode___next].val; /* _next on <self:Object(ListNode[nullable Object])> */
2263 var1 = var3;
2264 RET_LABEL2:(void)0;
2265 }
2266 var = var1;
2267 RET_LABEL:;
2268 return var;
2269 }
2270 /* method list#ListNode#next= for (self: ListNode[nullable Object], nullable ListNode[nullable Object]) */
2271 void list__ListNode__next_61d(val* self, val* p0) {
2272 short int var /* : Bool */;
2273 int cltype;
2274 int idtype;
2275 const struct type* type_struct;
2276 const char* var_class_name;
2277 /* Covariant cast for argument 0 (next) <p0:nullable ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
2278 /* <p0:nullable ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
2279 type_struct = self->type->resolution_table->types[COLOR_nullable_list__ListNodelist__ListNode_FT0];
2280 cltype = type_struct->color;
2281 idtype = type_struct->id;
2282 if(p0 == NULL) {
2283 var = 1;
2284 } else {
2285 if(cltype >= p0->type->table_size) {
2286 var = 0;
2287 } else {
2288 var = p0->type->type_table[cltype] == idtype;
2289 }
2290 }
2291 if (unlikely(!var)) {
2292 var_class_name = p0 == NULL ? "null" : p0->type->name;
2293 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[ListNode#0]", var_class_name);
2294 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 346);
2295 show_backtrace(1);
2296 }
2297 self->attrs[COLOR_list__ListNode___next].val = p0; /* _next on <self:ListNode[nullable Object]> */
2298 RET_LABEL:;
2299 }
2300 /* method list#ListNode#next= for (self: Object, nullable ListNode[nullable Object]) */
2301 void VIRTUAL_list__ListNode__next_61d(val* self, val* p0) {
2302 short int var /* : Bool */;
2303 int cltype;
2304 int idtype;
2305 const struct type* type_struct;
2306 const char* var_class_name;
2307 { /* Inline list#ListNode#next= (self,p0) on <self:Object(ListNode[nullable Object])> */
2308 /* Covariant cast for argument 0 (next) <p0:nullable ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
2309 /* <p0:nullable ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
2310 type_struct = self->type->resolution_table->types[COLOR_nullable_list__ListNodelist__ListNode_FT0];
2311 cltype = type_struct->color;
2312 idtype = type_struct->id;
2313 if(p0 == NULL) {
2314 var = 1;
2315 } else {
2316 if(cltype >= p0->type->table_size) {
2317 var = 0;
2318 } else {
2319 var = p0->type->type_table[cltype] == idtype;
2320 }
2321 }
2322 if (unlikely(!var)) {
2323 var_class_name = p0 == NULL ? "null" : p0->type->name;
2324 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[ListNode#0]", var_class_name);
2325 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 346);
2326 show_backtrace(1);
2327 }
2328 self->attrs[COLOR_list__ListNode___next].val = p0; /* _next on <self:Object(ListNode[nullable Object])> */
2329 RET_LABEL1:(void)0;
2330 }
2331 RET_LABEL:;
2332 }
2333 /* method list#ListNode#prev for (self: ListNode[nullable Object]): nullable ListNode[nullable Object] */
2334 val* list__ListNode__prev(val* self) {
2335 val* var /* : nullable ListNode[nullable Object] */;
2336 val* var1 /* : nullable ListNode[nullable Object] */;
2337 var1 = self->attrs[COLOR_list__ListNode___prev].val; /* _prev on <self:ListNode[nullable Object]> */
2338 var = var1;
2339 RET_LABEL:;
2340 return var;
2341 }
2342 /* method list#ListNode#prev for (self: Object): nullable ListNode[nullable Object] */
2343 val* VIRTUAL_list__ListNode__prev(val* self) {
2344 val* var /* : nullable ListNode[nullable Object] */;
2345 val* var1 /* : nullable ListNode[nullable Object] */;
2346 val* var3 /* : nullable ListNode[nullable Object] */;
2347 { /* Inline list#ListNode#prev (self) on <self:Object(ListNode[nullable Object])> */
2348 var3 = self->attrs[COLOR_list__ListNode___prev].val; /* _prev on <self:Object(ListNode[nullable Object])> */
2349 var1 = var3;
2350 RET_LABEL2:(void)0;
2351 }
2352 var = var1;
2353 RET_LABEL:;
2354 return var;
2355 }
2356 /* method list#ListNode#prev= for (self: ListNode[nullable Object], nullable ListNode[nullable Object]) */
2357 void list__ListNode__prev_61d(val* self, val* p0) {
2358 short int var /* : Bool */;
2359 int cltype;
2360 int idtype;
2361 const struct type* type_struct;
2362 const char* var_class_name;
2363 /* Covariant cast for argument 0 (prev) <p0:nullable ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
2364 /* <p0:nullable ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
2365 type_struct = self->type->resolution_table->types[COLOR_nullable_list__ListNodelist__ListNode_FT0];
2366 cltype = type_struct->color;
2367 idtype = type_struct->id;
2368 if(p0 == NULL) {
2369 var = 1;
2370 } else {
2371 if(cltype >= p0->type->table_size) {
2372 var = 0;
2373 } else {
2374 var = p0->type->type_table[cltype] == idtype;
2375 }
2376 }
2377 if (unlikely(!var)) {
2378 var_class_name = p0 == NULL ? "null" : p0->type->name;
2379 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[ListNode#0]", var_class_name);
2380 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 349);
2381 show_backtrace(1);
2382 }
2383 self->attrs[COLOR_list__ListNode___prev].val = p0; /* _prev on <self:ListNode[nullable Object]> */
2384 RET_LABEL:;
2385 }
2386 /* method list#ListNode#prev= for (self: Object, nullable ListNode[nullable Object]) */
2387 void VIRTUAL_list__ListNode__prev_61d(val* self, val* p0) {
2388 short int var /* : Bool */;
2389 int cltype;
2390 int idtype;
2391 const struct type* type_struct;
2392 const char* var_class_name;
2393 { /* Inline list#ListNode#prev= (self,p0) on <self:Object(ListNode[nullable Object])> */
2394 /* Covariant cast for argument 0 (prev) <p0:nullable ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
2395 /* <p0:nullable ListNode[nullable Object]> isa nullable ListNode[ListNode#0] */
2396 type_struct = self->type->resolution_table->types[COLOR_nullable_list__ListNodelist__ListNode_FT0];
2397 cltype = type_struct->color;
2398 idtype = type_struct->id;
2399 if(p0 == NULL) {
2400 var = 1;
2401 } else {
2402 if(cltype >= p0->type->table_size) {
2403 var = 0;
2404 } else {
2405 var = p0->type->type_table[cltype] == idtype;
2406 }
2407 }
2408 if (unlikely(!var)) {
2409 var_class_name = p0 == NULL ? "null" : p0->type->name;
2410 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "nullable ListNode[ListNode#0]", var_class_name);
2411 PRINT_ERROR(" (%s:%d)\n", "lib/standard/collection/list.nit", 349);
2412 show_backtrace(1);
2413 }
2414 self->attrs[COLOR_list__ListNode___prev].val = p0; /* _prev on <self:Object(ListNode[nullable Object])> */
2415 RET_LABEL1:(void)0;
2416 }
2417 RET_LABEL:;
2418 }