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