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