c_src/nitc__rapid_type_analysis.sep.1.c

   1 #include "nitc__rapid_type_analysis.sep.0.h"
   2 /* method rapid_type_analysis$ModelBuilder$do_rapid_type_analysis for (self: ModelBuilder, MModule): RapidTypeAnalysis */
   3 val* nitc__rapid_type_analysis___ModelBuilder___do_rapid_type_analysis(val* self, val* p0) {
   4 val* var /* : RapidTypeAnalysis */;
   5 val* var_mainmodule /* var mainmodule: MModule */;
   6 val* var1 /* : RapidTypeAnalysis */;
   7 val* var_analysis /* var analysis: RapidTypeAnalysis */;
   8 val* var2 /* : ToolContext */;
   9 val* var4 /* : ToolContext */;
  10 val* var5 /* : OptionBool */;
  11 val* var7 /* : OptionBool */;
  12 val* var8 /* : nullable Object */;
  13 val* var10 /* : nullable Object */;
  14 short int var11 /* : Bool */;
  15 val* var12 /* : ToolContext */;
  16 val* var14 /* : ToolContext */;
  17 val* var15 /* : String */;
  18 val* var17 /* : String */;
  19 val* var18 /* : String */;
  20 val* var20 /* : String */;
  21 val* var21 /* : String */;
  22 val* var_basename /* var basename: String */;
  23 val* var22 /* : OrderedTree[Object] */;
  24 static val* varonce;
  25 val* var23 /* : String */;
  26 char* var24 /* : CString */;
  27 val* var25 /* : String */;
  28 val* var26 /* : nullable Int */;
  29 val* var27 /* : nullable Int */;
  30 val* var28 /* : nullable Bool */;
  31 val* var29 /* : nullable Bool */;
  32 val* var30 /* : Text */;
  33 val* var31 /* : CsvDocument */;
  34 static val* varonce32;
  35 val* var33 /* : String */;
  36 char* var34 /* : CString */;
  37 val* var35 /* : String */;
  38 val* var36 /* : nullable Int */;
  39 val* var37 /* : nullable Int */;
  40 val* var38 /* : nullable Bool */;
  41 val* var39 /* : nullable Bool */;
  42 val* var40 /* : Text */;
  43 var_mainmodule = p0;
  44 var1 = NEW_nitc__RapidTypeAnalysis(&type_nitc__RapidTypeAnalysis);
  45 {
  46 ((void(*)(val* self, val* p0))(var1->class->vft[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis__modelbuilder_61d]))(var1, self); /* modelbuilder= on <var1:RapidTypeAnalysis>*/
  47 }
  48 {
  49 ((void(*)(val* self, val* p0))(var1->class->vft[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis__mainmodule_61d]))(var1, var_mainmodule); /* mainmodule= on <var1:RapidTypeAnalysis>*/
  50 }
  51 {
  52 ((void(*)(val* self))(var1->class->vft[COLOR_core__kernel__Object__init]))(var1); /* init on <var1:RapidTypeAnalysis>*/
  53 }
  54 var_analysis = var1;
  55 {
  56 nitc___nitc__RapidTypeAnalysis___run_analysis(var_analysis); /* Direct call rapid_type_analysis$RapidTypeAnalysis$run_analysis on <var_analysis:RapidTypeAnalysis>*/
  57 }
  58 {
  59 { /* Inline modelbuilder_base$ModelBuilder$toolcontext (self) on <self:ModelBuilder> */
  60 var4 = self->attrs[COLOR_nitc__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on <self:ModelBuilder> */
  61 if (unlikely(var4 == NULL)) {
  62 if(catchStack.cursor >= 0){
  63 longjmp(catchStack.envs[catchStack.cursor], 1);
  64 }
  65 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext");
  66 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__modelbuilder_base, 47);
  67 fatal_exit(1);
  68 }
  69 var2 = var4;
  70 RET_LABEL3:(void)0;
  71 }
  72 }
  73 {
  74 { /* Inline toolcontext$ToolContext$opt_log (var2) on <var2:ToolContext> */
  75 var7 = var2->attrs[COLOR_nitc__toolcontext__ToolContext___opt_log].val; /* _opt_log on <var2:ToolContext> */
  76 if (unlikely(var7 == NULL)) {
  77 if(catchStack.cursor >= 0){
  78 longjmp(catchStack.envs[catchStack.cursor], 1);
  79 }
  80 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _opt_log");
  81 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__toolcontext, 369);
  82 fatal_exit(1);
  83 }
  84 var5 = var7;
  85 RET_LABEL6:(void)0;
  86 }
  87 }
  88 {
  89 { /* Inline opts$Option$value (var5) on <var5:OptionBool> */
  90 var10 = var5->attrs[COLOR_opts__Option___value].val; /* _value on <var5:OptionBool> */
  91 var8 = var10;
  92 RET_LABEL9:(void)0;
  93 }
  94 }
  95 var11 = (short int)((long)(var8)>>2);
  96 if (var11){
  97 {
  98 { /* Inline modelbuilder_base$ModelBuilder$toolcontext (self) on <self:ModelBuilder> */
  99 var14 = self->attrs[COLOR_nitc__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on <self:ModelBuilder> */
 100 if (unlikely(var14 == NULL)) {
 101 if(catchStack.cursor >= 0){
 102 longjmp(catchStack.envs[catchStack.cursor], 1);
 103 }
 104 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext");
 105 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__modelbuilder_base, 47);
 106 fatal_exit(1);
 107 }
 108 var12 = var14;
 109 RET_LABEL13:(void)0;
 110 }
 111 }
 112 {
 113 { /* Inline toolcontext$ToolContext$log_directory (var12) on <var12:ToolContext> */
 114 var17 = var12->attrs[COLOR_nitc__toolcontext__ToolContext___log_directory].val; /* _log_directory on <var12:ToolContext> */
 115 if (unlikely(var17 == NULL)) {
 116 if(catchStack.cursor >= 0){
 117 longjmp(catchStack.envs[catchStack.cursor], 1);
 118 }
 119 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _log_directory");
 120 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__toolcontext, 151);
 121 fatal_exit(1);
 122 }
 123 var15 = var17;
 124 RET_LABEL16:(void)0;
 125 }
 126 }
 127 {
 128 { /* Inline mmodule$MModule$name (var_mainmodule) on <var_mainmodule:MModule> */
 129 var20 = var_mainmodule->attrs[COLOR_nitc__mmodule__MModule___name].val; /* _name on <var_mainmodule:MModule> */
 130 if (unlikely(var20 == NULL)) {
 131 if(catchStack.cursor >= 0){
 132 longjmp(catchStack.envs[catchStack.cursor], 1);
 133 }
 134 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _name");
 135 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__mmodule, 100);
 136 fatal_exit(1);
 137 }
 138 var18 = var20;
 139 RET_LABEL19:(void)0;
 140 }
 141 }
 142 {
 143 var21 = core__file___String____47d(var15, var18);
 144 }
 145 var_basename = var21;
 146 {
 147 var22 = nitc___nitc__RapidTypeAnalysis___live_methods_to_tree(var_analysis);
 148 }
 149 if (likely(varonce!=NULL)) {
 150 var23 = varonce;
 151 } else {
 152 var24 = ".rta_methods.txt";
 153 var26 = (val*)(16l<<2|1);
 154 var27 = (val*)(16l<<2|1);
 155 var28 = (val*)((long)(0)<<2|3);
 156 var29 = (val*)((long)(0)<<2|3);
 157 var25 = core__flat___CString___to_s_unsafe(var24, var26, var27, var28, var29);
 158 var23 = var25;
 159 varonce = var23;
 160 }
 161 {
 162 var30 = ((val*(*)(val* self, val* p0))(var_basename->class->vft[COLOR_core__abstract_text__Text___43d]))(var_basename, var23); /* + on <var_basename:String>*/
 163 }
 164 {
 165 core__file___Writable___write_to_file(var22, var30); /* Direct call file$Writable$write_to_file on <var22:OrderedTree[Object]>*/
 166 }
 167 {
 168 var31 = nitc___nitc__RapidTypeAnalysis___live_types_to_csv(var_analysis);
 169 }
 170 if (likely(varonce32!=NULL)) {
 171 var33 = varonce32;
 172 } else {
 173 var34 = ".rta_types.csv";
 174 var36 = (val*)(14l<<2|1);
 175 var37 = (val*)(14l<<2|1);
 176 var38 = (val*)((long)(0)<<2|3);
 177 var39 = (val*)((long)(0)<<2|3);
 178 var35 = core__flat___CString___to_s_unsafe(var34, var36, var37, var38, var39);
 179 var33 = var35;
 180 varonce32 = var33;
 181 }
 182 {
 183 var40 = ((val*(*)(val* self, val* p0))(var_basename->class->vft[COLOR_core__abstract_text__Text___43d]))(var_basename, var33); /* + on <var_basename:String>*/
 184 }
 185 {
 186 core__file___Writable___write_to_file(var31, var40); /* Direct call file$Writable$write_to_file on <var31:CsvDocument>*/
 187 }
 188 } else {
 189 }
 190 var = var_analysis;
 191 goto RET_LABEL;
 192 RET_LABEL:;
 193 return var;
 194 }
 195 /* method rapid_type_analysis$RapidTypeAnalysis$modelbuilder for (self: RapidTypeAnalysis): ModelBuilder */
 196 val* nitc___nitc__RapidTypeAnalysis___modelbuilder(val* self) {
 197 val* var /* : ModelBuilder */;
 198 val* var1 /* : ModelBuilder */;
 199 var1 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___modelbuilder].val; /* _modelbuilder on <self:RapidTypeAnalysis> */
 200 if (unlikely(var1 == NULL)) {
 201 if(catchStack.cursor >= 0){
 202 longjmp(catchStack.envs[catchStack.cursor], 1);
 203 }
 204 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder");
 205 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 53);
 206 fatal_exit(1);
 207 }
 208 var = var1;
 209 RET_LABEL:;
 210 return var;
 211 }
 212 /* method rapid_type_analysis$RapidTypeAnalysis$modelbuilder= for (self: RapidTypeAnalysis, ModelBuilder) */
 213 void nitc___nitc__RapidTypeAnalysis___modelbuilder_61d(val* self, val* p0) {
 214 self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___modelbuilder].val = p0; /* _modelbuilder on <self:RapidTypeAnalysis> */
 215 RET_LABEL:;
 216 }
 217 /* method rapid_type_analysis$RapidTypeAnalysis$mainmodule for (self: RapidTypeAnalysis): MModule */
 218 val* nitc___nitc__RapidTypeAnalysis___mainmodule(val* self) {
 219 val* var /* : MModule */;
 220 val* var1 /* : MModule */;
 221 var1 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
 222 if (unlikely(var1 == NULL)) {
 223 if(catchStack.cursor >= 0){
 224 longjmp(catchStack.envs[catchStack.cursor], 1);
 225 }
 226 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
 227 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
 228 fatal_exit(1);
 229 }
 230 var = var1;
 231 RET_LABEL:;
 232 return var;
 233 }
 234 /* method rapid_type_analysis$RapidTypeAnalysis$mainmodule= for (self: RapidTypeAnalysis, MModule) */
 235 void nitc___nitc__RapidTypeAnalysis___mainmodule_61d(val* self, val* p0) {
 236 self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val = p0; /* _mainmodule on <self:RapidTypeAnalysis> */
 237 RET_LABEL:;
 238 }
 239 /* method rapid_type_analysis$RapidTypeAnalysis$live_types for (self: RapidTypeAnalysis): HashSet[MClassType] */
 240 val* nitc___nitc__RapidTypeAnalysis___live_types(val* self) {
 241 val* var /* : HashSet[MClassType] */;
 242 val* var1 /* : HashSet[MClassType] */;
 243 var1 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on <self:RapidTypeAnalysis> */
 244 if (unlikely(var1 == NULL)) {
 245 if(catchStack.cursor >= 0){
 246 longjmp(catchStack.envs[catchStack.cursor], 1);
 247 }
 248 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types");
 249 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 60);
 250 fatal_exit(1);
 251 }
 252 var = var1;
 253 RET_LABEL:;
 254 return var;
 255 }
 256 /* method rapid_type_analysis$RapidTypeAnalysis$live_open_types for (self: RapidTypeAnalysis): HashSet[MClassType] */
 257 val* nitc___nitc__RapidTypeAnalysis___live_open_types(val* self) {
 258 val* var /* : HashSet[MClassType] */;
 259 val* var1 /* : HashSet[MClassType] */;
 260 var1 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_open_types].val; /* _live_open_types on <self:RapidTypeAnalysis> */
 261 if (unlikely(var1 == NULL)) {
 262 if(catchStack.cursor >= 0){
 263 longjmp(catchStack.envs[catchStack.cursor], 1);
 264 }
 265 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_types");
 266 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 65);
 267 fatal_exit(1);
 268 }
 269 var = var1;
 270 RET_LABEL:;
 271 return var;
 272 }
 273 /* method rapid_type_analysis$RapidTypeAnalysis$live_classes for (self: RapidTypeAnalysis): HashSet[MClass] */
 274 val* nitc___nitc__RapidTypeAnalysis___live_classes(val* self) {
 275 val* var /* : HashSet[MClass] */;
 276 val* var1 /* : HashSet[MClass] */;
 277 var1 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_classes].val; /* _live_classes on <self:RapidTypeAnalysis> */
 278 if (unlikely(var1 == NULL)) {
 279 if(catchStack.cursor >= 0){
 280 longjmp(catchStack.envs[catchStack.cursor], 1);
 281 }
 282 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_classes");
 283 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 69);
 284 fatal_exit(1);
 285 }
 286 var = var1;
 287 RET_LABEL:;
 288 return var;
 289 }
 290 /* method rapid_type_analysis$RapidTypeAnalysis$live_cast_types for (self: RapidTypeAnalysis): HashSet[MType] */
 291 val* nitc___nitc__RapidTypeAnalysis___live_cast_types(val* self) {
 292 val* var /* : HashSet[MType] */;
 293 val* var1 /* : HashSet[MType] */;
 294 var1 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_cast_types].val; /* _live_cast_types on <self:RapidTypeAnalysis> */
 295 if (unlikely(var1 == NULL)) {
 296 if(catchStack.cursor >= 0){
 297 longjmp(catchStack.envs[catchStack.cursor], 1);
 298 }
 299 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_cast_types");
 300 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 72);
 301 fatal_exit(1);
 302 }
 303 var = var1;
 304 RET_LABEL:;
 305 return var;
 306 }
 307 /* method rapid_type_analysis$RapidTypeAnalysis$live_open_cast_types for (self: RapidTypeAnalysis): HashSet[MType] */
 308 val* nitc___nitc__RapidTypeAnalysis___live_open_cast_types(val* self) {
 309 val* var /* : HashSet[MType] */;
 310 val* var1 /* : HashSet[MType] */;
 311 var1 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_open_cast_types].val; /* _live_open_cast_types on <self:RapidTypeAnalysis> */
 312 if (unlikely(var1 == NULL)) {
 313 if(catchStack.cursor >= 0){
 314 longjmp(catchStack.envs[catchStack.cursor], 1);
 315 }
 316 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_cast_types");
 317 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 75);
 318 fatal_exit(1);
 319 }
 320 var = var1;
 321 RET_LABEL:;
 322 return var;
 323 }
 324 /* method rapid_type_analysis$RapidTypeAnalysis$live_methoddefs for (self: RapidTypeAnalysis): HashSet[MMethodDef] */
 325 val* nitc___nitc__RapidTypeAnalysis___live_methoddefs(val* self) {
 326 val* var /* : HashSet[MMethodDef] */;
 327 val* var1 /* : HashSet[MMethodDef] */;
 328 var1 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_methoddefs].val; /* _live_methoddefs on <self:RapidTypeAnalysis> */
 329 if (unlikely(var1 == NULL)) {
 330 if(catchStack.cursor >= 0){
 331 longjmp(catchStack.envs[catchStack.cursor], 1);
 332 }
 333 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methoddefs");
 334 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 79);
 335 fatal_exit(1);
 336 }
 337 var = var1;
 338 RET_LABEL:;
 339 return var;
 340 }
 341 /* method rapid_type_analysis$RapidTypeAnalysis$live_methods for (self: RapidTypeAnalysis): HashSet[MMethod] */
 342 val* nitc___nitc__RapidTypeAnalysis___live_methods(val* self) {
 343 val* var /* : HashSet[MMethod] */;
 344 val* var1 /* : HashSet[MMethod] */;
 345 var1 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_methods].val; /* _live_methods on <self:RapidTypeAnalysis> */
 346 if (unlikely(var1 == NULL)) {
 347 if(catchStack.cursor >= 0){
 348 longjmp(catchStack.envs[catchStack.cursor], 1);
 349 }
 350 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methods");
 351 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 82);
 352 fatal_exit(1);
 353 }
 354 var = var1;
 355 RET_LABEL:;
 356 return var;
 357 }
 358 /* method rapid_type_analysis$RapidTypeAnalysis$live_mmodules for (self: RapidTypeAnalysis): HashSet[MModule] */
 359 val* nitc___nitc__RapidTypeAnalysis___live_mmodules(val* self) {
 360 val* var /* : HashSet[MModule] */;
 361 val* var1 /* : HashSet[MModule] */;
 362 var1 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_mmodules].val; /* _live_mmodules on <self:RapidTypeAnalysis> */
 363 if (unlikely(var1 == NULL)) {
 364 if(catchStack.cursor >= 0){
 365 longjmp(catchStack.envs[catchStack.cursor], 1);
 366 }
 367 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_mmodules");
 368 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 85);
 369 fatal_exit(1);
 370 }
 371 var = var1;
 372 RET_LABEL:;
 373 return var;
 374 }
 375 /* method rapid_type_analysis$RapidTypeAnalysis$live_callsites for (self: RapidTypeAnalysis): HashSet[CallSite] */
 376 val* nitc___nitc__RapidTypeAnalysis___live_callsites(val* self) {
 377 val* var /* : HashSet[CallSite] */;
 378 val* var1 /* : HashSet[CallSite] */;
 379 var1 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_callsites].val; /* _live_callsites on <self:RapidTypeAnalysis> */
 380 if (unlikely(var1 == NULL)) {
 381 if(catchStack.cursor >= 0){
 382 longjmp(catchStack.envs[catchStack.cursor], 1);
 383 }
 384 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_callsites");
 385 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 89);
 386 fatal_exit(1);
 387 }
 388 var = var1;
 389 RET_LABEL:;
 390 return var;
 391 }
 392 /* method rapid_type_analysis$RapidTypeAnalysis$live_targets_cache for (self: RapidTypeAnalysis): HashMap2[MType, MProperty, Set[MMethodDef]] */
 393 val* nitc___nitc__RapidTypeAnalysis___live_targets_cache(val* self) {
 394 val* var /* : HashMap2[MType, MProperty, Set[MMethodDef]] */;
 395 val* var1 /* : HashMap2[MType, MProperty, Set[MMethodDef]] */;
 396 var1 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_targets_cache].val; /* _live_targets_cache on <self:RapidTypeAnalysis> */
 397 if (unlikely(var1 == NULL)) {
 398 if(catchStack.cursor >= 0){
 399 longjmp(catchStack.envs[catchStack.cursor], 1);
 400 }
 401 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_targets_cache");
 402 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 92);
 403 fatal_exit(1);
 404 }
 405 var = var1;
 406 RET_LABEL:;
 407 return var;
 408 }
 409 /* method rapid_type_analysis$RapidTypeAnalysis$live_targets for (self: RapidTypeAnalysis, CallSite): Set[MMethodDef] */
 410 val* nitc___nitc__RapidTypeAnalysis___live_targets(val* self, val* p0) {
 411 val* var /* : Set[MMethodDef] */;
 412 val* var_callsite /* var callsite: CallSite */;
 413 val* var1 /* : MType */;
 414 val* var3 /* : MType */;
 415 val* var_mtype /* var mtype: MType */;
 416 val* var4 /* : nullable MClassType */;
 417 val* var6 /* : nullable MClassType */;
 418 val* var_anchor /* var anchor: nullable MClassType */;
 419 short int var7 /* : Bool */;
 420 short int var8 /* : Bool */;
 421 val* var_other /* var other: nullable Object */;
 422 short int var10 /* : Bool */;
 423 short int var11 /* : Bool */;
 424 val* var12 /* : MModule */;
 425 val* var14 /* : MModule */;
 426 val* var15 /* : MType */;
 427 val* var16 /* : MType */;
 428 short int var17 /* : Bool */;
 429 int cltype;
 430 int idtype;
 431 val* var18 /* : MClass */;
 432 val* var20 /* : MClass */;
 433 val* var21 /* : MClassDef */;
 434 val* var23 /* : MClassDef */;
 435 val* var24 /* : MClassType */;
 436 val* var26 /* : MClassType */;
 437 val* var27 /* : MMethod */;
 438 val* var29 /* : MMethod */;
 439 val* var_mproperty /* var mproperty: MMethod */;
 440 val* var30 /* : HashMap2[MType, MProperty, Set[MMethodDef]] */;
 441 val* var32 /* : HashMap2[MType, MProperty, Set[MMethodDef]] */;
 442 val* var33 /* : nullable Object */;
 443 val* var_res /* var res: nullable Set[MMethodDef] */;
 444 short int var34 /* : Bool */;
 445 short int var35 /* : Bool */;
 446 short int var37 /* : Bool */;
 447 short int var38 /* : Bool */;
 448 val* var39 /* : ArraySet[MMethodDef] */;
 449 val* var40 /* : HashMap2[MType, MProperty, Set[MMethodDef]] */;
 450 val* var42 /* : HashMap2[MType, MProperty, Set[MMethodDef]] */;
 451 val* var43 /* : HashSet[MClass] */;
 452 val* var45 /* : HashSet[MClass] */;
 453 val* var_ /* var : HashSet[MClass] */;
 454 val* var46 /* : Iterator[nullable Object] */;
 455 val* var_47 /* var : Iterator[MClass] */;
 456 short int var48 /* : Bool */;
 457 val* var49 /* : nullable Object */;
 458 val* var_c /* var c: MClass */;
 459 val* var50 /* : MClassDef */;
 460 val* var52 /* : MClassDef */;
 461 val* var53 /* : MClassType */;
 462 val* var55 /* : MClassType */;
 463 val* var_tc /* var tc: MClassType */;
 464 val* var56 /* : MModule */;
 465 val* var58 /* : MModule */;
 466 short int var59 /* : Bool */;
 467 short int var60 /* : Bool */;
 468 val* var62 /* : MModule */;
 469 val* var64 /* : MModule */;
 470 val* var65 /* : MPropDef */;
 471 val* var_d /* var d: MMethodDef */;
 472 var_callsite = p0;
 473 {
 474 { /* Inline typing$CallSite$recv (var_callsite) on <var_callsite:CallSite> */
 475 var3 = var_callsite->attrs[COLOR_nitc__typing__CallSite___recv].val; /* _recv on <var_callsite:CallSite> */
 476 if (unlikely(var3 == NULL)) {
 477 if(catchStack.cursor >= 0){
 478 longjmp(catchStack.envs[catchStack.cursor], 1);
 479 }
 480 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _recv");
 481 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__typing, 642);
 482 fatal_exit(1);
 483 }
 484 var1 = var3;
 485 RET_LABEL2:(void)0;
 486 }
 487 }
 488 var_mtype = var1;
 489 {
 490 { /* Inline typing$CallSite$anchor (var_callsite) on <var_callsite:CallSite> */
 491 var6 = var_callsite->attrs[COLOR_nitc__typing__CallSite___anchor].val; /* _anchor on <var_callsite:CallSite> */
 492 var4 = var6;
 493 RET_LABEL5:(void)0;
 494 }
 495 }
 496 var_anchor = var4;
 497 if (var_anchor == NULL) {
 498 var7 = 0; /* is null */
 499 } else {
 500 var7 = 1; /* arg is null and recv is not */
 501 }
 502 if (0) {
 503 { /* Inline kernel$Object$!= (var_anchor,((val*)NULL)) on <var_anchor:nullable MClassType> */
 504 var_other = ((val*)NULL);
 505 {
 506 var10 = ((short int(*)(val* self, val* p0))(var_anchor->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_anchor, var_other); /* == on <var_anchor:nullable MClassType(MClassType)>*/
 507 }
 508 var11 = !var10;
 509 var8 = var11;
 510 goto RET_LABEL9;
 511 RET_LABEL9:(void)0;
 512 }
 513 var7 = var8;
 514 }
 515 if (var7){
 516 {
 517 { /* Inline typing$CallSite$mmodule (var_callsite) on <var_callsite:CallSite> */
 518 var14 = var_callsite->attrs[COLOR_nitc__typing__CallSite___mmodule].val; /* _mmodule on <var_callsite:CallSite> */
 519 if (unlikely(var14 == NULL)) {
 520 if(catchStack.cursor >= 0){
 521 longjmp(catchStack.envs[catchStack.cursor], 1);
 522 }
 523 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mmodule");
 524 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__typing, 645);
 525 fatal_exit(1);
 526 }
 527 var12 = var14;
 528 RET_LABEL13:(void)0;
 529 }
 530 }
 531 {
 532 var15 = ((val*(*)(val* self, val* p0, val* p1))(var_mtype->class->vft[COLOR_nitc__model__MType__anchor_to]))(var_mtype, var12, var_anchor); /* anchor_to on <var_mtype:MType>*/
 533 }
 534 var_mtype = var15;
 535 } else {
 536 }
 537 {
 538 var16 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nitc__model__MType__undecorate]))(var_mtype); /* undecorate on <var_mtype:MType>*/
 539 }
 540 var_mtype = var16;
 541 /* <var_mtype:MType> isa MClassType */
 542 cltype = type_nitc__MClassType.color;
 543 idtype = type_nitc__MClassType.id;
 544 if(cltype >= var_mtype->type->table_size) {
 545 var17 = 0;
 546 } else {
 547 var17 = var_mtype->type->type_table[cltype] == idtype;
 548 }
 549 if (var17){
 550 {
 551 { /* Inline model$MClassType$mclass (var_mtype) on <var_mtype:MType(MClassType)> */
 552 var20 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on <var_mtype:MType(MClassType)> */
 553 if (unlikely(var20 == NULL)) {
 554 if(catchStack.cursor >= 0){
 555 longjmp(catchStack.envs[catchStack.cursor], 1);
 556 }
 557 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
 558 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197);
 559 fatal_exit(1);
 560 }
 561 var18 = var20;
 562 RET_LABEL19:(void)0;
 563 }
 564 }
 565 {
 566 { /* Inline model$MClass$intro (var18) on <var18:MClass> */
 567 var23 = var18->attrs[COLOR_nitc__model__MClass___intro].val; /* _intro on <var18:MClass> */
 568 if (unlikely(var23 == NULL)) {
 569 if(catchStack.cursor >= 0){
 570 longjmp(catchStack.envs[catchStack.cursor], 1);
 571 }
 572 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro");
 573 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 496);
 574 fatal_exit(1);
 575 }
 576 var21 = var23;
 577 RET_LABEL22:(void)0;
 578 }
 579 }
 580 {
 581 { /* Inline model$MClassDef$bound_mtype (var21) on <var21:MClassDef> */
 582 var26 = var21->attrs[COLOR_nitc__model__MClassDef___bound_mtype].val; /* _bound_mtype on <var21:MClassDef> */
 583 if (unlikely(var26 == NULL)) {
 584 if(catchStack.cursor >= 0){
 585 longjmp(catchStack.envs[catchStack.cursor], 1);
 586 }
 587 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype");
 588 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 594);
 589 fatal_exit(1);
 590 }
 591 var24 = var26;
 592 RET_LABEL25:(void)0;
 593 }
 594 }
 595 var_mtype = var24;
 596 } else {
 597 }
 598 {
 599 { /* Inline typing$CallSite$mproperty (var_callsite) on <var_callsite:CallSite> */
 600 var29 = var_callsite->attrs[COLOR_nitc__typing__CallSite___mproperty].val; /* _mproperty on <var_callsite:CallSite> */
 601 if (unlikely(var29 == NULL)) {
 602 if(catchStack.cursor >= 0){
 603 longjmp(catchStack.envs[catchStack.cursor], 1);
 604 }
 605 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty");
 606 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__typing, 656);
 607 fatal_exit(1);
 608 }
 609 var27 = var29;
 610 RET_LABEL28:(void)0;
 611 }
 612 }
 613 var_mproperty = var27;
 614 {
 615 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_targets_cache (self) on <self:RapidTypeAnalysis> */
 616 var32 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_targets_cache].val; /* _live_targets_cache on <self:RapidTypeAnalysis> */
 617 if (unlikely(var32 == NULL)) {
 618 if(catchStack.cursor >= 0){
 619 longjmp(catchStack.envs[catchStack.cursor], 1);
 620 }
 621 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_targets_cache");
 622 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 92);
 623 fatal_exit(1);
 624 }
 625 var30 = var32;
 626 RET_LABEL31:(void)0;
 627 }
 628 }
 629 {
 630 var33 = more_collections___more_collections__HashMap2____91d_93d(var30, var_mtype, var_mproperty);
 631 }
 632 var_res = var33;
 633 if (var_res == NULL) {
 634 var34 = 0; /* is null */
 635 } else {
 636 var34 = 1; /* arg is null and recv is not */
 637 }
 638 if (0) {
 639 { /* Inline kernel$Object$!= (var_res,((val*)NULL)) on <var_res:nullable Set[MMethodDef]> */
 640 var_other = ((val*)NULL);
 641 {
 642 var37 = ((short int(*)(val* self, val* p0))((((long)var_res&3)?class_info[((long)var_res&3)]:var_res->class)->vft[COLOR_core__kernel__Object___61d_61d]))(var_res, var_other); /* == on <var_res:nullable Set[MMethodDef](Set[MMethodDef])>*/
 643 }
 644 var38 = !var37;
 645 var35 = var38;
 646 goto RET_LABEL36;
 647 RET_LABEL36:(void)0;
 648 }
 649 var34 = var35;
 650 }
 651 if (var34){
 652 var = var_res;
 653 goto RET_LABEL;
 654 } else {
 655 }
 656 var39 = NEW_core__ArraySet(&type_core__ArraySet__nitc__MMethodDef);
 657 {
 658 core___core__ArraySet___core__kernel__Object__init(var39); /* Direct call array$ArraySet$init on <var39:ArraySet[MMethodDef]>*/
 659 }
 660 var_res = var39;
 661 {
 662 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_targets_cache (self) on <self:RapidTypeAnalysis> */
 663 var42 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_targets_cache].val; /* _live_targets_cache on <self:RapidTypeAnalysis> */
 664 if (unlikely(var42 == NULL)) {
 665 if(catchStack.cursor >= 0){
 666 longjmp(catchStack.envs[catchStack.cursor], 1);
 667 }
 668 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_targets_cache");
 669 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 92);
 670 fatal_exit(1);
 671 }
 672 var40 = var42;
 673 RET_LABEL41:(void)0;
 674 }
 675 }
 676 {
 677 more_collections___more_collections__HashMap2____91d_93d_61d(var40, var_mtype, var_mproperty, var_res); /* Direct call more_collections$HashMap2$[]= on <var40:HashMap2[MType, MProperty, Set[MMethodDef]]>*/
 678 }
 679 {
 680 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_classes (self) on <self:RapidTypeAnalysis> */
 681 var45 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_classes].val; /* _live_classes on <self:RapidTypeAnalysis> */
 682 if (unlikely(var45 == NULL)) {
 683 if(catchStack.cursor >= 0){
 684 longjmp(catchStack.envs[catchStack.cursor], 1);
 685 }
 686 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_classes");
 687 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 69);
 688 fatal_exit(1);
 689 }
 690 var43 = var45;
 691 RET_LABEL44:(void)0;
 692 }
 693 }
 694 var_ = var43;
 695 {
 696 var46 = core___core__HashSet___core__abstract_collection__Collection__iterator(var_);
 697 }
 698 var_47 = var46;
 699 for(;;) {
 700 {
 701 var48 = ((short int(*)(val* self))((((long)var_47&3)?class_info[((long)var_47&3)]:var_47->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_47); /* is_ok on <var_47:Iterator[MClass]>*/
 702 }
 703 if (var48){
 704 } else {
 705 goto BREAK_label;
 706 }
 707 {
 708 var49 = ((val*(*)(val* self))((((long)var_47&3)?class_info[((long)var_47&3)]:var_47->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_47); /* item on <var_47:Iterator[MClass]>*/
 709 }
 710 var_c = var49;
 711 {
 712 { /* Inline model$MClass$intro (var_c) on <var_c:MClass> */
 713 var52 = var_c->attrs[COLOR_nitc__model__MClass___intro].val; /* _intro on <var_c:MClass> */
 714 if (unlikely(var52 == NULL)) {
 715 if(catchStack.cursor >= 0){
 716 longjmp(catchStack.envs[catchStack.cursor], 1);
 717 }
 718 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro");
 719 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 496);
 720 fatal_exit(1);
 721 }
 722 var50 = var52;
 723 RET_LABEL51:(void)0;
 724 }
 725 }
 726 {
 727 { /* Inline model$MClassDef$bound_mtype (var50) on <var50:MClassDef> */
 728 var55 = var50->attrs[COLOR_nitc__model__MClassDef___bound_mtype].val; /* _bound_mtype on <var50:MClassDef> */
 729 if (unlikely(var55 == NULL)) {
 730 if(catchStack.cursor >= 0){
 731 longjmp(catchStack.envs[catchStack.cursor], 1);
 732 }
 733 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype");
 734 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 594);
 735 fatal_exit(1);
 736 }
 737 var53 = var55;
 738 RET_LABEL54:(void)0;
 739 }
 740 }
 741 var_tc = var53;
 742 {
 743 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
 744 var58 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
 745 if (unlikely(var58 == NULL)) {
 746 if(catchStack.cursor >= 0){
 747 longjmp(catchStack.envs[catchStack.cursor], 1);
 748 }
 749 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
 750 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
 751 fatal_exit(1);
 752 }
 753 var56 = var58;
 754 RET_LABEL57:(void)0;
 755 }
 756 }
 757 {
 758 var59 = nitc___nitc__MType___is_subtype(var_tc, var56, ((val*)NULL), var_mtype);
 759 }
 760 var60 = !var59;
 761 if (var60){
 762 goto BREAK_label61;
 763 } else {
 764 }
 765 {
 766 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
 767 var64 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
 768 if (unlikely(var64 == NULL)) {
 769 if(catchStack.cursor >= 0){
 770 longjmp(catchStack.envs[catchStack.cursor], 1);
 771 }
 772 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
 773 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
 774 fatal_exit(1);
 775 }
 776 var62 = var64;
 777 RET_LABEL63:(void)0;
 778 }
 779 }
 780 {
 781 var65 = nitc___nitc__MProperty___lookup_first_definition(var_mproperty, var62, var_tc);
 782 }
 783 var_d = var65;
 784 {
 785 core___core__ArraySet___core__abstract_collection__SimpleCollection__add(var_res, var_d); /* Direct call array$ArraySet$add on <var_res:nullable Set[MMethodDef](ArraySet[MMethodDef])>*/
 786 }
 787 BREAK_label61: (void)0;
 788 {
 789 ((void(*)(val* self))((((long)var_47&3)?class_info[((long)var_47&3)]:var_47->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_47); /* next on <var_47:Iterator[MClass]>*/
 790 }
 791 }
 792 BREAK_label: (void)0;
 793 {
 794 ((void(*)(val* self))((((long)var_47&3)?class_info[((long)var_47&3)]:var_47->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_47); /* finish on <var_47:Iterator[MClass]>*/
 795 }
 796 var = var_res;
 797 goto RET_LABEL;
 798 RET_LABEL:;
 799 return var;
 800 }
 801 /* method rapid_type_analysis$RapidTypeAnalysis$live_super_sends for (self: RapidTypeAnalysis): HashSet[MMethodDef] */
 802 val* nitc___nitc__RapidTypeAnalysis___live_super_sends(val* self) {
 803 val* var /* : HashSet[MMethodDef] */;
 804 val* var1 /* : HashSet[MMethodDef] */;
 805 var1 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_super_sends].val; /* _live_super_sends on <self:RapidTypeAnalysis> */
 806 if (unlikely(var1 == NULL)) {
 807 if(catchStack.cursor >= 0){
 808 longjmp(catchStack.envs[catchStack.cursor], 1);
 809 }
 810 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_super_sends");
 811 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 118);
 812 fatal_exit(1);
 813 }
 814 var = var1;
 815 RET_LABEL:;
 816 return var;
 817 }
 818 /* method rapid_type_analysis$RapidTypeAnalysis$live_types_to_csv for (self: RapidTypeAnalysis): CsvDocument */
 819 val* nitc___nitc__RapidTypeAnalysis___live_types_to_csv(val* self) {
 820 val* var /* : CsvDocument */;
 821 val* var1 /* : HashSet[MType] */;
 822 val* var_typeset /* var typeset: HashSet[MType] */;
 823 val* var2 /* : HashSet[MClassType] */;
 824 val* var4 /* : HashSet[MClassType] */;
 825 val* var5 /* : HashSet[MClassType] */;
 826 val* var7 /* : HashSet[MClassType] */;
 827 val* var8 /* : HashSet[MType] */;
 828 val* var10 /* : HashSet[MType] */;
 829 val* var11 /* : HashSet[MType] */;
 830 val* var13 /* : HashSet[MType] */;
 831 val* var14 /* : Array[nullable Object] */;
 832 val* var_types /* var types: Array[MType] */;
 833 val* var15 /* : CachedAlphaComparator */;
 834 val* var17 /* : CsvDocument */;
 835 val* var_res /* var res: CsvDocument */;
 836 val* var19 /* : Array[String] */;
 837 val* var_ /* var : Array[String] */;
 838 static val* varonce;
 839 val* var20 /* : String */;
 840 char* var21 /* : CString */;
 841 val* var22 /* : String */;
 842 val* var23 /* : nullable Int */;
 843 val* var24 /* : nullable Int */;
 844 val* var25 /* : nullable Bool */;
 845 val* var26 /* : nullable Bool */;
 846 static val* varonce27;
 847 val* var28 /* : String */;
 848 char* var29 /* : CString */;
 849 val* var30 /* : String */;
 850 val* var31 /* : nullable Int */;
 851 val* var32 /* : nullable Int */;
 852 val* var33 /* : nullable Bool */;
 853 val* var34 /* : nullable Bool */;
 854 static val* varonce35;
 855 val* var36 /* : String */;
 856 char* var37 /* : CString */;
 857 val* var38 /* : String */;
 858 val* var39 /* : nullable Int */;
 859 val* var40 /* : nullable Int */;
 860 val* var41 /* : nullable Bool */;
 861 val* var42 /* : nullable Bool */;
 862 static val* varonce43;
 863 val* var44 /* : String */;
 864 char* var45 /* : CString */;
 865 val* var46 /* : String */;
 866 val* var47 /* : nullable Int */;
 867 val* var48 /* : nullable Int */;
 868 val* var49 /* : nullable Bool */;
 869 val* var50 /* : nullable Bool */;
 870 val* var_52 /* var : Array[MType] */;
 871 val* var53 /* : IndexedIterator[nullable Object] */;
 872 val* var_54 /* var : IndexedIterator[MType] */;
 873 short int var55 /* : Bool */;
 874 val* var56 /* : nullable Object */;
 875 val* var_t /* var t: MType */;
 876 short int var57 /* : Bool */;
 877 static val* varonce58;
 878 val* var59 /* : String */;
 879 char* var60 /* : CString */;
 880 val* var61 /* : String */;
 881 val* var62 /* : nullable Int */;
 882 val* var63 /* : nullable Int */;
 883 val* var64 /* : nullable Bool */;
 884 val* var65 /* : nullable Bool */;
 885 val* var_reso /* var reso: nullable Object */;
 886 static val* varonce66;
 887 val* var67 /* : String */;
 888 char* var68 /* : CString */;
 889 val* var69 /* : String */;
 890 val* var70 /* : nullable Int */;
 891 val* var71 /* : nullable Int */;
 892 val* var72 /* : nullable Bool */;
 893 val* var73 /* : nullable Bool */;
 894 short int var74 /* : Bool */;
 895 short int var75 /* : Bool */;
 896 int cltype;
 897 int idtype;
 898 short int var_76 /* var : Bool */;
 899 short int var77 /* : Bool */;
 900 val* var78 /* : HashSet[MClassType] */;
 901 val* var80 /* : HashSet[MClassType] */;
 902 short int var81 /* : Bool */;
 903 short int var_82 /* var : Bool */;
 904 val* var83 /* : HashSet[MClassType] */;
 905 val* var85 /* : HashSet[MClassType] */;
 906 short int var86 /* : Bool */;
 907 static val* varonce87;
 908 val* var88 /* : String */;
 909 char* var89 /* : CString */;
 910 val* var90 /* : String */;
 911 val* var91 /* : nullable Int */;
 912 val* var92 /* : nullable Int */;
 913 val* var93 /* : nullable Bool */;
 914 val* var94 /* : nullable Bool */;
 915 val* var_live /* var live: nullable Object */;
 916 static val* varonce95;
 917 val* var96 /* : String */;
 918 char* var97 /* : CString */;
 919 val* var98 /* : String */;
 920 val* var99 /* : nullable Int */;
 921 val* var100 /* : nullable Int */;
 922 val* var101 /* : nullable Bool */;
 923 val* var102 /* : nullable Bool */;
 924 short int var103 /* : Bool */;
 925 val* var104 /* : HashSet[MType] */;
 926 val* var106 /* : HashSet[MType] */;
 927 short int var107 /* : Bool */;
 928 short int var_108 /* var : Bool */;
 929 val* var109 /* : HashSet[MType] */;
 930 val* var111 /* : HashSet[MType] */;
 931 short int var112 /* : Bool */;
 932 static val* varonce113;
 933 val* var114 /* : String */;
 934 char* var115 /* : CString */;
 935 val* var116 /* : String */;
 936 val* var117 /* : nullable Int */;
 937 val* var118 /* : nullable Int */;
 938 val* var119 /* : nullable Bool */;
 939 val* var120 /* : nullable Bool */;
 940 val* var_cast /* var cast: nullable Object */;
 941 static val* varonce121;
 942 val* var122 /* : String */;
 943 char* var123 /* : CString */;
 944 val* var124 /* : String */;
 945 val* var125 /* : nullable Int */;
 946 val* var126 /* : nullable Int */;
 947 val* var127 /* : nullable Bool */;
 948 val* var128 /* : nullable Bool */;
 949 val* var129 /* : Array[Object] */;
 950 val* var130 /* : NativeArray[Object] */;
 951 var1 = NEW_core__HashSet(&type_core__HashSet__nitc__MType);
 952 {
 953 core___core__HashSet___core__kernel__Object__init(var1); /* Direct call hash_collection$HashSet$init on <var1:HashSet[MType]>*/
 954 }
 955 var_typeset = var1;
 956 {
 957 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_types (self) on <self:RapidTypeAnalysis> */
 958 var4 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on <self:RapidTypeAnalysis> */
 959 if (unlikely(var4 == NULL)) {
 960 if(catchStack.cursor >= 0){
 961 longjmp(catchStack.envs[catchStack.cursor], 1);
 962 }
 963 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types");
 964 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 60);
 965 fatal_exit(1);
 966 }
 967 var2 = var4;
 968 RET_LABEL3:(void)0;
 969 }
 970 }
 971 {
 972 core___core__SimpleCollection___add_all(var_typeset, var2); /* Direct call abstract_collection$SimpleCollection$add_all on <var_typeset:HashSet[MType]>*/
 973 }
 974 {
 975 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_open_types (self) on <self:RapidTypeAnalysis> */
 976 var7 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_open_types].val; /* _live_open_types on <self:RapidTypeAnalysis> */
 977 if (unlikely(var7 == NULL)) {
 978 if(catchStack.cursor >= 0){
 979 longjmp(catchStack.envs[catchStack.cursor], 1);
 980 }
 981 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_types");
 982 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 65);
 983 fatal_exit(1);
 984 }
 985 var5 = var7;
 986 RET_LABEL6:(void)0;
 987 }
 988 }
 989 {
 990 core___core__SimpleCollection___add_all(var_typeset, var5); /* Direct call abstract_collection$SimpleCollection$add_all on <var_typeset:HashSet[MType]>*/
 991 }
 992 {
 993 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_cast_types (self) on <self:RapidTypeAnalysis> */
 994 var10 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_cast_types].val; /* _live_cast_types on <self:RapidTypeAnalysis> */
 995 if (unlikely(var10 == NULL)) {
 996 if(catchStack.cursor >= 0){
 997 longjmp(catchStack.envs[catchStack.cursor], 1);
 998 }
 999 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_cast_types");
1000 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 72);
1001 fatal_exit(1);
1002 }
1003 var8 = var10;
1004 RET_LABEL9:(void)0;
1005 }
1006 }
1007 {
1008 core___core__SimpleCollection___add_all(var_typeset, var8); /* Direct call abstract_collection$SimpleCollection$add_all on <var_typeset:HashSet[MType]>*/
1009 }
1010 {
1011 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_open_cast_types (self) on <self:RapidTypeAnalysis> */
1012 var13 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_open_cast_types].val; /* _live_open_cast_types on <self:RapidTypeAnalysis> */
1013 if (unlikely(var13 == NULL)) {
1014 if(catchStack.cursor >= 0){
1015 longjmp(catchStack.envs[catchStack.cursor], 1);
1016 }
1017 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_cast_types");
1018 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 75);
1019 fatal_exit(1);
1020 }
1021 var11 = var13;
1022 RET_LABEL12:(void)0;
1023 }
1024 }
1025 {
1026 core___core__SimpleCollection___add_all(var_typeset, var11); /* Direct call abstract_collection$SimpleCollection$add_all on <var_typeset:HashSet[MType]>*/
1027 }
1028 {
1029 var14 = core__array___Collection___to_a(var_typeset);
1030 }
1031 var_types = var14;
1032 var15 = NEW_core__CachedAlphaComparator(&type_core__CachedAlphaComparator);
1033 {
1034 { /* Inline kernel$Object$init (var15) on <var15:CachedAlphaComparator> */
1035 RET_LABEL16:(void)0;
1036 }
1037 }
1038 {
1039 core___core__Comparator___sort(var15, var_types); /* Direct call sorter$Comparator$sort on <var15:CachedAlphaComparator>*/
1040 }
1041 var17 = NEW_csv__CsvDocument(&type_csv__CsvDocument);
1042 {
1043 ((void(*)(val* self, val* p0))(var17->class->vft[COLOR_csv__CsvDocument__header_61d]))(var17, ((val*)NULL)); /* header= on <var17:CsvDocument>*/
1044 }
1045 {
1046 ((void(*)(val* self, val* p0))(var17->class->vft[COLOR_csv__CsvDocument__records_61d]))(var17, ((val*)NULL)); /* records= on <var17:CsvDocument>*/
1047 }
1048 {
1049 ((void(*)(val* self))(var17->class->vft[COLOR_core__kernel__Object__init]))(var17); /* init on <var17:CsvDocument>*/
1050 }
1051 var_res = var17;
1052 {
1053 { /* Inline csv$CsvStream$separator= (var_res,';') on <var_res:CsvDocument> */
1054 var_res->attrs[COLOR_csv__CsvStream___separator].c = ';'; /* _separator on <var_res:CsvDocument> */
1055 RET_LABEL18:(void)0;
1056 }
1057 }
1058 var19 = NEW_core__Array(&type_core__Array__core__String);
1059 {
1060 core___core__Array___with_capacity(var19, 4l); /* Direct call array$Array$with_capacity on <var19:Array[String]>*/
1061 }
1062 var_ = var19;
1063 if (likely(varonce!=NULL)) {
1064 var20 = varonce;
1065 } else {
1066 var21 = "Type";
1067 var23 = (val*)(4l<<2|1);
1068 var24 = (val*)(4l<<2|1);
1069 var25 = (val*)((long)(0)<<2|3);
1070 var26 = (val*)((long)(0)<<2|3);
1071 var22 = core__flat___CString___to_s_unsafe(var21, var23, var24, var25, var26);
1072 var20 = var22;
1073 varonce = var20;
1074 }
1075 {
1076 core___core__AbstractArray___core__abstract_collection__Sequence__push(var_, var20); /* Direct call array$AbstractArray$push on <var_:Array[String]>*/
1077 }
1078 if (likely(varonce27!=NULL)) {
1079 var28 = varonce27;
1080 } else {
1081 var29 = "Resolution";
1082 var31 = (val*)(10l<<2|1);
1083 var32 = (val*)(10l<<2|1);
1084 var33 = (val*)((long)(0)<<2|3);
1085 var34 = (val*)((long)(0)<<2|3);
1086 var30 = core__flat___CString___to_s_unsafe(var29, var31, var32, var33, var34);
1087 var28 = var30;
1088 varonce27 = var28;
1089 }
1090 {
1091 core___core__AbstractArray___core__abstract_collection__Sequence__push(var_, var28); /* Direct call array$AbstractArray$push on <var_:Array[String]>*/
1092 }
1093 if (likely(varonce35!=NULL)) {
1094 var36 = varonce35;
1095 } else {
1096 var37 = "Liveness";
1097 var39 = (val*)(8l<<2|1);
1098 var40 = (val*)(8l<<2|1);
1099 var41 = (val*)((long)(0)<<2|3);
1100 var42 = (val*)((long)(0)<<2|3);
1101 var38 = core__flat___CString___to_s_unsafe(var37, var39, var40, var41, var42);
1102 var36 = var38;
1103 varonce35 = var36;
1104 }
1105 {
1106 core___core__AbstractArray___core__abstract_collection__Sequence__push(var_, var36); /* Direct call array$AbstractArray$push on <var_:Array[String]>*/
1107 }
1108 if (likely(varonce43!=NULL)) {
1109 var44 = varonce43;
1110 } else {
1111 var45 = "Cast-liveness";
1112 var47 = (val*)(13l<<2|1);
1113 var48 = (val*)(13l<<2|1);
1114 var49 = (val*)((long)(0)<<2|3);
1115 var50 = (val*)((long)(0)<<2|3);
1116 var46 = core__flat___CString___to_s_unsafe(var45, var47, var48, var49, var50);
1117 var44 = var46;
1118 varonce43 = var44;
1119 }
1120 {
1121 core___core__AbstractArray___core__abstract_collection__Sequence__push(var_, var44); /* Direct call array$AbstractArray$push on <var_:Array[String]>*/
1122 }
1123 {
1124 { /* Inline csv$CsvDocument$header= (var_res,var_) on <var_res:CsvDocument> */
1125 var_res->attrs[COLOR_csv__CsvDocument___header].val = var_; /* _header on <var_res:CsvDocument> */
1126 RET_LABEL51:(void)0;
1127 }
1128 }
1129 var_52 = var_types;
1130 {
1131 var53 = core___core__AbstractArrayRead___core__abstract_collection__Collection__iterator(var_52);
1132 }
1133 var_54 = var53;
1134 for(;;) {
1135 {
1136 var55 = ((short int(*)(val* self))((((long)var_54&3)?class_info[((long)var_54&3)]:var_54->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_54); /* is_ok on <var_54:IndexedIterator[MType]>*/
1137 }
1138 if (var55){
1139 } else {
1140 goto BREAK_label;
1141 }
1142 {
1143 var56 = ((val*(*)(val* self))((((long)var_54&3)?class_info[((long)var_54&3)]:var_54->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_54); /* item on <var_54:IndexedIterator[MType]>*/
1144 }
1145 var_t = var56;
1146 {
1147 var57 = ((short int(*)(val* self))(var_t->class->vft[COLOR_nitc__model__MType__need_anchor]))(var_t); /* need_anchor on <var_t:MType>*/
1148 }
1149 if (var57){
1150 if (likely(varonce58!=NULL)) {
1151 var59 = varonce58;
1152 } else {
1153 var60 = "OPEN ";
1154 var62 = (val*)(5l<<2|1);
1155 var63 = (val*)(5l<<2|1);
1156 var64 = (val*)((long)(0)<<2|3);
1157 var65 = (val*)((long)(0)<<2|3);
1158 var61 = core__flat___CString___to_s_unsafe(var60, var62, var63, var64, var65);
1159 var59 = var61;
1160 varonce58 = var59;
1161 }
1162 var_reso = var59;
1163 } else {
1164 if (likely(varonce66!=NULL)) {
1165 var67 = varonce66;
1166 } else {
1167 var68 = "CLOSED";
1168 var70 = (val*)(6l<<2|1);
1169 var71 = (val*)(6l<<2|1);
1170 var72 = (val*)((long)(0)<<2|3);
1171 var73 = (val*)((long)(0)<<2|3);
1172 var69 = core__flat___CString___to_s_unsafe(var68, var70, var71, var72, var73);
1173 var67 = var69;
1174 varonce66 = var67;
1175 }
1176 var_reso = var67;
1177 }
1178 /* <var_t:MType> isa MClassType */
1179 cltype = type_nitc__MClassType.color;
1180 idtype = type_nitc__MClassType.id;
1181 if(cltype >= var_t->type->table_size) {
1182 var75 = 0;
1183 } else {
1184 var75 = var_t->type->type_table[cltype] == idtype;
1185 }
1186 var_76 = var75;
1187 if (var75){
1188 {
1189 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_types (self) on <self:RapidTypeAnalysis> */
1190 var80 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on <self:RapidTypeAnalysis> */
1191 if (unlikely(var80 == NULL)) {
1192 if(catchStack.cursor >= 0){
1193 longjmp(catchStack.envs[catchStack.cursor], 1);
1194 }
1195 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types");
1196 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 60);
1197 fatal_exit(1);
1198 }
1199 var78 = var80;
1200 RET_LABEL79:(void)0;
1201 }
1202 }
1203 {
1204 var81 = core___core__HashSet___core__abstract_collection__Collection__has(var78, var_t);
1205 }
1206 var_82 = var81;
1207 if (var81){
1208 var77 = var_82;
1209 } else {
1210 {
1211 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_open_types (self) on <self:RapidTypeAnalysis> */
1212 var85 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_open_types].val; /* _live_open_types on <self:RapidTypeAnalysis> */
1213 if (unlikely(var85 == NULL)) {
1214 if(catchStack.cursor >= 0){
1215 longjmp(catchStack.envs[catchStack.cursor], 1);
1216 }
1217 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_types");
1218 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 65);
1219 fatal_exit(1);
1220 }
1221 var83 = var85;
1222 RET_LABEL84:(void)0;
1223 }
1224 }
1225 {
1226 var86 = core___core__HashSet___core__abstract_collection__Collection__has(var83, var_t);
1227 }
1228 var77 = var86;
1229 }
1230 var74 = var77;
1231 } else {
1232 var74 = var_76;
1233 }
1234 if (var74){
1235 if (likely(varonce87!=NULL)) {
1236 var88 = varonce87;
1237 } else {
1238 var89 = "LIVE";
1239 var91 = (val*)(4l<<2|1);
1240 var92 = (val*)(4l<<2|1);
1241 var93 = (val*)((long)(0)<<2|3);
1242 var94 = (val*)((long)(0)<<2|3);
1243 var90 = core__flat___CString___to_s_unsafe(var89, var91, var92, var93, var94);
1244 var88 = var90;
1245 varonce87 = var88;
1246 }
1247 var_live = var88;
1248 } else {
1249 if (likely(varonce95!=NULL)) {
1250 var96 = varonce95;
1251 } else {
1252 var97 = "DEAD";
1253 var99 = (val*)(4l<<2|1);
1254 var100 = (val*)(4l<<2|1);
1255 var101 = (val*)((long)(0)<<2|3);
1256 var102 = (val*)((long)(0)<<2|3);
1257 var98 = core__flat___CString___to_s_unsafe(var97, var99, var100, var101, var102);
1258 var96 = var98;
1259 varonce95 = var96;
1260 }
1261 var_live = var96;
1262 }
1263 {
1264 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_cast_types (self) on <self:RapidTypeAnalysis> */
1265 var106 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_cast_types].val; /* _live_cast_types on <self:RapidTypeAnalysis> */
1266 if (unlikely(var106 == NULL)) {
1267 if(catchStack.cursor >= 0){
1268 longjmp(catchStack.envs[catchStack.cursor], 1);
1269 }
1270 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_cast_types");
1271 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 72);
1272 fatal_exit(1);
1273 }
1274 var104 = var106;
1275 RET_LABEL105:(void)0;
1276 }
1277 }
1278 {
1279 var107 = core___core__HashSet___core__abstract_collection__Collection__has(var104, var_t);
1280 }
1281 var_108 = var107;
1282 if (var107){
1283 var103 = var_108;
1284 } else {
1285 {
1286 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_open_cast_types (self) on <self:RapidTypeAnalysis> */
1287 var111 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_open_cast_types].val; /* _live_open_cast_types on <self:RapidTypeAnalysis> */
1288 if (unlikely(var111 == NULL)) {
1289 if(catchStack.cursor >= 0){
1290 longjmp(catchStack.envs[catchStack.cursor], 1);
1291 }
1292 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_cast_types");
1293 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 75);
1294 fatal_exit(1);
1295 }
1296 var109 = var111;
1297 RET_LABEL110:(void)0;
1298 }
1299 }
1300 {
1301 var112 = core___core__HashSet___core__abstract_collection__Collection__has(var109, var_t);
1302 }
1303 var103 = var112;
1304 }
1305 if (var103){
1306 if (likely(varonce113!=NULL)) {
1307 var114 = varonce113;
1308 } else {
1309 var115 = "CAST LIVE";
1310 var117 = (val*)(9l<<2|1);
1311 var118 = (val*)(9l<<2|1);
1312 var119 = (val*)((long)(0)<<2|3);
1313 var120 = (val*)((long)(0)<<2|3);
1314 var116 = core__flat___CString___to_s_unsafe(var115, var117, var118, var119, var120);
1315 var114 = var116;
1316 varonce113 = var114;
1317 }
1318 var_cast = var114;
1319 } else {
1320 if (likely(varonce121!=NULL)) {
1321 var122 = varonce121;
1322 } else {
1323 var123 = "CAST DEAD";
1324 var125 = (val*)(9l<<2|1);
1325 var126 = (val*)(9l<<2|1);
1326 var127 = (val*)((long)(0)<<2|3);
1327 var128 = (val*)((long)(0)<<2|3);
1328 var124 = core__flat___CString___to_s_unsafe(var123, var125, var126, var127, var128);
1329 var122 = var124;
1330 varonce121 = var122;
1331 }
1332 var_cast = var122;
1333 }
1334 var129 = NEW_core__Array(&type_core__Array__core__Object);
1335 { /* var129 = array_instance Array[Object] */
1336 var130 = NEW_core__NativeArray((int)4l, &type_core__NativeArray__core__Object);
1337 ((struct instance_core__NativeArray*)var130)->values[0] = (val*) var_t;
1338 ((struct instance_core__NativeArray*)var130)->values[1] = (val*) var_reso;
1339 ((struct instance_core__NativeArray*)var130)->values[2] = (val*) var_live;
1340 ((struct instance_core__NativeArray*)var130)->values[3] = (val*) var_cast;
1341 {
1342 ((void(*)(val* self, val* p0, long p1))(var129->class->vft[COLOR_core__array__Array__with_native]))(var129, var130, 4l); /* with_native on <var129:Array[Object]>*/
1343 }
1344 }
1345 {
1346 csv___csv__CsvDocument___add_record(var_res, var129); /* Direct call csv$CsvDocument$add_record on <var_res:CsvDocument>*/
1347 }
1348 {
1349 ((void(*)(val* self))((((long)var_54&3)?class_info[((long)var_54&3)]:var_54->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_54); /* next on <var_54:IndexedIterator[MType]>*/
1350 }
1351 }
1352 BREAK_label: (void)0;
1353 {
1354 ((void(*)(val* self))((((long)var_54&3)?class_info[((long)var_54&3)]:var_54->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_54); /* finish on <var_54:IndexedIterator[MType]>*/
1355 }
1356 var = var_res;
1357 goto RET_LABEL;
1358 RET_LABEL:;
1359 return var;
1360 }
1361 /* method rapid_type_analysis$RapidTypeAnalysis$live_methods_to_tree for (self: RapidTypeAnalysis): OrderedTree[Object] */
1362 val* nitc___nitc__RapidTypeAnalysis___live_methods_to_tree(val* self) {
1363 val* var /* : OrderedTree[Object] */;
1364 val* var1 /* : OrderedTree[Object] */;
1365 val* var_tree /* var tree: OrderedTree[Object] */;
1366 val* var3 /* : HashSet[MMethod] */;
1367 val* var5 /* : HashSet[MMethod] */;
1368 val* var_ /* var : HashSet[MMethod] */;
1369 val* var6 /* : Iterator[nullable Object] */;
1370 val* var_7 /* var : Iterator[MMethod] */;
1371 short int var8 /* : Bool */;
1372 val* var9 /* : nullable Object */;
1373 val* var_x /* var x: MMethod */;
1374 val* var10 /* : String */;
1375 val* var_xn /* var xn: String */;
1376 val* var11 /* : Array[MPropDef] */;
1377 val* var13 /* : Array[MPropDef] */;
1378 val* var_14 /* var : Array[MMethodDef] */;
1379 val* var15 /* : IndexedIterator[nullable Object] */;
1380 val* var_16 /* var : IndexedIterator[MMethodDef] */;
1381 short int var17 /* : Bool */;
1382 val* var19 /* : nullable Object */;
1383 val* var_z /* var z: MMethodDef */;
1384 val* var20 /* : String */;
1385 val* var22 /* : String */;
1386 val* var_zn /* var zn: String */;
1387 val* var23 /* : HashSet[MMethodDef] */;
1388 val* var25 /* : HashSet[MMethodDef] */;
1389 short int var26 /* : Bool */;
1390 val* var27 /* : HashSet[MMethodDef] */;
1391 val* var29 /* : HashSet[MMethodDef] */;
1392 short int var30 /* : Bool */;
1393 static val* varonce;
1394 val* var31 /* : String */;
1395 char* var32 /* : CString */;
1396 val* var33 /* : String */;
1397 val* var34 /* : nullable Int */;
1398 val* var35 /* : nullable Int */;
1399 val* var36 /* : nullable Bool */;
1400 val* var37 /* : nullable Bool */;
1401 val* var38 /* : Text */;
1402 val* var39 /* : HashSet[MMethodDef] */;
1403 val* var41 /* : HashSet[MMethodDef] */;
1404 short int var42 /* : Bool */;
1405 static val* varonce43;
1406 val* var44 /* : String */;
1407 char* var45 /* : CString */;
1408 val* var46 /* : String */;
1409 val* var47 /* : nullable Int */;
1410 val* var48 /* : nullable Int */;
1411 val* var49 /* : nullable Bool */;
1412 val* var50 /* : nullable Bool */;
1413 val* var51 /* : Text */;
1414 val* var52 /* : Sys */;
1415 val* var53 /* : Comparator */;
1416 var1 = NEW_ordered_tree__OrderedTree(&type_ordered_tree__OrderedTree__core__Object);
1417 {
1418 { /* Inline kernel$Object$init (var1) on <var1:OrderedTree[Object]> */
1419 RET_LABEL2:(void)0;
1420 }
1421 }
1422 var_tree = var1;
1423 {
1424 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_methods (self) on <self:RapidTypeAnalysis> */
1425 var5 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_methods].val; /* _live_methods on <self:RapidTypeAnalysis> */
1426 if (unlikely(var5 == NULL)) {
1427 if(catchStack.cursor >= 0){
1428 longjmp(catchStack.envs[catchStack.cursor], 1);
1429 }
1430 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methods");
1431 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 82);
1432 fatal_exit(1);
1433 }
1434 var3 = var5;
1435 RET_LABEL4:(void)0;
1436 }
1437 }
1438 var_ = var3;
1439 {
1440 var6 = core___core__HashSet___core__abstract_collection__Collection__iterator(var_);
1441 }
1442 var_7 = var6;
1443 for(;;) {
1444 {
1445 var8 = ((short int(*)(val* self))((((long)var_7&3)?class_info[((long)var_7&3)]:var_7->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_7); /* is_ok on <var_7:Iterator[MMethod]>*/
1446 }
1447 if (var8){
1448 } else {
1449 goto BREAK_label;
1450 }
1451 {
1452 var9 = ((val*(*)(val* self))((((long)var_7&3)?class_info[((long)var_7&3)]:var_7->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_7); /* item on <var_7:Iterator[MMethod]>*/
1453 }
1454 var_x = var9;
1455 {
1456 var10 = nitc___nitc__MProperty___nitc__model_base__MEntity__full_name(var_x);
1457 }
1458 var_xn = var10;
1459 {
1460 ordered_tree___ordered_tree__OrderedTree___add(var_tree, ((val*)NULL), var_xn); /* Direct call ordered_tree$OrderedTree$add on <var_tree:OrderedTree[Object]>*/
1461 }
1462 {
1463 { /* Inline model$MProperty$mpropdefs (var_x) on <var_x:MMethod> */
1464 var13 = var_x->attrs[COLOR_nitc__model__MProperty___mpropdefs].val; /* _mpropdefs on <var_x:MMethod> */
1465 if (unlikely(var13 == NULL)) {
1466 if(catchStack.cursor >= 0){
1467 longjmp(catchStack.envs[catchStack.cursor], 1);
1468 }
1469 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdefs");
1470 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2092);
1471 fatal_exit(1);
1472 }
1473 var11 = var13;
1474 RET_LABEL12:(void)0;
1475 }
1476 }
1477 var_14 = var11;
1478 {
1479 var15 = core___core__AbstractArrayRead___core__abstract_collection__Collection__iterator(var_14);
1480 }
1481 var_16 = var15;
1482 for(;;) {
1483 {
1484 var17 = ((short int(*)(val* self))((((long)var_16&3)?class_info[((long)var_16&3)]:var_16->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_16); /* is_ok on <var_16:IndexedIterator[MMethodDef]>*/
1485 }
1486 if (var17){
1487 } else {
1488 goto BREAK_label18;
1489 }
1490 {
1491 var19 = ((val*(*)(val* self))((((long)var_16&3)?class_info[((long)var_16&3)]:var_16->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_16); /* item on <var_16:IndexedIterator[MMethodDef]>*/
1492 }
1493 var_z = var19;
1494 {
1495 { /* Inline model$MPropDef$to_s (var_z) on <var_z:MMethodDef> */
1496 var22 = var_z->attrs[COLOR_nitc__model__MPropDef___to_s].val; /* _to_s on <var_z:MMethodDef> */
1497 if (unlikely(var22 == NULL)) {
1498 if(catchStack.cursor >= 0){
1499 longjmp(catchStack.envs[catchStack.cursor], 1);
1500 }
1501 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _to_s");
1502 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2450);
1503 fatal_exit(1);
1504 }
1505 var20 = var22;
1506 RET_LABEL21:(void)0;
1507 }
1508 }
1509 var_zn = var20;
1510 {
1511 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_methoddefs (self) on <self:RapidTypeAnalysis> */
1512 var25 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_methoddefs].val; /* _live_methoddefs on <self:RapidTypeAnalysis> */
1513 if (unlikely(var25 == NULL)) {
1514 if(catchStack.cursor >= 0){
1515 longjmp(catchStack.envs[catchStack.cursor], 1);
1516 }
1517 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methoddefs");
1518 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 79);
1519 fatal_exit(1);
1520 }
1521 var23 = var25;
1522 RET_LABEL24:(void)0;
1523 }
1524 }
1525 {
1526 var26 = core___core__HashSet___core__abstract_collection__Collection__has(var23, var_z);
1527 }
1528 if (var26){
1529 {
1530 ordered_tree___ordered_tree__OrderedTree___add(var_tree, var_xn, var_zn); /* Direct call ordered_tree$OrderedTree$add on <var_tree:OrderedTree[Object]>*/
1531 }
1532 {
1533 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_super_sends (self) on <self:RapidTypeAnalysis> */
1534 var29 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_super_sends].val; /* _live_super_sends on <self:RapidTypeAnalysis> */
1535 if (unlikely(var29 == NULL)) {
1536 if(catchStack.cursor >= 0){
1537 longjmp(catchStack.envs[catchStack.cursor], 1);
1538 }
1539 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_super_sends");
1540 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 118);
1541 fatal_exit(1);
1542 }
1543 var27 = var29;
1544 RET_LABEL28:(void)0;
1545 }
1546 }
1547 {
1548 var30 = core___core__HashSet___core__abstract_collection__Collection__has(var27, var_z);
1549 }
1550 if (var30){
1551 if (likely(varonce!=NULL)) {
1552 var31 = varonce;
1553 } else {
1554 var32 = "(super)";
1555 var34 = (val*)(7l<<2|1);
1556 var35 = (val*)(7l<<2|1);
1557 var36 = (val*)((long)(0)<<2|3);
1558 var37 = (val*)((long)(0)<<2|3);
1559 var33 = core__flat___CString___to_s_unsafe(var32, var34, var35, var36, var37);
1560 var31 = var33;
1561 varonce = var31;
1562 }
1563 {
1564 var38 = ((val*(*)(val* self, val* p0))(var_zn->class->vft[COLOR_core__abstract_text__Text___43d]))(var_zn, var31); /* + on <var_zn:String>*/
1565 }
1566 {
1567 ordered_tree___ordered_tree__OrderedTree___add(var_tree, var_zn, var38); /* Direct call ordered_tree$OrderedTree$add on <var_tree:OrderedTree[Object]>*/
1568 }
1569 } else {
1570 }
1571 } else {
1572 {
1573 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_super_sends (self) on <self:RapidTypeAnalysis> */
1574 var41 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_super_sends].val; /* _live_super_sends on <self:RapidTypeAnalysis> */
1575 if (unlikely(var41 == NULL)) {
1576 if(catchStack.cursor >= 0){
1577 longjmp(catchStack.envs[catchStack.cursor], 1);
1578 }
1579 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_super_sends");
1580 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 118);
1581 fatal_exit(1);
1582 }
1583 var39 = var41;
1584 RET_LABEL40:(void)0;
1585 }
1586 }
1587 {
1588 var42 = core___core__HashSet___core__abstract_collection__Collection__has(var39, var_z);
1589 }
1590 if (var42){
1591 if (likely(varonce43!=NULL)) {
1592 var44 = varonce43;
1593 } else {
1594 var45 = "(super)";
1595 var47 = (val*)(7l<<2|1);
1596 var48 = (val*)(7l<<2|1);
1597 var49 = (val*)((long)(0)<<2|3);
1598 var50 = (val*)((long)(0)<<2|3);
1599 var46 = core__flat___CString___to_s_unsafe(var45, var47, var48, var49, var50);
1600 var44 = var46;
1601 varonce43 = var44;
1602 }
1603 {
1604 var51 = ((val*(*)(val* self, val* p0))(var_zn->class->vft[COLOR_core__abstract_text__Text___43d]))(var_zn, var44); /* + on <var_zn:String>*/
1605 }
1606 {
1607 ordered_tree___ordered_tree__OrderedTree___add(var_tree, var_xn, var51); /* Direct call ordered_tree$OrderedTree$add on <var_tree:OrderedTree[Object]>*/
1608 }
1609 } else {
1610 }
1611 }
1612 {
1613 ((void(*)(val* self))((((long)var_16&3)?class_info[((long)var_16&3)]:var_16->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_16); /* next on <var_16:IndexedIterator[MMethodDef]>*/
1614 }
1615 }
1616 BREAK_label18: (void)0;
1617 {
1618 ((void(*)(val* self))((((long)var_16&3)?class_info[((long)var_16&3)]:var_16->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_16); /* finish on <var_16:IndexedIterator[MMethodDef]>*/
1619 }
1620 {
1621 ((void(*)(val* self))((((long)var_7&3)?class_info[((long)var_7&3)]:var_7->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_7); /* next on <var_7:Iterator[MMethod]>*/
1622 }
1623 }
1624 BREAK_label: (void)0;
1625 {
1626 ((void(*)(val* self))((((long)var_7&3)?class_info[((long)var_7&3)]:var_7->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_7); /* finish on <var_7:Iterator[MMethod]>*/
1627 }
1628 var52 = glob_sys;
1629 {
1630 var53 = core__abstract_text___Sys___alpha_comparator(var52);
1631 }
1632 {
1633 ordered_tree___ordered_tree__OrderedTree___sort_with(var_tree, var53); /* Direct call ordered_tree$OrderedTree$sort_with on <var_tree:OrderedTree[Object]>*/
1634 }
1635 var = var_tree;
1636 goto RET_LABEL;
1637 RET_LABEL:;
1638 return var;
1639 }
1640 /* method rapid_type_analysis$RapidTypeAnalysis$totry_methods for (self: RapidTypeAnalysis): HashSet[MMethod] */
1641 val* nitc___nitc__RapidTypeAnalysis___totry_methods(val* self) {
1642 val* var /* : HashSet[MMethod] */;
1643 val* var1 /* : HashSet[MMethod] */;
1644 var1 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___totry_methods].val; /* _totry_methods on <self:RapidTypeAnalysis> */
1645 if (unlikely(var1 == NULL)) {
1646 if(catchStack.cursor >= 0){
1647 longjmp(catchStack.envs[catchStack.cursor], 1);
1648 }
1649 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _totry_methods");
1650 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 173);
1651 fatal_exit(1);
1652 }
1653 var = var1;
1654 RET_LABEL:;
1655 return var;
1656 }
1657 /* method rapid_type_analysis$RapidTypeAnalysis$totry_methods_to_remove for (self: RapidTypeAnalysis): Array[MMethod] */
1658 val* nitc___nitc__RapidTypeAnalysis___totry_methods_to_remove(val* self) {
1659 val* var /* : Array[MMethod] */;
1660 val* var1 /* : Array[MMethod] */;
1661 var1 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___totry_methods_to_remove].val; /* _totry_methods_to_remove on <self:RapidTypeAnalysis> */
1662 if (unlikely(var1 == NULL)) {
1663 if(catchStack.cursor >= 0){
1664 longjmp(catchStack.envs[catchStack.cursor], 1);
1665 }
1666 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _totry_methods_to_remove");
1667 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 176);
1668 fatal_exit(1);
1669 }
1670 var = var1;
1671 RET_LABEL:;
1672 return var;
1673 }
1674 /* method rapid_type_analysis$RapidTypeAnalysis$try_methods for (self: RapidTypeAnalysis): HashSet[MMethod] */
1675 val* nitc___nitc__RapidTypeAnalysis___try_methods(val* self) {
1676 val* var /* : HashSet[MMethod] */;
1677 val* var1 /* : HashSet[MMethod] */;
1678 var1 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___try_methods].val; /* _try_methods on <self:RapidTypeAnalysis> */
1679 if (unlikely(var1 == NULL)) {
1680 if(catchStack.cursor >= 0){
1681 longjmp(catchStack.envs[catchStack.cursor], 1);
1682 }
1683 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _try_methods");
1684 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 179);
1685 fatal_exit(1);
1686 }
1687 var = var1;
1688 RET_LABEL:;
1689 return var;
1690 }
1691 /* method rapid_type_analysis$RapidTypeAnalysis$todo for (self: RapidTypeAnalysis): List[MMethodDef] */
1692 val* nitc___nitc__RapidTypeAnalysis___todo(val* self) {
1693 val* var /* : List[MMethodDef] */;
1694 val* var1 /* : List[MMethodDef] */;
1695 var1 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___todo].val; /* _todo on <self:RapidTypeAnalysis> */
1696 if (unlikely(var1 == NULL)) {
1697 if(catchStack.cursor >= 0){
1698 longjmp(catchStack.envs[catchStack.cursor], 1);
1699 }
1700 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _todo");
1701 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 183);
1702 fatal_exit(1);
1703 }
1704 var = var1;
1705 RET_LABEL:;
1706 return var;
1707 }
1708 /* method rapid_type_analysis$RapidTypeAnalysis$force_alive for (self: RapidTypeAnalysis, String) */
1709 void nitc___nitc__RapidTypeAnalysis___force_alive(val* self, val* p0) {
1710 val* var_classname /* var classname: String */;
1711 val* var /* : ModelBuilder */;
1712 val* var2 /* : ModelBuilder */;
1713 val* var3 /* : Model */;
1714 val* var5 /* : Model */;
1715 val* var6 /* : nullable Array[MClass] */;
1716 val* var_classes /* var classes: nullable Array[MClass] */;
1717 short int var7 /* : Bool */;
1718 short int var8 /* : Bool */;
1719 val* var_other /* var other: nullable Object */;
1720 short int var10 /* : Bool */;
1721 short int var11 /* : Bool */;
1722 val* var_ /* var : Array[MClass] */;
1723 val* var12 /* : IndexedIterator[nullable Object] */;
1724 val* var_13 /* var : IndexedIterator[MClass] */;
1725 short int var14 /* : Bool */;
1726 val* var15 /* : nullable Object */;
1727 val* var_c /* var c: MClass */;
1728 val* var16 /* : MClassType */;
1729 val* var18 /* : MClassType */;
1730 val* var19 /* : MClassType */;
1731 val* var21 /* : MClassType */;
1732 var_classname = p0;
1733 {
1734 { /* Inline rapid_type_analysis$RapidTypeAnalysis$modelbuilder (self) on <self:RapidTypeAnalysis> */
1735 var2 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___modelbuilder].val; /* _modelbuilder on <self:RapidTypeAnalysis> */
1736 if (unlikely(var2 == NULL)) {
1737 if(catchStack.cursor >= 0){
1738 longjmp(catchStack.envs[catchStack.cursor], 1);
1739 }
1740 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder");
1741 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 53);
1742 fatal_exit(1);
1743 }
1744 var = var2;
1745 RET_LABEL1:(void)0;
1746 }
1747 }
1748 {
1749 { /* Inline modelbuilder_base$ModelBuilder$model (var) on <var:ModelBuilder> */
1750 var5 = var->attrs[COLOR_nitc__modelbuilder_base__ModelBuilder___model].val; /* _model on <var:ModelBuilder> */
1751 if (unlikely(var5 == NULL)) {
1752 if(catchStack.cursor >= 0){
1753 longjmp(catchStack.envs[catchStack.cursor], 1);
1754 }
1755 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _model");
1756 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__modelbuilder_base, 44);
1757 fatal_exit(1);
1758 }
1759 var3 = var5;
1760 RET_LABEL4:(void)0;
1761 }
1762 }
1763 {
1764 var6 = nitc__model___Model___get_mclasses_by_name(var3, var_classname);
1765 }
1766 var_classes = var6;
1767 if (var_classes == NULL) {
1768 var7 = 0; /* is null */
1769 } else {
1770 var7 = 1; /* arg is null and recv is not */
1771 }
1772 if (0) {
1773 { /* Inline kernel$Object$!= (var_classes,((val*)NULL)) on <var_classes:nullable Array[MClass]> */
1774 var_other = ((val*)NULL);
1775 {
1776 var10 = ((short int(*)(val* self, val* p0))(var_classes->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_classes, var_other); /* == on <var_classes:nullable Array[MClass](Array[MClass])>*/
1777 }
1778 var11 = !var10;
1779 var8 = var11;
1780 goto RET_LABEL9;
1781 RET_LABEL9:(void)0;
1782 }
1783 var7 = var8;
1784 }
1785 if (var7){
1786 var_ = var_classes;
1787 {
1788 var12 = core___core__AbstractArrayRead___core__abstract_collection__Collection__iterator(var_);
1789 }
1790 var_13 = var12;
1791 for(;;) {
1792 {
1793 var14 = ((short int(*)(val* self))((((long)var_13&3)?class_info[((long)var_13&3)]:var_13->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_13); /* is_ok on <var_13:IndexedIterator[MClass]>*/
1794 }
1795 if (var14){
1796 } else {
1797 goto BREAK_label;
1798 }
1799 {
1800 var15 = ((val*(*)(val* self))((((long)var_13&3)?class_info[((long)var_13&3)]:var_13->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_13); /* item on <var_13:IndexedIterator[MClass]>*/
1801 }
1802 var_c = var15;
1803 {
1804 { /* Inline model$MClass$mclass_type (var_c) on <var_c:MClass> */
1805 var18 = var_c->attrs[COLOR_nitc__model__MClass___mclass_type].val; /* _mclass_type on <var_c:MClass> */
1806 if (unlikely(var18 == NULL)) {
1807 if(catchStack.cursor >= 0){
1808 longjmp(catchStack.envs[catchStack.cursor], 1);
1809 }
1810 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type");
1811 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 520);
1812 fatal_exit(1);
1813 }
1814 var16 = var18;
1815 RET_LABEL17:(void)0;
1816 }
1817 }
1818 {
1819 { /* Inline model$MClass$mclass_type (var_c) on <var_c:MClass> */
1820 var21 = var_c->attrs[COLOR_nitc__model__MClass___mclass_type].val; /* _mclass_type on <var_c:MClass> */
1821 if (unlikely(var21 == NULL)) {
1822 if(catchStack.cursor >= 0){
1823 longjmp(catchStack.envs[catchStack.cursor], 1);
1824 }
1825 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass_type");
1826 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 520);
1827 fatal_exit(1);
1828 }
1829 var19 = var21;
1830 RET_LABEL20:(void)0;
1831 }
1832 }
1833 {
1834 nitc___nitc__RapidTypeAnalysis___add_new(self, var16, var19); /* Direct call rapid_type_analysis$RapidTypeAnalysis$add_new on <self:RapidTypeAnalysis>*/
1835 }
1836 {
1837 ((void(*)(val* self))((((long)var_13&3)?class_info[((long)var_13&3)]:var_13->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_13); /* next on <var_13:IndexedIterator[MClass]>*/
1838 }
1839 }
1840 BREAK_label: (void)0;
1841 {
1842 ((void(*)(val* self))((((long)var_13&3)?class_info[((long)var_13&3)]:var_13->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_13); /* finish on <var_13:IndexedIterator[MClass]>*/
1843 }
1844 } else {
1845 }
1846 RET_LABEL:;
1847 }
1848 /* method rapid_type_analysis$RapidTypeAnalysis$run_analysis for (self: RapidTypeAnalysis) */
1849 void nitc___nitc__RapidTypeAnalysis___run_analysis(val* self) {
1850 val* var /* : MModule */;
1851 val* var2 /* : MModule */;
1852 val* var3 /* : nullable MClassType */;
1853 val* var_maintype /* var maintype: nullable MClassType */;
1854 short int var4 /* : Bool */;
1855 short int var5 /* : Bool */;
1856 val* var_other /* var other: nullable Object */;
1857 short int var7 /* : Bool */;
1858 short int var9 /* : Bool */;
1859 val* var10 /* : MModule */;
1860 val* var12 /* : MModule */;
1861 static val* varonce;
1862 val* var13 /* : String */;
1863 char* var14 /* : CString */;
1864 val* var15 /* : String */;
1865 val* var16 /* : nullable Int */;
1866 val* var17 /* : nullable Int */;
1867 val* var18 /* : nullable Bool */;
1868 val* var19 /* : nullable Bool */;
1869 val* var20 /* : MClass */;
1870 val* var22 /* : MClass */;
1871 val* var23 /* : nullable MMethod */;
1872 val* var_initprop /* var initprop: nullable MMethod */;
1873 short int var24 /* : Bool */;
1874 short int var25 /* : Bool */;
1875 val* var_other27 /* var other: nullable Object */;
1876 short int var28 /* : Bool */;
1877 short int var29 /* : Bool */;
1878 val* var30 /* : nullable MMethod */;
1879 val* var31 /* : MModule */;
1880 val* var33 /* : MModule */;
1881 static val* varonce34;
1882 val* var35 /* : String */;
1883 char* var36 /* : CString */;
1884 val* var37 /* : String */;
1885 val* var38 /* : nullable Int */;
1886 val* var39 /* : nullable Int */;
1887 val* var40 /* : nullable Bool */;
1888 val* var41 /* : nullable Bool */;
1889 val* var42 /* : MClass */;
1890 val* var44 /* : MClass */;
1891 val* var45 /* : nullable MMethod */;
1892 val* var46 /* : MModule */;
1893 val* var48 /* : MModule */;
1894 static val* varonce49;
1895 val* var50 /* : String */;
1896 char* var51 /* : CString */;
1897 val* var52 /* : String */;
1898 val* var53 /* : nullable Int */;
1899 val* var54 /* : nullable Int */;
1900 val* var55 /* : nullable Bool */;
1901 val* var56 /* : nullable Bool */;
1902 val* var57 /* : MClass */;
1903 val* var59 /* : MClass */;
1904 val* var60 /* : nullable MMethod */;
1905 val* var_mainprop /* var mainprop: nullable MMethod */;
1906 short int var61 /* : Bool */;
1907 short int var62 /* : Bool */;
1908 short int var64 /* : Bool */;
1909 short int var65 /* : Bool */;
1910 val* var66 /* : MModule */;
1911 val* var68 /* : MModule */;
1912 val* var69 /* : nullable MClassType */;
1913 val* var_finalizable_type /* var finalizable_type: nullable MClassType */;
1914 short int var70 /* : Bool */;
1915 short int var71 /* : Bool */;
1916 short int var73 /* : Bool */;
1917 short int var74 /* : Bool */;
1918 val* var75 /* : MModule */;
1919 val* var77 /* : MModule */;
1920 static val* varonce78;
1921 val* var79 /* : String */;
1922 char* var80 /* : CString */;
1923 val* var81 /* : String */;
1924 val* var82 /* : nullable Int */;
1925 val* var83 /* : nullable Int */;
1926 val* var84 /* : nullable Bool */;
1927 val* var85 /* : nullable Bool */;
1928 val* var86 /* : MClass */;
1929 val* var88 /* : MClass */;
1930 val* var89 /* : nullable MMethod */;
1931 val* var_finalize_meth /* var finalize_meth: nullable MMethod */;
1932 short int var90 /* : Bool */;
1933 short int var91 /* : Bool */;
1934 short int var93 /* : Bool */;
1935 short int var94 /* : Bool */;
1936 static val* varonce95;
1937 val* var96 /* : String */;
1938 char* var97 /* : CString */;
1939 val* var98 /* : String */;
1940 val* var99 /* : nullable Int */;
1941 val* var100 /* : nullable Int */;
1942 val* var101 /* : nullable Bool */;
1943 val* var102 /* : nullable Bool */;
1944 static val* varonce103;
1945 val* var104 /* : String */;
1946 char* var105 /* : CString */;
1947 val* var106 /* : String */;
1948 val* var107 /* : nullable Int */;
1949 val* var108 /* : nullable Int */;
1950 val* var109 /* : nullable Bool */;
1951 val* var110 /* : nullable Bool */;
1952 static val* varonce111;
1953 val* var112 /* : String */;
1954 char* var113 /* : CString */;
1955 val* var114 /* : String */;
1956 val* var115 /* : nullable Int */;
1957 val* var116 /* : nullable Int */;
1958 val* var117 /* : nullable Bool */;
1959 val* var118 /* : nullable Bool */;
1960 static val* varonce119;
1961 val* var120 /* : String */;
1962 char* var121 /* : CString */;
1963 val* var122 /* : String */;
1964 val* var123 /* : nullable Int */;
1965 val* var124 /* : nullable Int */;
1966 val* var125 /* : nullable Bool */;
1967 val* var126 /* : nullable Bool */;
1968 static val* varonce127;
1969 val* var128 /* : String */;
1970 char* var129 /* : CString */;
1971 val* var130 /* : String */;
1972 val* var131 /* : nullable Int */;
1973 val* var132 /* : nullable Int */;
1974 val* var133 /* : nullable Bool */;
1975 val* var134 /* : nullable Bool */;
1976 static val* varonce135;
1977 val* var136 /* : String */;
1978 char* var137 /* : CString */;
1979 val* var138 /* : String */;
1980 val* var139 /* : nullable Int */;
1981 val* var140 /* : nullable Int */;
1982 val* var141 /* : nullable Bool */;
1983 val* var142 /* : nullable Bool */;
1984 static val* varonce143;
1985 val* var144 /* : String */;
1986 char* var145 /* : CString */;
1987 val* var146 /* : String */;
1988 val* var147 /* : nullable Int */;
1989 val* var148 /* : nullable Int */;
1990 val* var149 /* : nullable Bool */;
1991 val* var150 /* : nullable Bool */;
1992 static val* varonce151;
1993 val* var152 /* : String */;
1994 char* var153 /* : CString */;
1995 val* var154 /* : String */;
1996 val* var155 /* : nullable Int */;
1997 val* var156 /* : nullable Int */;
1998 val* var157 /* : nullable Bool */;
1999 val* var158 /* : nullable Bool */;
2000 static val* varonce159;
2001 val* var160 /* : String */;
2002 char* var161 /* : CString */;
2003 val* var162 /* : String */;
2004 val* var163 /* : nullable Int */;
2005 val* var164 /* : nullable Int */;
2006 val* var165 /* : nullable Bool */;
2007 val* var166 /* : nullable Bool */;
2008 static val* varonce167;
2009 val* var168 /* : String */;
2010 char* var169 /* : CString */;
2011 val* var170 /* : String */;
2012 val* var171 /* : nullable Int */;
2013 val* var172 /* : nullable Int */;
2014 val* var173 /* : nullable Bool */;
2015 val* var174 /* : nullable Bool */;
2016 static val* varonce175;
2017 val* var176 /* : String */;
2018 char* var177 /* : CString */;
2019 val* var178 /* : String */;
2020 val* var179 /* : nullable Int */;
2021 val* var180 /* : nullable Int */;
2022 val* var181 /* : nullable Bool */;
2023 val* var182 /* : nullable Bool */;
2024 val* var183 /* : List[MMethodDef] */;
2025 val* var185 /* : List[MMethodDef] */;
2026 short int var186 /* : Bool */;
2027 short int var187 /* : Bool */;
2028 val* var188 /* : List[MMethodDef] */;
2029 val* var190 /* : List[MMethodDef] */;
2030 val* var191 /* : nullable Object */;
2031 val* var_mmethoddef /* var mmethoddef: MMethodDef */;
2032 val* var192 /* : MProperty */;
2033 val* var194 /* : MProperty */;
2034 val* var_mmeth /* var mmeth: MMethod */;
2035 val* var195 /* : nullable MSignature */;
2036 val* var197 /* : nullable MSignature */;
2037 val* var_msignature /* var msignature: nullable MSignature */;
2038 short int var198 /* : Bool */;
2039 short int var199 /* : Bool */;
2040 short int var201 /* : Bool */;
2041 short int var203 /* : Bool */;
2042 val* var204 /* : RapidTypeVisitor */;
2043 val* var205 /* : MClassDef */;
2044 val* var207 /* : MClassDef */;
2045 val* var208 /* : MClassType */;
2046 val* var210 /* : MClassType */;
2047 val* var_v /* var v: RapidTypeVisitor */;
2048 long var211 /* : Int */;
2049 long var213 /* : Int */;
2050 long var_vararg_rank /* var vararg_rank: Int */;
2051 long var214 /* : Int */;
2052 long var216 /* : Int */;
2053 short int var217 /* : Bool */;
2054 short int var219 /* : Bool */;
2055 int cltype;
2056 int idtype;
2057 const char* var_class_name;
2058 short int var220 /* : Bool */;
2059 val* var221 /* : ModelBuilder */;
2060 val* var223 /* : ModelBuilder */;
2061 val* var224 /* : nullable ANode */;
2062 val* var_node /* var node: nullable ANode */;
2063 val* var225 /* : Array[MParameter] */;
2064 val* var227 /* : Array[MParameter] */;
2065 val* var228 /* : nullable Object */;
2066 val* var229 /* : MType */;
2067 val* var231 /* : MType */;
2068 val* var_elttype /* var elttype: MType */;
2069 val* var232 /* : MModule */;
2070 val* var234 /* : MModule */;
2071 val* var235 /* : MClassType */;
2072 val* var_vararg /* var vararg: MClassType */;
2073 val* var236 /* : MModule */;
2074 val* var238 /* : MModule */;
2075 val* var239 /* : MClassType */;
2076 val* var_native /* var native: MClassType */;
2077 val* var240 /* : ModelBuilder */;
2078 val* var242 /* : ModelBuilder */;
2079 static val* varonce243;
2080 val* var244 /* : String */;
2081 char* var245 /* : CString */;
2082 val* var246 /* : String */;
2083 val* var247 /* : nullable Int */;
2084 val* var248 /* : nullable Int */;
2085 val* var249 /* : nullable Bool */;
2086 val* var250 /* : nullable Bool */;
2087 val* var251 /* : MClass */;
2088 val* var253 /* : MClass */;
2089 val* var254 /* : MModule */;
2090 val* var256 /* : MModule */;
2091 val* var257 /* : MMethod */;
2092 val* var_sig /* var sig: MSignature */;
2093 val* var258 /* : MPropDef */;
2094 val* var260 /* : MPropDef */;
2095 val* var261 /* : nullable MSignature */;
2096 val* var263 /* : nullable MSignature */;
2097 val* var_osig /* var osig: MSignature */;
2098 long var_i /* var i: Int */;
2099 long var264 /* : Int */;
2100 long var_ /* var : Int */;
2101 short int var265 /* : Bool */;
2102 short int var267 /* : Bool */;
2103 int cltype268;
2104 int idtype269;
2105 const char* var_class_name270;
2106 short int var271 /* : Bool */;
2107 val* var273 /* : Array[MParameter] */;
2108 val* var275 /* : Array[MParameter] */;
2109 val* var276 /* : nullable Object */;
2110 val* var277 /* : MType */;
2111 val* var279 /* : MType */;
2112 val* var_origtype /* var origtype: MType */;
2113 short int var280 /* : Bool */;
2114 short int var281 /* : Bool */;
2115 val* var283 /* : Array[MParameter] */;
2116 val* var285 /* : Array[MParameter] */;
2117 val* var286 /* : nullable Object */;
2118 val* var287 /* : MType */;
2119 val* var289 /* : MType */;
2120 val* var_paramtype /* var paramtype: MType */;
2121 long var290 /* : Int */;
2122 short int var291 /* : Bool */;
2123 short int var293 /* : Bool */;
2124 val* var294 /* : ModelBuilder */;
2125 val* var296 /* : ModelBuilder */;
2126 val* var297 /* : nullable ANode */;
2127 val* var_npropdef /* var npropdef: nullable ANode */;
2128 short int var298 /* : Bool */;
2129 int cltype299;
2130 int idtype300;
2131 val* var301 /* : MProperty */;
2132 val* var303 /* : MProperty */;
2133 short int var304 /* : Bool */;
2134 short int var306 /* : Bool */;
2135 short int var307 /* : Bool */;
2136 short int var308 /* : Bool */;
2137 val* var309 /* : MClassType */;
2138 val* var311 /* : MClassType */;
2139 val* var313 /* : NativeArray[String] */;
2140 static val* varonce312;
2141 static val* varonce314;
2142 val* var315 /* : String */;
2143 char* var316 /* : CString */;
2144 val* var317 /* : String */;
2145 val* var318 /* : nullable Int */;
2146 val* var319 /* : nullable Int */;
2147 val* var320 /* : nullable Bool */;
2148 val* var321 /* : nullable Bool */;
2149 val* var322 /* : String */;
2150 val* var323 /* : String */;
2151 val* var324 /* : nullable Object */;
2152 val* var326 /* : nullable Object */;
2153 short int var327 /* : Bool */;
2154 short int var328 /* : Bool */;
2155 val* var329 /* : nullable MType */;
2156 val* var331 /* : nullable MType */;
2157 short int var332 /* : Bool */;
2158 int cltype333;
2159 int idtype334;
2160 const char* var_class_name335;
2161 short int var336 /* : Bool */;
2162 short int var337 /* : Bool */;
2163 short int var339 /* : Bool */;
2164 short int var341 /* : Bool */;
2165 short int var342 /* : Bool */;
2166 int cltype343;
2167 int idtype344;
2168 val* var345 /* : nullable Array[CallSite] */;
2169 val* var347 /* : nullable Array[CallSite] */;
2170 val* var_auto_super_inits /* var auto_super_inits: nullable Array[CallSite] */;
2171 short int var348 /* : Bool */;
2172 short int var349 /* : Bool */;
2173 short int var351 /* : Bool */;
2174 short int var352 /* : Bool */;
2175 val* var_353 /* var : Array[CallSite] */;
2176 val* var354 /* : IndexedIterator[nullable Object] */;
2177 val* var_355 /* var : IndexedIterator[CallSite] */;
2178 short int var356 /* : Bool */;
2179 val* var358 /* : nullable Object */;
2180 val* var_auto_super_init /* var auto_super_init: CallSite */;
2181 short int var359 /* : Bool */;
2182 short int var361 /* : Bool */;
2183 val* var362 /* : MClassType */;
2184 val* var364 /* : MClassType */;
2185 short int var365 /* : Bool */;
2186 short int var366 /* : Bool */;
2187 short int var368 /* : Bool */;
2188 short int var_369 /* var : Bool */;
2189 short int var370 /* : Bool */;
2190 short int var372 /* : Bool */;
2191 val* var373 /* : nullable MType */;
2192 val* var375 /* : nullable MType */;
2193 val* var_ret /* var ret: nullable MType */;
2194 short int var376 /* : Bool */;
2195 short int var377 /* : Bool */;
2196 short int var378 /* : Bool */;
2197 short int var379 /* : Bool */;
2198 short int var380 /* : Bool */;
2199 short int var382 /* : Bool */;
2200 short int var383 /* : Bool */;
2201 short int var_384 /* var : Bool */;
2202 short int var385 /* : Bool */;
2203 int cltype386;
2204 int idtype387;
2205 short int var_388 /* var : Bool */;
2206 val* var389 /* : MClass */;
2207 val* var391 /* : MClass */;
2208 val* var392 /* : MClassKind */;
2209 val* var394 /* : MClassKind */;
2210 val* var395 /* : Sys */;
2211 val* var396 /* : MClassKind */;
2212 short int var397 /* : Bool */;
2213 short int var399 /* : Bool */;
2214 short int var400 /* : Bool */;
2215 short int var_401 /* var : Bool */;
2216 val* var402 /* : MClass */;
2217 val* var404 /* : MClass */;
2218 val* var405 /* : MClassKind */;
2219 val* var407 /* : MClassKind */;
2220 val* var408 /* : Sys */;
2221 val* var409 /* : MClassKind */;
2222 short int var410 /* : Bool */;
2223 short int var412 /* : Bool */;
2224 short int var413 /* : Bool */;
2225 val* var415 /* : List[MClassType] */;
2226 val* var_todo_types /* var todo_types: List[MClassType] */;
2227 val* var417 /* : HashSet[MClassType] */;
2228 val* var419 /* : HashSet[MClassType] */;
2229 short int var420 /* : Bool */;
2230 short int var421 /* : Bool */;
2231 val* var422 /* : nullable Object */;
2232 val* var_t /* var t: MClassType */;
2233 val* var423 /* : HashSet[MClassType] */;
2234 val* var425 /* : HashSet[MClassType] */;
2235 val* var_426 /* var : HashSet[MClassType] */;
2236 val* var427 /* : Iterator[nullable Object] */;
2237 val* var_428 /* var : Iterator[MClassType] */;
2238 short int var429 /* : Bool */;
2239 val* var431 /* : nullable Object */;
2240 val* var_ot /* var ot: MClassType */;
2241 val* var432 /* : MModule */;
2242 val* var434 /* : MModule */;
2243 short int var435 /* : Bool */;
2244 short int var436 /* : Bool */;
2245 val* var438 /* : MModule */;
2246 val* var440 /* : MModule */;
2247 val* var441 /* : MClassType */;
2248 val* var_rt /* var rt: MClassType */;
2249 val* var442 /* : HashSet[MClassType] */;
2250 val* var444 /* : HashSet[MClassType] */;
2251 short int var445 /* : Bool */;
2252 val* var446 /* : MModule */;
2253 val* var448 /* : MModule */;
2254 short int var449 /* : Bool */;
2255 short int var450 /* : Bool */;
2256 short int var451 /* : Bool */;
2257 short int var452 /* : Bool */;
2258 val* var453 /* : HashSet[MClassType] */;
2259 val* var455 /* : HashSet[MClassType] */;
2260 val* var457 /* : HashSet[MType] */;
2261 val* var459 /* : HashSet[MType] */;
2262 val* var_460 /* var : HashSet[MType] */;
2263 val* var461 /* : Iterator[nullable Object] */;
2264 val* var_462 /* var : Iterator[MType] */;
2265 short int var463 /* : Bool */;
2266 val* var465 /* : nullable Object */;
2267 val* var_ot466 /* var ot: MType */;
2268 val* var467 /* : HashSet[MClassType] */;
2269 val* var469 /* : HashSet[MClassType] */;
2270 val* var_470 /* var : HashSet[MClassType] */;
2271 val* var471 /* : Iterator[nullable Object] */;
2272 val* var_472 /* var : Iterator[MClassType] */;
2273 short int var473 /* : Bool */;
2274 val* var475 /* : nullable Object */;
2275 val* var_t476 /* var t: MClassType */;
2276 val* var477 /* : MModule */;
2277 val* var479 /* : MModule */;
2278 short int var480 /* : Bool */;
2279 short int var481 /* : Bool */;
2280 val* var483 /* : MModule */;
2281 val* var485 /* : MModule */;
2282 val* var486 /* : MType */;
2283 val* var_rt487 /* var rt: MType */;
2284 val* var488 /* : MModule */;
2285 val* var490 /* : MModule */;
2286 short int var491 /* : Bool */;
2287 short int var492 /* : Bool */;
2288 val* var493 /* : HashSet[MType] */;
2289 val* var495 /* : HashSet[MType] */;
2290 {
2291 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
2292 var2 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
2293 if (unlikely(var2 == NULL)) {
2294 if(catchStack.cursor >= 0){
2295 longjmp(catchStack.envs[catchStack.cursor], 1);
2296 }
2297 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
2298 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
2299 fatal_exit(1);
2300 }
2301 var = var2;
2302 RET_LABEL1:(void)0;
2303 }
2304 }
2305 {
2306 var3 = nitc__model___MModule___sys_type(var);
2307 }
2308 var_maintype = var3;
2309 if (var_maintype == NULL) {
2310 var4 = 1; /* is null */
2311 } else {
2312 var4 = 0; /* arg is null but recv is not */
2313 }
2314 if (0) {
2315 { /* Inline kernel$Object$== (var_maintype,((val*)NULL)) on <var_maintype:nullable MClassType> */
2316 var_other = ((val*)NULL);
2317 {
2318 { /* Inline kernel$Object$is_same_instance (var_maintype,var_other) on <var_maintype:nullable MClassType(MClassType)> */
2319 var9 = var_maintype == var_other;
2320 var7 = var9;
2321 goto RET_LABEL8;
2322 RET_LABEL8:(void)0;
2323 }
2324 }
2325 var5 = var7;
2326 goto RET_LABEL6;
2327 RET_LABEL6:(void)0;
2328 }
2329 var4 = var5;
2330 }
2331 if (var4){
2332 goto RET_LABEL;
2333 } else {
2334 }
2335 {
2336 nitc___nitc__RapidTypeAnalysis___add_new(self, var_maintype, var_maintype); /* Direct call rapid_type_analysis$RapidTypeAnalysis$add_new on <self:RapidTypeAnalysis>*/
2337 }
2338 {
2339 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
2340 var12 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
2341 if (unlikely(var12 == NULL)) {
2342 if(catchStack.cursor >= 0){
2343 longjmp(catchStack.envs[catchStack.cursor], 1);
2344 }
2345 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
2346 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
2347 fatal_exit(1);
2348 }
2349 var10 = var12;
2350 RET_LABEL11:(void)0;
2351 }
2352 }
2353 if (likely(varonce!=NULL)) {
2354 var13 = varonce;
2355 } else {
2356 var14 = "init";
2357 var16 = (val*)(4l<<2|1);
2358 var17 = (val*)(4l<<2|1);
2359 var18 = (val*)((long)(0)<<2|3);
2360 var19 = (val*)((long)(0)<<2|3);
2361 var15 = core__flat___CString___to_s_unsafe(var14, var16, var17, var18, var19);
2362 var13 = var15;
2363 varonce = var13;
2364 }
2365 {
2366 { /* Inline model$MClassType$mclass (var_maintype) on <var_maintype:nullable MClassType(MClassType)> */
2367 var22 = var_maintype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on <var_maintype:nullable MClassType(MClassType)> */
2368 if (unlikely(var22 == NULL)) {
2369 if(catchStack.cursor >= 0){
2370 longjmp(catchStack.envs[catchStack.cursor], 1);
2371 }
2372 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
2373 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197);
2374 fatal_exit(1);
2375 }
2376 var20 = var22;
2377 RET_LABEL21:(void)0;
2378 }
2379 }
2380 {
2381 var23 = nitc__model___MModule___try_get_primitive_method(var10, var13, var20);
2382 }
2383 var_initprop = var23;
2384 if (var_initprop == NULL) {
2385 var24 = 0; /* is null */
2386 } else {
2387 var24 = 1; /* arg is null and recv is not */
2388 }
2389 if (0) {
2390 { /* Inline kernel$Object$!= (var_initprop,((val*)NULL)) on <var_initprop:nullable MMethod> */
2391 var_other27 = ((val*)NULL);
2392 {
2393 var28 = ((short int(*)(val* self, val* p0))(var_initprop->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_initprop, var_other27); /* == on <var_initprop:nullable MMethod(MMethod)>*/
2394 }
2395 var29 = !var28;
2396 var25 = var29;
2397 goto RET_LABEL26;
2398 RET_LABEL26:(void)0;
2399 }
2400 var24 = var25;
2401 }
2402 if (var24){
2403 {
2404 nitc___nitc__RapidTypeAnalysis___add_send(self, var_maintype, var_initprop); /* Direct call rapid_type_analysis$RapidTypeAnalysis$add_send on <self:RapidTypeAnalysis>*/
2405 }
2406 } else {
2407 }
2408 {
2409 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
2410 var33 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
2411 if (unlikely(var33 == NULL)) {
2412 if(catchStack.cursor >= 0){
2413 longjmp(catchStack.envs[catchStack.cursor], 1);
2414 }
2415 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
2416 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
2417 fatal_exit(1);
2418 }
2419 var31 = var33;
2420 RET_LABEL32:(void)0;
2421 }
2422 }
2423 if (likely(varonce34!=NULL)) {
2424 var35 = varonce34;
2425 } else {
2426 var36 = "run";
2427 var38 = (val*)(3l<<2|1);
2428 var39 = (val*)(3l<<2|1);
2429 var40 = (val*)((long)(0)<<2|3);
2430 var41 = (val*)((long)(0)<<2|3);
2431 var37 = core__flat___CString___to_s_unsafe(var36, var38, var39, var40, var41);
2432 var35 = var37;
2433 varonce34 = var35;
2434 }
2435 {
2436 { /* Inline model$MClassType$mclass (var_maintype) on <var_maintype:nullable MClassType(MClassType)> */
2437 var44 = var_maintype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on <var_maintype:nullable MClassType(MClassType)> */
2438 if (unlikely(var44 == NULL)) {
2439 if(catchStack.cursor >= 0){
2440 longjmp(catchStack.envs[catchStack.cursor], 1);
2441 }
2442 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
2443 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197);
2444 fatal_exit(1);
2445 }
2446 var42 = var44;
2447 RET_LABEL43:(void)0;
2448 }
2449 }
2450 {
2451 var45 = nitc__model___MModule___try_get_primitive_method(var31, var35, var42);
2452 }
2453 if (var45!=NULL) {
2454 var30 = var45;
2455 } else {
2456 {
2457 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
2458 var48 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
2459 if (unlikely(var48 == NULL)) {
2460 if(catchStack.cursor >= 0){
2461 longjmp(catchStack.envs[catchStack.cursor], 1);
2462 }
2463 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
2464 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
2465 fatal_exit(1);
2466 }
2467 var46 = var48;
2468 RET_LABEL47:(void)0;
2469 }
2470 }
2471 if (likely(varonce49!=NULL)) {
2472 var50 = varonce49;
2473 } else {
2474 var51 = "main";
2475 var53 = (val*)(4l<<2|1);
2476 var54 = (val*)(4l<<2|1);
2477 var55 = (val*)((long)(0)<<2|3);
2478 var56 = (val*)((long)(0)<<2|3);
2479 var52 = core__flat___CString___to_s_unsafe(var51, var53, var54, var55, var56);
2480 var50 = var52;
2481 varonce49 = var50;
2482 }
2483 {
2484 { /* Inline model$MClassType$mclass (var_maintype) on <var_maintype:nullable MClassType(MClassType)> */
2485 var59 = var_maintype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on <var_maintype:nullable MClassType(MClassType)> */
2486 if (unlikely(var59 == NULL)) {
2487 if(catchStack.cursor >= 0){
2488 longjmp(catchStack.envs[catchStack.cursor], 1);
2489 }
2490 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
2491 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197);
2492 fatal_exit(1);
2493 }
2494 var57 = var59;
2495 RET_LABEL58:(void)0;
2496 }
2497 }
2498 {
2499 var60 = nitc__model___MModule___try_get_primitive_method(var46, var50, var57);
2500 }
2501 var30 = var60;
2502 }
2503 var_mainprop = var30;
2504 if (var_mainprop == NULL) {
2505 var61 = 0; /* is null */
2506 } else {
2507 var61 = 1; /* arg is null and recv is not */
2508 }
2509 if (0) {
2510 { /* Inline kernel$Object$!= (var_mainprop,((val*)NULL)) on <var_mainprop:nullable MMethod> */
2511 var_other27 = ((val*)NULL);
2512 {
2513 var64 = ((short int(*)(val* self, val* p0))(var_mainprop->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_mainprop, var_other27); /* == on <var_mainprop:nullable MMethod(MMethod)>*/
2514 }
2515 var65 = !var64;
2516 var62 = var65;
2517 goto RET_LABEL63;
2518 RET_LABEL63:(void)0;
2519 }
2520 var61 = var62;
2521 }
2522 if (var61){
2523 {
2524 nitc___nitc__RapidTypeAnalysis___add_send(self, var_maintype, var_mainprop); /* Direct call rapid_type_analysis$RapidTypeAnalysis$add_send on <self:RapidTypeAnalysis>*/
2525 }
2526 } else {
2527 }
2528 {
2529 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
2530 var68 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
2531 if (unlikely(var68 == NULL)) {
2532 if(catchStack.cursor >= 0){
2533 longjmp(catchStack.envs[catchStack.cursor], 1);
2534 }
2535 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
2536 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
2537 fatal_exit(1);
2538 }
2539 var66 = var68;
2540 RET_LABEL67:(void)0;
2541 }
2542 }
2543 {
2544 var69 = nitc__model___MModule___finalizable_type(var66);
2545 }
2546 var_finalizable_type = var69;
2547 if (var_finalizable_type == NULL) {
2548 var70 = 0; /* is null */
2549 } else {
2550 var70 = 1; /* arg is null and recv is not */
2551 }
2552 if (0) {
2553 { /* Inline kernel$Object$!= (var_finalizable_type,((val*)NULL)) on <var_finalizable_type:nullable MClassType> */
2554 var_other27 = ((val*)NULL);
2555 {
2556 var73 = ((short int(*)(val* self, val* p0))(var_finalizable_type->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_finalizable_type, var_other27); /* == on <var_finalizable_type:nullable MClassType(MClassType)>*/
2557 }
2558 var74 = !var73;
2559 var71 = var74;
2560 goto RET_LABEL72;
2561 RET_LABEL72:(void)0;
2562 }
2563 var70 = var71;
2564 }
2565 if (var70){
2566 {
2567 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
2568 var77 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
2569 if (unlikely(var77 == NULL)) {
2570 if(catchStack.cursor >= 0){
2571 longjmp(catchStack.envs[catchStack.cursor], 1);
2572 }
2573 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
2574 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
2575 fatal_exit(1);
2576 }
2577 var75 = var77;
2578 RET_LABEL76:(void)0;
2579 }
2580 }
2581 if (likely(varonce78!=NULL)) {
2582 var79 = varonce78;
2583 } else {
2584 var80 = "finalize";
2585 var82 = (val*)(8l<<2|1);
2586 var83 = (val*)(8l<<2|1);
2587 var84 = (val*)((long)(0)<<2|3);
2588 var85 = (val*)((long)(0)<<2|3);
2589 var81 = core__flat___CString___to_s_unsafe(var80, var82, var83, var84, var85);
2590 var79 = var81;
2591 varonce78 = var79;
2592 }
2593 {
2594 { /* Inline model$MClassType$mclass (var_finalizable_type) on <var_finalizable_type:nullable MClassType(MClassType)> */
2595 var88 = var_finalizable_type->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on <var_finalizable_type:nullable MClassType(MClassType)> */
2596 if (unlikely(var88 == NULL)) {
2597 if(catchStack.cursor >= 0){
2598 longjmp(catchStack.envs[catchStack.cursor], 1);
2599 }
2600 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
2601 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197);
2602 fatal_exit(1);
2603 }
2604 var86 = var88;
2605 RET_LABEL87:(void)0;
2606 }
2607 }
2608 {
2609 var89 = nitc__model___MModule___try_get_primitive_method(var75, var79, var86);
2610 }
2611 var_finalize_meth = var89;
2612 if (var_finalize_meth == NULL) {
2613 var90 = 0; /* is null */
2614 } else {
2615 var90 = 1; /* arg is null and recv is not */
2616 }
2617 if (0) {
2618 { /* Inline kernel$Object$!= (var_finalize_meth,((val*)NULL)) on <var_finalize_meth:nullable MMethod> */
2619 var_other27 = ((val*)NULL);
2620 {
2621 var93 = ((short int(*)(val* self, val* p0))(var_finalize_meth->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_finalize_meth, var_other27); /* == on <var_finalize_meth:nullable MMethod(MMethod)>*/
2622 }
2623 var94 = !var93;
2624 var91 = var94;
2625 goto RET_LABEL92;
2626 RET_LABEL92:(void)0;
2627 }
2628 var90 = var91;
2629 }
2630 if (var90){
2631 {
2632 nitc___nitc__RapidTypeAnalysis___add_send(self, var_finalizable_type, var_finalize_meth); /* Direct call rapid_type_analysis$RapidTypeAnalysis$add_send on <self:RapidTypeAnalysis>*/
2633 }
2634 } else {
2635 }
2636 } else {
2637 }
2638 if (likely(varonce95!=NULL)) {
2639 var96 = varonce95;
2640 } else {
2641 var97 = "Bool";
2642 var99 = (val*)(4l<<2|1);
2643 var100 = (val*)(4l<<2|1);
2644 var101 = (val*)((long)(0)<<2|3);
2645 var102 = (val*)((long)(0)<<2|3);
2646 var98 = core__flat___CString___to_s_unsafe(var97, var99, var100, var101, var102);
2647 var96 = var98;
2648 varonce95 = var96;
2649 }
2650 {
2651 nitc___nitc__RapidTypeAnalysis___force_alive(self, var96); /* Direct call rapid_type_analysis$RapidTypeAnalysis$force_alive on <self:RapidTypeAnalysis>*/
2652 }
2653 if (likely(varonce103!=NULL)) {
2654 var104 = varonce103;
2655 } else {
2656 var105 = "Float";
2657 var107 = (val*)(5l<<2|1);
2658 var108 = (val*)(5l<<2|1);
2659 var109 = (val*)((long)(0)<<2|3);
2660 var110 = (val*)((long)(0)<<2|3);
2661 var106 = core__flat___CString___to_s_unsafe(var105, var107, var108, var109, var110);
2662 var104 = var106;
2663 varonce103 = var104;
2664 }
2665 {
2666 nitc___nitc__RapidTypeAnalysis___force_alive(self, var104); /* Direct call rapid_type_analysis$RapidTypeAnalysis$force_alive on <self:RapidTypeAnalysis>*/
2667 }
2668 if (likely(varonce111!=NULL)) {
2669 var112 = varonce111;
2670 } else {
2671 var113 = "Char";
2672 var115 = (val*)(4l<<2|1);
2673 var116 = (val*)(4l<<2|1);
2674 var117 = (val*)((long)(0)<<2|3);
2675 var118 = (val*)((long)(0)<<2|3);
2676 var114 = core__flat___CString___to_s_unsafe(var113, var115, var116, var117, var118);
2677 var112 = var114;
2678 varonce111 = var112;
2679 }
2680 {
2681 nitc___nitc__RapidTypeAnalysis___force_alive(self, var112); /* Direct call rapid_type_analysis$RapidTypeAnalysis$force_alive on <self:RapidTypeAnalysis>*/
2682 }
2683 if (likely(varonce119!=NULL)) {
2684 var120 = varonce119;
2685 } else {
2686 var121 = "Pointer";
2687 var123 = (val*)(7l<<2|1);
2688 var124 = (val*)(7l<<2|1);
2689 var125 = (val*)((long)(0)<<2|3);
2690 var126 = (val*)((long)(0)<<2|3);
2691 var122 = core__flat___CString___to_s_unsafe(var121, var123, var124, var125, var126);
2692 var120 = var122;
2693 varonce119 = var120;
2694 }
2695 {
2696 nitc___nitc__RapidTypeAnalysis___force_alive(self, var120); /* Direct call rapid_type_analysis$RapidTypeAnalysis$force_alive on <self:RapidTypeAnalysis>*/
2697 }
2698 if (likely(varonce127!=NULL)) {
2699 var128 = varonce127;
2700 } else {
2701 var129 = "Byte";
2702 var131 = (val*)(4l<<2|1);
2703 var132 = (val*)(4l<<2|1);
2704 var133 = (val*)((long)(0)<<2|3);
2705 var134 = (val*)((long)(0)<<2|3);
2706 var130 = core__flat___CString___to_s_unsafe(var129, var131, var132, var133, var134);
2707 var128 = var130;
2708 varonce127 = var128;
2709 }
2710 {
2711 nitc___nitc__RapidTypeAnalysis___force_alive(self, var128); /* Direct call rapid_type_analysis$RapidTypeAnalysis$force_alive on <self:RapidTypeAnalysis>*/
2712 }
2713 if (likely(varonce135!=NULL)) {
2714 var136 = varonce135;
2715 } else {
2716 var137 = "Int";
2717 var139 = (val*)(3l<<2|1);
2718 var140 = (val*)(3l<<2|1);
2719 var141 = (val*)((long)(0)<<2|3);
2720 var142 = (val*)((long)(0)<<2|3);
2721 var138 = core__flat___CString___to_s_unsafe(var137, var139, var140, var141, var142);
2722 var136 = var138;
2723 varonce135 = var136;
2724 }
2725 {
2726 nitc___nitc__RapidTypeAnalysis___force_alive(self, var136); /* Direct call rapid_type_analysis$RapidTypeAnalysis$force_alive on <self:RapidTypeAnalysis>*/
2727 }
2728 if (likely(varonce143!=NULL)) {
2729 var144 = varonce143;
2730 } else {
2731 var145 = "Int8";
2732 var147 = (val*)(4l<<2|1);
2733 var148 = (val*)(4l<<2|1);
2734 var149 = (val*)((long)(0)<<2|3);
2735 var150 = (val*)((long)(0)<<2|3);
2736 var146 = core__flat___CString___to_s_unsafe(var145, var147, var148, var149, var150);
2737 var144 = var146;
2738 varonce143 = var144;
2739 }
2740 {
2741 nitc___nitc__RapidTypeAnalysis___force_alive(self, var144); /* Direct call rapid_type_analysis$RapidTypeAnalysis$force_alive on <self:RapidTypeAnalysis>*/
2742 }
2743 if (likely(varonce151!=NULL)) {
2744 var152 = varonce151;
2745 } else {
2746 var153 = "Int16";
2747 var155 = (val*)(5l<<2|1);
2748 var156 = (val*)(5l<<2|1);
2749 var157 = (val*)((long)(0)<<2|3);
2750 var158 = (val*)((long)(0)<<2|3);
2751 var154 = core__flat___CString___to_s_unsafe(var153, var155, var156, var157, var158);
2752 var152 = var154;
2753 varonce151 = var152;
2754 }
2755 {
2756 nitc___nitc__RapidTypeAnalysis___force_alive(self, var152); /* Direct call rapid_type_analysis$RapidTypeAnalysis$force_alive on <self:RapidTypeAnalysis>*/
2757 }
2758 if (likely(varonce159!=NULL)) {
2759 var160 = varonce159;
2760 } else {
2761 var161 = "UInt16";
2762 var163 = (val*)(6l<<2|1);
2763 var164 = (val*)(6l<<2|1);
2764 var165 = (val*)((long)(0)<<2|3);
2765 var166 = (val*)((long)(0)<<2|3);
2766 var162 = core__flat___CString___to_s_unsafe(var161, var163, var164, var165, var166);
2767 var160 = var162;
2768 varonce159 = var160;
2769 }
2770 {
2771 nitc___nitc__RapidTypeAnalysis___force_alive(self, var160); /* Direct call rapid_type_analysis$RapidTypeAnalysis$force_alive on <self:RapidTypeAnalysis>*/
2772 }
2773 if (likely(varonce167!=NULL)) {
2774 var168 = varonce167;
2775 } else {
2776 var169 = "Int32";
2777 var171 = (val*)(5l<<2|1);
2778 var172 = (val*)(5l<<2|1);
2779 var173 = (val*)((long)(0)<<2|3);
2780 var174 = (val*)((long)(0)<<2|3);
2781 var170 = core__flat___CString___to_s_unsafe(var169, var171, var172, var173, var174);
2782 var168 = var170;
2783 varonce167 = var168;
2784 }
2785 {
2786 nitc___nitc__RapidTypeAnalysis___force_alive(self, var168); /* Direct call rapid_type_analysis$RapidTypeAnalysis$force_alive on <self:RapidTypeAnalysis>*/
2787 }
2788 if (likely(varonce175!=NULL)) {
2789 var176 = varonce175;
2790 } else {
2791 var177 = "UInt32";
2792 var179 = (val*)(6l<<2|1);
2793 var180 = (val*)(6l<<2|1);
2794 var181 = (val*)((long)(0)<<2|3);
2795 var182 = (val*)((long)(0)<<2|3);
2796 var178 = core__flat___CString___to_s_unsafe(var177, var179, var180, var181, var182);
2797 var176 = var178;
2798 varonce175 = var176;
2799 }
2800 {
2801 nitc___nitc__RapidTypeAnalysis___force_alive(self, var176); /* Direct call rapid_type_analysis$RapidTypeAnalysis$force_alive on <self:RapidTypeAnalysis>*/
2802 }
2803 for(;;) {
2804 {
2805 { /* Inline rapid_type_analysis$RapidTypeAnalysis$todo (self) on <self:RapidTypeAnalysis> */
2806 var185 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___todo].val; /* _todo on <self:RapidTypeAnalysis> */
2807 if (unlikely(var185 == NULL)) {
2808 if(catchStack.cursor >= 0){
2809 longjmp(catchStack.envs[catchStack.cursor], 1);
2810 }
2811 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _todo");
2812 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 183);
2813 fatal_exit(1);
2814 }
2815 var183 = var185;
2816 RET_LABEL184:(void)0;
2817 }
2818 }
2819 {
2820 var186 = core___core__List___core__abstract_collection__Collection__is_empty(var183);
2821 }
2822 var187 = !var186;
2823 if (var187){
2824 {
2825 { /* Inline rapid_type_analysis$RapidTypeAnalysis$todo (self) on <self:RapidTypeAnalysis> */
2826 var190 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___todo].val; /* _todo on <self:RapidTypeAnalysis> */
2827 if (unlikely(var190 == NULL)) {
2828 if(catchStack.cursor >= 0){
2829 longjmp(catchStack.envs[catchStack.cursor], 1);
2830 }
2831 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _todo");
2832 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 183);
2833 fatal_exit(1);
2834 }
2835 var188 = var190;
2836 RET_LABEL189:(void)0;
2837 }
2838 }
2839 {
2840 var191 = core___core__List___core__abstract_collection__Sequence__shift(var188);
2841 }
2842 var_mmethoddef = var191;
2843 {
2844 { /* Inline model$MPropDef$mproperty (var_mmethoddef) on <var_mmethoddef:MMethodDef> */
2845 var194 = var_mmethoddef->attrs[COLOR_nitc__model__MPropDef___mproperty].val; /* _mproperty on <var_mmethoddef:MMethodDef> */
2846 if (unlikely(var194 == NULL)) {
2847 if(catchStack.cursor >= 0){
2848 longjmp(catchStack.envs[catchStack.cursor], 1);
2849 }
2850 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty");
2851 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2357);
2852 fatal_exit(1);
2853 }
2854 var192 = var194;
2855 RET_LABEL193:(void)0;
2856 }
2857 }
2858 var_mmeth = var192;
2859 {
2860 { /* Inline model$MMethodDef$msignature (var_mmethoddef) on <var_mmethoddef:MMethodDef> */
2861 var197 = var_mmethoddef->attrs[COLOR_nitc__model__MMethodDef___msignature].val; /* _msignature on <var_mmethoddef:MMethodDef> */
2862 var195 = var197;
2863 RET_LABEL196:(void)0;
2864 }
2865 }
2866 var_msignature = var195;
2867 if (var_msignature == NULL) {
2868 var198 = 1; /* is null */
2869 } else {
2870 var198 = 0; /* arg is null but recv is not */
2871 }
2872 if (0) {
2873 { /* Inline kernel$Object$== (var_msignature,((val*)NULL)) on <var_msignature:nullable MSignature> */
2874 var_other = ((val*)NULL);
2875 {
2876 { /* Inline kernel$Object$is_same_instance (var_msignature,var_other) on <var_msignature:nullable MSignature(MSignature)> */
2877 var203 = var_msignature == var_other;
2878 var201 = var203;
2879 goto RET_LABEL202;
2880 RET_LABEL202:(void)0;
2881 }
2882 }
2883 var199 = var201;
2884 goto RET_LABEL200;
2885 RET_LABEL200:(void)0;
2886 }
2887 var198 = var199;
2888 }
2889 if (var198){
2890 goto BREAK_label;
2891 } else {
2892 }
2893 var204 = NEW_nitc__RapidTypeVisitor(&type_nitc__RapidTypeVisitor);
2894 {
2895 { /* Inline model$MPropDef$mclassdef (var_mmethoddef) on <var_mmethoddef:MMethodDef> */
2896 var207 = var_mmethoddef->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on <var_mmethoddef:MMethodDef> */
2897 if (unlikely(var207 == NULL)) {
2898 if(catchStack.cursor >= 0){
2899 longjmp(catchStack.envs[catchStack.cursor], 1);
2900 }
2901 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef");
2902 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2354);
2903 fatal_exit(1);
2904 }
2905 var205 = var207;
2906 RET_LABEL206:(void)0;
2907 }
2908 }
2909 {
2910 { /* Inline model$MClassDef$bound_mtype (var205) on <var205:MClassDef> */
2911 var210 = var205->attrs[COLOR_nitc__model__MClassDef___bound_mtype].val; /* _bound_mtype on <var205:MClassDef> */
2912 if (unlikely(var210 == NULL)) {
2913 if(catchStack.cursor >= 0){
2914 longjmp(catchStack.envs[catchStack.cursor], 1);
2915 }
2916 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype");
2917 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 594);
2918 fatal_exit(1);
2919 }
2920 var208 = var210;
2921 RET_LABEL209:(void)0;
2922 }
2923 }
2924 {
2925 ((void(*)(val* self, val* p0))(var204->class->vft[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor__analysis_61d]))(var204, self); /* analysis= on <var204:RapidTypeVisitor>*/
2926 }
2927 {
2928 ((void(*)(val* self, val* p0))(var204->class->vft[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor__receiver_61d]))(var204, var208); /* receiver= on <var204:RapidTypeVisitor>*/
2929 }
2930 {
2931 ((void(*)(val* self, val* p0))(var204->class->vft[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor__mpropdef_61d]))(var204, var_mmethoddef); /* mpropdef= on <var204:RapidTypeVisitor>*/
2932 }
2933 {
2934 ((void(*)(val* self))(var204->class->vft[COLOR_core__kernel__Object__init]))(var204); /* init on <var204:RapidTypeVisitor>*/
2935 }
2936 var_v = var204;
2937 {
2938 { /* Inline model$MSignature$vararg_rank (var_msignature) on <var_msignature:nullable MSignature(MSignature)> */
2939 var213 = var_msignature->attrs[COLOR_nitc__model__MSignature___vararg_rank].l; /* _vararg_rank on <var_msignature:nullable MSignature(MSignature)> */
2940 var211 = var213;
2941 RET_LABEL212:(void)0;
2942 }
2943 }
2944 var_vararg_rank = var211;
2945 {
2946 { /* Inline kernel$Int$unary - (1l) on <1l:Int> */
2947 var216 = -1l;
2948 var214 = var216;
2949 goto RET_LABEL215;
2950 RET_LABEL215:(void)0;
2951 }
2952 }
2953 {
2954 { /* Inline kernel$Int$> (var_vararg_rank,var214) on <var_vararg_rank:Int> */
2955 /* Covariant cast for argument 0 (i) <var214:Int> isa OTHER */
2956 /* <var214:Int> isa OTHER */
2957 var219 = 1; /* easy <var214:Int> isa OTHER*/
2958 if (unlikely(!var219)) {
2959 var_class_name = type_core__Int.name;
2960 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
2961 PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 727);
2962 fatal_exit(1);
2963 }
2964 var220 = var_vararg_rank > var214;
2965 var217 = var220;
2966 goto RET_LABEL218;
2967 RET_LABEL218:(void)0;
2968 }
2969 }
2970 if (var217){
2971 {
2972 { /* Inline rapid_type_analysis$RapidTypeAnalysis$modelbuilder (self) on <self:RapidTypeAnalysis> */
2973 var223 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___modelbuilder].val; /* _modelbuilder on <self:RapidTypeAnalysis> */
2974 if (unlikely(var223 == NULL)) {
2975 if(catchStack.cursor >= 0){
2976 longjmp(catchStack.envs[catchStack.cursor], 1);
2977 }
2978 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder");
2979 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 53);
2980 fatal_exit(1);
2981 }
2982 var221 = var223;
2983 RET_LABEL222:(void)0;
2984 }
2985 }
2986 {
2987 var224 = nitc__modelize_property___ModelBuilder___mpropdef2node(var221, var_mmethoddef);
2988 }
2989 var_node = var224;
2990 {
2991 { /* Inline model$MSignature$mparameters (var_msignature) on <var_msignature:nullable MSignature(MSignature)> */
2992 var227 = var_msignature->attrs[COLOR_nitc__model__MSignature___mparameters].val; /* _mparameters on <var_msignature:nullable MSignature(MSignature)> */
2993 if (unlikely(var227 == NULL)) {
2994 if(catchStack.cursor >= 0){
2995 longjmp(catchStack.envs[catchStack.cursor], 1);
2996 }
2997 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mparameters");
2998 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1879);
2999 fatal_exit(1);
3000 }
3001 var225 = var227;
3002 RET_LABEL226:(void)0;
3003 }
3004 }
3005 {
3006 var228 = core___core__Array___core__abstract_collection__SequenceRead___91d_93d(var225, var_vararg_rank);
3007 }
3008 {
3009 { /* Inline model$MParameter$mtype (var228) on <var228:nullable Object(MParameter)> */
3010 var231 = var228->attrs[COLOR_nitc__model__MParameter___mtype].val; /* _mtype on <var228:nullable Object(MParameter)> */
3011 if (unlikely(var231 == NULL)) {
3012 if(catchStack.cursor >= 0){
3013 longjmp(catchStack.envs[catchStack.cursor], 1);
3014 }
3015 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype");
3016 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1996);
3017 fatal_exit(1);
3018 }
3019 var229 = var231;
3020 RET_LABEL230:(void)0;
3021 }
3022 }
3023 var_elttype = var229;
3024 {
3025 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
3026 var234 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
3027 if (unlikely(var234 == NULL)) {
3028 if(catchStack.cursor >= 0){
3029 longjmp(catchStack.envs[catchStack.cursor], 1);
3030 }
3031 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
3032 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
3033 fatal_exit(1);
3034 }
3035 var232 = var234;
3036 RET_LABEL233:(void)0;
3037 }
3038 }
3039 {
3040 var235 = nitc__model___MModule___array_type(var232, var_elttype);
3041 }
3042 var_vararg = var235;
3043 {
3044 nitc___nitc__RapidTypeVisitor___add_type(var_v, var_vararg); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_type on <var_v:RapidTypeVisitor>*/
3045 }
3046 {
3047 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
3048 var238 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
3049 if (unlikely(var238 == NULL)) {
3050 if(catchStack.cursor >= 0){
3051 longjmp(catchStack.envs[catchStack.cursor], 1);
3052 }
3053 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
3054 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
3055 fatal_exit(1);
3056 }
3057 var236 = var238;
3058 RET_LABEL237:(void)0;
3059 }
3060 }
3061 {
3062 var239 = nitc__model___MModule___native_array_type(var236, var_elttype);
3063 }
3064 var_native = var239;
3065 {
3066 nitc___nitc__RapidTypeVisitor___add_type(var_v, var_native); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_type on <var_v:RapidTypeVisitor>*/
3067 }
3068 {
3069 { /* Inline rapid_type_analysis$RapidTypeAnalysis$modelbuilder (self) on <self:RapidTypeAnalysis> */
3070 var242 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___modelbuilder].val; /* _modelbuilder on <self:RapidTypeAnalysis> */
3071 if (unlikely(var242 == NULL)) {
3072 if(catchStack.cursor >= 0){
3073 longjmp(catchStack.envs[catchStack.cursor], 1);
3074 }
3075 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder");
3076 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 53);
3077 fatal_exit(1);
3078 }
3079 var240 = var242;
3080 RET_LABEL241:(void)0;
3081 }
3082 }
3083 if (likely(varonce243!=NULL)) {
3084 var244 = varonce243;
3085 } else {
3086 var245 = "with_native";
3087 var247 = (val*)(11l<<2|1);
3088 var248 = (val*)(11l<<2|1);
3089 var249 = (val*)((long)(0)<<2|3);
3090 var250 = (val*)((long)(0)<<2|3);
3091 var246 = core__flat___CString___to_s_unsafe(var245, var247, var248, var249, var250);
3092 var244 = var246;
3093 varonce243 = var244;
3094 }
3095 {
3096 { /* Inline model$MClassType$mclass (var_vararg) on <var_vararg:MClassType> */
3097 var253 = var_vararg->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on <var_vararg:MClassType> */
3098 if (unlikely(var253 == NULL)) {
3099 if(catchStack.cursor >= 0){
3100 longjmp(catchStack.envs[catchStack.cursor], 1);
3101 }
3102 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
3103 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197);
3104 fatal_exit(1);
3105 }
3106 var251 = var253;
3107 RET_LABEL252:(void)0;
3108 }
3109 }
3110 {
3111 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
3112 var256 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
3113 if (unlikely(var256 == NULL)) {
3114 if(catchStack.cursor >= 0){
3115 longjmp(catchStack.envs[catchStack.cursor], 1);
3116 }
3117 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
3118 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
3119 fatal_exit(1);
3120 }
3121 var254 = var256;
3122 RET_LABEL255:(void)0;
3123 }
3124 }
3125 {
3126 var257 = nitc___nitc__ModelBuilder___force_get_primitive_method(var240, var_node, var244, var251, var254);
3127 }
3128 {
3129 nitc___nitc__RapidTypeVisitor___add_monomorphic_send(var_v, var_vararg, var257); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_monomorphic_send on <var_v:RapidTypeVisitor>*/
3130 }
3131 } else {
3132 }
3133 var_sig = var_msignature;
3134 {
3135 { /* Inline model$MProperty$intro (var_mmeth) on <var_mmeth:MMethod> */
3136 var260 = var_mmeth->attrs[COLOR_nitc__model__MProperty___intro].val; /* _intro on <var_mmeth:MMethod> */
3137 if (unlikely(var260 == NULL)) {
3138 if(catchStack.cursor >= 0){
3139 longjmp(catchStack.envs[catchStack.cursor], 1);
3140 }
3141 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro");
3142 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2097);
3143 fatal_exit(1);
3144 }
3145 var258 = var260;
3146 RET_LABEL259:(void)0;
3147 }
3148 }
3149 {
3150 { /* Inline model$MMethodDef$msignature (var258) on <var258:MPropDef(MMethodDef)> */
3151 var263 = var258->attrs[COLOR_nitc__model__MMethodDef___msignature].val; /* _msignature on <var258:MPropDef(MMethodDef)> */
3152 var261 = var263;
3153 RET_LABEL262:(void)0;
3154 }
3155 }
3156 if (unlikely(var261 == NULL)) {
3157 if(catchStack.cursor >= 0){
3158 longjmp(catchStack.envs[catchStack.cursor], 1);
3159 }
3160 PRINT_ERROR("Runtime error: %s", "Cast failed");
3161 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 250);
3162 fatal_exit(1);
3163 }
3164 var_osig = var261;
3165 var_i = 0l;
3166 {
3167 var264 = nitc___nitc__MSignature___arity(var_sig);
3168 }
3169 var_ = var264;
3170 for(;;) {
3171 {
3172 { /* Inline kernel$Int$< (var_i,var_) on <var_i:Int> */
3173 /* Covariant cast for argument 0 (i) <var_:Int> isa OTHER */
3174 /* <var_:Int> isa OTHER */
3175 var267 = 1; /* easy <var_:Int> isa OTHER*/
3176 if (unlikely(!var267)) {
3177 var_class_name270 = type_core__Int.name;
3178 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name270);
3179 PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 725);
3180 fatal_exit(1);
3181 }
3182 var271 = var_i < var_;
3183 var265 = var271;
3184 goto RET_LABEL266;
3185 RET_LABEL266:(void)0;
3186 }
3187 }
3188 if (var265){
3189 } else {
3190 goto BREAK_label272;
3191 }
3192 {
3193 { /* Inline model$MSignature$mparameters (var_osig) on <var_osig:MSignature> */
3194 var275 = var_osig->attrs[COLOR_nitc__model__MSignature___mparameters].val; /* _mparameters on <var_osig:MSignature> */
3195 if (unlikely(var275 == NULL)) {
3196 if(catchStack.cursor >= 0){
3197 longjmp(catchStack.envs[catchStack.cursor], 1);
3198 }
3199 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mparameters");
3200 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1879);
3201 fatal_exit(1);
3202 }
3203 var273 = var275;
3204 RET_LABEL274:(void)0;
3205 }
3206 }
3207 {
3208 var276 = core___core__Array___core__abstract_collection__SequenceRead___91d_93d(var273, var_i);
3209 }
3210 {
3211 { /* Inline model$MParameter$mtype (var276) on <var276:nullable Object(MParameter)> */
3212 var279 = var276->attrs[COLOR_nitc__model__MParameter___mtype].val; /* _mtype on <var276:nullable Object(MParameter)> */
3213 if (unlikely(var279 == NULL)) {
3214 if(catchStack.cursor >= 0){
3215 longjmp(catchStack.envs[catchStack.cursor], 1);
3216 }
3217 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype");
3218 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1996);
3219 fatal_exit(1);
3220 }
3221 var277 = var279;
3222 RET_LABEL278:(void)0;
3223 }
3224 }
3225 var_origtype = var277;
3226 {
3227 var280 = ((short int(*)(val* self))(var_origtype->class->vft[COLOR_nitc__model__MType__need_anchor]))(var_origtype); /* need_anchor on <var_origtype:MType>*/
3228 }
3229 var281 = !var280;
3230 if (var281){
3231 goto BREAK_label282;
3232 } else {
3233 }
3234 {
3235 { /* Inline model$MSignature$mparameters (var_sig) on <var_sig:MSignature> */
3236 var285 = var_sig->attrs[COLOR_nitc__model__MSignature___mparameters].val; /* _mparameters on <var_sig:MSignature> */
3237 if (unlikely(var285 == NULL)) {
3238 if(catchStack.cursor >= 0){
3239 longjmp(catchStack.envs[catchStack.cursor], 1);
3240 }
3241 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mparameters");
3242 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1879);
3243 fatal_exit(1);
3244 }
3245 var283 = var285;
3246 RET_LABEL284:(void)0;
3247 }
3248 }
3249 {
3250 var286 = core___core__Array___core__abstract_collection__SequenceRead___91d_93d(var283, var_i);
3251 }
3252 {
3253 { /* Inline model$MParameter$mtype (var286) on <var286:nullable Object(MParameter)> */
3254 var289 = var286->attrs[COLOR_nitc__model__MParameter___mtype].val; /* _mtype on <var286:nullable Object(MParameter)> */
3255 if (unlikely(var289 == NULL)) {
3256 if(catchStack.cursor >= 0){
3257 longjmp(catchStack.envs[catchStack.cursor], 1);
3258 }
3259 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mtype");
3260 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1996);
3261 fatal_exit(1);
3262 }
3263 var287 = var289;
3264 RET_LABEL288:(void)0;
3265 }
3266 }
3267 var_paramtype = var287;
3268 {
3269 nitc___nitc__RapidTypeAnalysis___add_cast(self, var_paramtype); /* Direct call rapid_type_analysis$RapidTypeAnalysis$add_cast on <self:RapidTypeAnalysis>*/
3270 }
3271 BREAK_label282: (void)0;
3272 {
3273 var290 = core___core__Int___Discrete__successor(var_i, 1l);
3274 }
3275 var_i = var290;
3276 }
3277 BREAK_label272: (void)0;
3278 {
3279 { /* Inline model$MMethodDef$is_abstract (var_mmethoddef) on <var_mmethoddef:MMethodDef> */
3280 var293 = var_mmethoddef->attrs[COLOR_nitc__model__MMethodDef___is_abstract].s; /* _is_abstract on <var_mmethoddef:MMethodDef> */
3281 var291 = var293;
3282 RET_LABEL292:(void)0;
3283 }
3284 }
3285 if (var291){
3286 goto BREAK_label;
3287 } else {
3288 }
3289 {
3290 { /* Inline rapid_type_analysis$RapidTypeAnalysis$modelbuilder (self) on <self:RapidTypeAnalysis> */
3291 var296 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___modelbuilder].val; /* _modelbuilder on <self:RapidTypeAnalysis> */
3292 if (unlikely(var296 == NULL)) {
3293 if(catchStack.cursor >= 0){
3294 longjmp(catchStack.envs[catchStack.cursor], 1);
3295 }
3296 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder");
3297 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 53);
3298 fatal_exit(1);
3299 }
3300 var294 = var296;
3301 RET_LABEL295:(void)0;
3302 }
3303 }
3304 {
3305 var297 = nitc__modelize_property___ModelBuilder___mpropdef2node(var294, var_mmethoddef);
3306 }
3307 var_npropdef = var297;
3308 /* <var_npropdef:nullable ANode> isa AClassdef */
3309 cltype299 = type_nitc__AClassdef.color;
3310 idtype300 = type_nitc__AClassdef.id;
3311 if(var_npropdef == NULL) {
3312 var298 = 0;
3313 } else {
3314 if(cltype299 >= var_npropdef->type->table_size) {
3315 var298 = 0;
3316 } else {
3317 var298 = var_npropdef->type->type_table[cltype299] == idtype300;
3318 }
3319 }
3320 if (var298){
3321 {
3322 { /* Inline model$MPropDef$mproperty (var_mmethoddef) on <var_mmethoddef:MMethodDef> */
3323 var303 = var_mmethoddef->attrs[COLOR_nitc__model__MPropDef___mproperty].val; /* _mproperty on <var_mmethoddef:MMethodDef> */
3324 if (unlikely(var303 == NULL)) {
3325 if(catchStack.cursor >= 0){
3326 longjmp(catchStack.envs[catchStack.cursor], 1);
3327 }
3328 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty");
3329 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2357);
3330 fatal_exit(1);
3331 }
3332 var301 = var303;
3333 RET_LABEL302:(void)0;
3334 }
3335 }
3336 {
3337 { /* Inline model$MMethod$is_root_init (var301) on <var301:MProperty(MMethod)> */
3338 var306 = var301->attrs[COLOR_nitc__model__MMethod___is_root_init].s; /* _is_root_init on <var301:MProperty(MMethod)> */
3339 var304 = var306;
3340 RET_LABEL305:(void)0;
3341 }
3342 }
3343 if (var304){
3344 {
3345 var307 = nitc___nitc__MPropDef___is_intro(var_mmethoddef);
3346 }
3347 var308 = !var307;
3348 if (var308){
3349 {
3350 { /* Inline rapid_type_analysis$RapidTypeVisitor$receiver (var_v) on <var_v:RapidTypeVisitor> */
3351 var311 = var_v->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___receiver].val; /* _receiver on <var_v:RapidTypeVisitor> */
3352 if (unlikely(var311 == NULL)) {
3353 if(catchStack.cursor >= 0){
3354 longjmp(catchStack.envs[catchStack.cursor], 1);
3355 }
3356 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _receiver");
3357 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 466);
3358 fatal_exit(1);
3359 }
3360 var309 = var311;
3361 RET_LABEL310:(void)0;
3362 }
3363 }
3364 {
3365 nitc___nitc__RapidTypeAnalysis___add_super_send(self, var309, var_mmethoddef); /* Direct call rapid_type_analysis$RapidTypeAnalysis$add_super_send on <self:RapidTypeAnalysis>*/
3366 }
3367 } else {
3368 }
3369 } else {
3370 if (unlikely(varonce312==NULL)) {
3371 var313 = NEW_core__NativeArray((int)2l, &type_core__NativeArray__core__String);
3372 if (likely(varonce314!=NULL)) {
3373 var315 = varonce314;
3374 } else {
3375 var316 = "cannot RTA ";
3376 var318 = (val*)(11l<<2|1);
3377 var319 = (val*)(11l<<2|1);
3378 var320 = (val*)((long)(0)<<2|3);
3379 var321 = (val*)((long)(0)<<2|3);
3380 var317 = core__flat___CString___to_s_unsafe(var316, var318, var319, var320, var321);
3381 var315 = var317;
3382 varonce314 = var315;
3383 }
3384 ((struct instance_core__NativeArray*)var313)->values[0]=var315;
3385 } else {
3386 var313 = varonce312;
3387 varonce312 = NULL;
3388 }
3389 {
3390 var322 = ((val*(*)(val* self))(var_mmethoddef->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mmethoddef); /* to_s on <var_mmethoddef:MMethodDef>*/
3391 }
3392 ((struct instance_core__NativeArray*)var313)->values[1]=var322;
3393 {
3394 var323 = ((val*(*)(val* self))(var313->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var313); /* native_to_s on <var313:NativeArray[String]>*/
3395 }
3396 varonce312 = var313;
3397 {
3398 nitc___nitc__ANode___debug(var_npropdef, var323); /* Direct call parser_nodes$ANode$debug on <var_npropdef:nullable ANode(AClassdef)>*/
3399 }
3400 if(catchStack.cursor >= 0){
3401 longjmp(catchStack.envs[catchStack.cursor], 1);
3402 }
3403 PRINT_ERROR("Runtime error: %s", "Aborted");
3404 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 269);
3405 fatal_exit(1);
3406 }
3407 goto BREAK_label;
3408 } else {
3409 {
3410 { /* Inline model$MMethodDef$constant_value (var_mmethoddef) on <var_mmethoddef:MMethodDef> */
3411 var326 = var_mmethoddef->attrs[COLOR_nitc__model__MMethodDef___constant_value].val; /* _constant_value on <var_mmethoddef:MMethodDef> */
3412 var324 = var326;
3413 RET_LABEL325:(void)0;
3414 }
3415 }
3416 if (var324 == NULL) {
3417 var327 = 0; /* is null */
3418 } else {
3419 var327 = 1; /* arg is null and recv is not */
3420 }
3421 if (0) {
3422 var328 = ((short int(*)(val* self, val* p0))((((long)var324&3)?class_info[((long)var324&3)]:var324->class)->vft[COLOR_core__kernel__Object___33d_61d]))(var324, ((val*)NULL)); /* != on <var324:nullable Object>*/
3423 var327 = var328;
3424 }
3425 if (var327){
3426 {
3427 { /* Inline model$MSignature$return_mtype (var_msignature) on <var_msignature:nullable MSignature(MSignature)> */
3428 var331 = var_msignature->attrs[COLOR_nitc__model__MSignature___return_mtype].val; /* _return_mtype on <var_msignature:nullable MSignature(MSignature)> */
3429 var329 = var331;
3430 RET_LABEL330:(void)0;
3431 }
3432 }
3433 /* <var329:nullable MType> isa MClassType */
3434 cltype333 = type_nitc__MClassType.color;
3435 idtype334 = type_nitc__MClassType.id;
3436 if(var329 == NULL) {
3437 var332 = 0;
3438 } else {
3439 if(cltype333 >= var329->type->table_size) {
3440 var332 = 0;
3441 } else {
3442 var332 = var329->type->type_table[cltype333] == idtype334;
3443 }
3444 }
3445 if (unlikely(!var332)) {
3446 var_class_name335 = var329 == NULL ? "null" : var329->type->name;
3447 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name335);
3448 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 274);
3449 fatal_exit(1);
3450 }
3451 {
3452 nitc___nitc__RapidTypeVisitor___add_type(var_v, var329); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_type on <var_v:RapidTypeVisitor>*/
3453 }
3454 goto BREAK_label;
3455 } else {
3456 if (var_npropdef == NULL) {
3457 var336 = 1; /* is null */
3458 } else {
3459 var336 = 0; /* arg is null but recv is not */
3460 }
3461 if (0) {
3462 { /* Inline kernel$Object$== (var_npropdef,((val*)NULL)) on <var_npropdef:nullable ANode> */
3463 var_other = ((val*)NULL);
3464 {
3465 { /* Inline kernel$Object$is_same_instance (var_npropdef,var_other) on <var_npropdef:nullable ANode(ANode)> */
3466 var341 = var_npropdef == var_other;
3467 var339 = var341;
3468 goto RET_LABEL340;
3469 RET_LABEL340:(void)0;
3470 }
3471 }
3472 var337 = var339;
3473 goto RET_LABEL338;
3474 RET_LABEL338:(void)0;
3475 }
3476 var336 = var337;
3477 }
3478 if (var336){
3479 if(catchStack.cursor >= 0){
3480 longjmp(catchStack.envs[catchStack.cursor], 1);
3481 }
3482 PRINT_ERROR("Runtime error: %s", "Aborted");
3483 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 277);
3484 fatal_exit(1);
3485 } else {
3486 }
3487 }
3488 }
3489 /* <var_npropdef:nullable ANode(ANode)> isa AMethPropdef */
3490 cltype343 = type_nitc__AMethPropdef.color;
3491 idtype344 = type_nitc__AMethPropdef.id;
3492 if(cltype343 >= var_npropdef->type->table_size) {
3493 var342 = 0;
3494 } else {
3495 var342 = var_npropdef->type->type_table[cltype343] == idtype344;
3496 }
3497 if (var342){
3498 {
3499 { /* Inline auto_super_init$AMethPropdef$auto_super_inits (var_npropdef) on <var_npropdef:nullable ANode(AMethPropdef)> */
3500 var347 = var_npropdef->attrs[COLOR_nitc__auto_super_init__AMethPropdef___auto_super_inits].val; /* _auto_super_inits on <var_npropdef:nullable ANode(AMethPropdef)> */
3501 var345 = var347;
3502 RET_LABEL346:(void)0;
3503 }
3504 }
3505 var_auto_super_inits = var345;
3506 if (var_auto_super_inits == NULL) {
3507 var348 = 0; /* is null */
3508 } else {
3509 var348 = 1; /* arg is null and recv is not */
3510 }
3511 if (0) {
3512 { /* Inline kernel$Object$!= (var_auto_super_inits,((val*)NULL)) on <var_auto_super_inits:nullable Array[CallSite]> */
3513 var_other27 = ((val*)NULL);
3514 {
3515 var351 = ((short int(*)(val* self, val* p0))(var_auto_super_inits->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_auto_super_inits, var_other27); /* == on <var_auto_super_inits:nullable Array[CallSite](Array[CallSite])>*/
3516 }
3517 var352 = !var351;
3518 var349 = var352;
3519 goto RET_LABEL350;
3520 RET_LABEL350:(void)0;
3521 }
3522 var348 = var349;
3523 }
3524 if (var348){
3525 var_353 = var_auto_super_inits;
3526 {
3527 var354 = core___core__AbstractArrayRead___core__abstract_collection__Collection__iterator(var_353);
3528 }
3529 var_355 = var354;
3530 for(;;) {
3531 {
3532 var356 = ((short int(*)(val* self))((((long)var_355&3)?class_info[((long)var_355&3)]:var_355->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_355); /* is_ok on <var_355:IndexedIterator[CallSite]>*/
3533 }
3534 if (var356){
3535 } else {
3536 goto BREAK_label357;
3537 }
3538 {
3539 var358 = ((val*(*)(val* self))((((long)var_355&3)?class_info[((long)var_355&3)]:var_355->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_355); /* item on <var_355:IndexedIterator[CallSite]>*/
3540 }
3541 var_auto_super_init = var358;
3542 {
3543 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var_auto_super_init); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
3544 }
3545 {
3546 ((void(*)(val* self))((((long)var_355&3)?class_info[((long)var_355&3)]:var_355->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_355); /* next on <var_355:IndexedIterator[CallSite]>*/
3547 }
3548 }
3549 BREAK_label357: (void)0;
3550 {
3551 ((void(*)(val* self))((((long)var_355&3)?class_info[((long)var_355&3)]:var_355->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_355); /* finish on <var_355:IndexedIterator[CallSite]>*/
3552 }
3553 } else {
3554 }
3555 {
3556 { /* Inline auto_super_init$AMethPropdef$auto_super_call (var_npropdef) on <var_npropdef:nullable ANode(AMethPropdef)> */
3557 var361 = var_npropdef->attrs[COLOR_nitc__auto_super_init__AMethPropdef___auto_super_call].s; /* _auto_super_call on <var_npropdef:nullable ANode(AMethPropdef)> */
3558 var359 = var361;
3559 RET_LABEL360:(void)0;
3560 }
3561 }
3562 if (var359){
3563 {
3564 { /* Inline rapid_type_analysis$RapidTypeVisitor$receiver (var_v) on <var_v:RapidTypeVisitor> */
3565 var364 = var_v->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___receiver].val; /* _receiver on <var_v:RapidTypeVisitor> */
3566 if (unlikely(var364 == NULL)) {
3567 if(catchStack.cursor >= 0){
3568 longjmp(catchStack.envs[catchStack.cursor], 1);
3569 }
3570 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _receiver");
3571 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 466);
3572 fatal_exit(1);
3573 }
3574 var362 = var364;
3575 RET_LABEL363:(void)0;
3576 }
3577 }
3578 {
3579 nitc___nitc__RapidTypeAnalysis___add_super_send(self, var362, var_mmethoddef); /* Direct call rapid_type_analysis$RapidTypeAnalysis$add_super_send on <self:RapidTypeAnalysis>*/
3580 }
3581 } else {
3582 }
3583 } else {
3584 }
3585 {
3586 { /* Inline model$MMethodDef$is_intern (var_mmethoddef) on <var_mmethoddef:MMethodDef> */
3587 var368 = var_mmethoddef->attrs[COLOR_nitc__model__MMethodDef___is_intern].s; /* _is_intern on <var_mmethoddef:MMethodDef> */
3588 var366 = var368;
3589 RET_LABEL367:(void)0;
3590 }
3591 }
3592 var_369 = var366;
3593 if (var366){
3594 var365 = var_369;
3595 } else {
3596 {
3597 { /* Inline model$MMethodDef$is_extern (var_mmethoddef) on <var_mmethoddef:MMethodDef> */
3598 var372 = var_mmethoddef->attrs[COLOR_nitc__model__MMethodDef___is_extern].s; /* _is_extern on <var_mmethoddef:MMethodDef> */
3599 var370 = var372;
3600 RET_LABEL371:(void)0;
3601 }
3602 }
3603 var365 = var370;
3604 }
3605 if (var365){
3606 {
3607 { /* Inline model$MSignature$return_mtype (var_msignature) on <var_msignature:nullable MSignature(MSignature)> */
3608 var375 = var_msignature->attrs[COLOR_nitc__model__MSignature___return_mtype].val; /* _return_mtype on <var_msignature:nullable MSignature(MSignature)> */
3609 var373 = var375;
3610 RET_LABEL374:(void)0;
3611 }
3612 }
3613 var_ret = var373;
3614 if (var_ret == NULL) {
3615 var379 = 0; /* is null */
3616 } else {
3617 var379 = 1; /* arg is null and recv is not */
3618 }
3619 if (0) {
3620 { /* Inline kernel$Object$!= (var_ret,((val*)NULL)) on <var_ret:nullable MType> */
3621 var_other27 = ((val*)NULL);
3622 {
3623 var382 = ((short int(*)(val* self, val* p0))(var_ret->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_ret, var_other27); /* == on <var_ret:nullable MType(MType)>*/
3624 }
3625 var383 = !var382;
3626 var380 = var383;
3627 goto RET_LABEL381;
3628 RET_LABEL381:(void)0;
3629 }
3630 var379 = var380;
3631 }
3632 var_384 = var379;
3633 if (var379){
3634 /* <var_ret:nullable MType(MType)> isa MClassType */
3635 cltype386 = type_nitc__MClassType.color;
3636 idtype387 = type_nitc__MClassType.id;
3637 if(cltype386 >= var_ret->type->table_size) {
3638 var385 = 0;
3639 } else {
3640 var385 = var_ret->type->type_table[cltype386] == idtype387;
3641 }
3642 var378 = var385;
3643 } else {
3644 var378 = var_384;
3645 }
3646 var_388 = var378;
3647 if (var378){
3648 {
3649 { /* Inline model$MClassType$mclass (var_ret) on <var_ret:nullable MType(MClassType)> */
3650 var391 = var_ret->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on <var_ret:nullable MType(MClassType)> */
3651 if (unlikely(var391 == NULL)) {
3652 if(catchStack.cursor >= 0){
3653 longjmp(catchStack.envs[catchStack.cursor], 1);
3654 }
3655 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
3656 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197);
3657 fatal_exit(1);
3658 }
3659 var389 = var391;
3660 RET_LABEL390:(void)0;
3661 }
3662 }
3663 {
3664 { /* Inline model$MClass$kind (var389) on <var389:MClass> */
3665 var394 = var389->attrs[COLOR_nitc__model__MClass___kind].val; /* _kind on <var389:MClass> */
3666 if (unlikely(var394 == NULL)) {
3667 if(catchStack.cursor >= 0){
3668 longjmp(catchStack.envs[catchStack.cursor], 1);
3669 }
3670 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _kind");
3671 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 472);
3672 fatal_exit(1);
3673 }
3674 var392 = var394;
3675 RET_LABEL393:(void)0;
3676 }
3677 }
3678 var395 = glob_sys;
3679 {
3680 var396 = nitc__model___core__Sys___abstract_kind(var395);
3681 }
3682 {
3683 { /* Inline kernel$Object$!= (var392,var396) on <var392:MClassKind> */
3684 var_other27 = var396;
3685 {
3686 var399 = ((short int(*)(val* self, val* p0))(var392->class->vft[COLOR_core__kernel__Object___61d_61d]))(var392, var_other27); /* == on <var392:MClassKind>*/
3687 }
3688 var400 = !var399;
3689 var397 = var400;
3690 goto RET_LABEL398;
3691 RET_LABEL398:(void)0;
3692 }
3693 }
3694 var377 = var397;
3695 } else {
3696 var377 = var_388;
3697 }
3698 var_401 = var377;
3699 if (var377){
3700 {
3701 { /* Inline model$MClassType$mclass (var_ret) on <var_ret:nullable MType(MClassType)> */
3702 var404 = var_ret->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on <var_ret:nullable MType(MClassType)> */
3703 if (unlikely(var404 == NULL)) {
3704 if(catchStack.cursor >= 0){
3705 longjmp(catchStack.envs[catchStack.cursor], 1);
3706 }
3707 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
3708 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197);
3709 fatal_exit(1);
3710 }
3711 var402 = var404;
3712 RET_LABEL403:(void)0;
3713 }
3714 }
3715 {
3716 { /* Inline model$MClass$kind (var402) on <var402:MClass> */
3717 var407 = var402->attrs[COLOR_nitc__model__MClass___kind].val; /* _kind on <var402:MClass> */
3718 if (unlikely(var407 == NULL)) {
3719 if(catchStack.cursor >= 0){
3720 longjmp(catchStack.envs[catchStack.cursor], 1);
3721 }
3722 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _kind");
3723 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 472);
3724 fatal_exit(1);
3725 }
3726 var405 = var407;
3727 RET_LABEL406:(void)0;
3728 }
3729 }
3730 var408 = glob_sys;
3731 {
3732 var409 = nitc__model___core__Sys___interface_kind(var408);
3733 }
3734 {
3735 { /* Inline kernel$Object$!= (var405,var409) on <var405:MClassKind> */
3736 var_other27 = var409;
3737 {
3738 var412 = ((short int(*)(val* self, val* p0))(var405->class->vft[COLOR_core__kernel__Object___61d_61d]))(var405, var_other27); /* == on <var405:MClassKind>*/
3739 }
3740 var413 = !var412;
3741 var410 = var413;
3742 goto RET_LABEL411;
3743 RET_LABEL411:(void)0;
3744 }
3745 }
3746 var376 = var410;
3747 } else {
3748 var376 = var_401;
3749 }
3750 if (var376){
3751 {
3752 nitc___nitc__RapidTypeVisitor___add_type(var_v, var_ret); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_type on <var_v:RapidTypeVisitor>*/
3753 }
3754 } else {
3755 }
3756 } else {
3757 }
3758 {
3759 nitc___nitc__Visitor___enter_visit(var_v, var_npropdef); /* Direct call parser_nodes$Visitor$enter_visit on <var_v:RapidTypeVisitor>*/
3760 }
3761 } else {
3762 goto BREAK_label414;
3763 }
3764 BREAK_label: (void)0;
3765 }
3766 BREAK_label414: (void)0;
3767 var415 = NEW_core__List(&type_core__List__nitc__MClassType);
3768 {
3769 { /* Inline list$List$init (var415) on <var415:List[MClassType]> */
3770 {
3771 ((void(*)(val* self))(var415->class->vft[COLOR_core___core__List___core__kernel__Object__init]))(var415); /* init on <var415:List[MClassType]>*/
3772 }
3773 RET_LABEL416:(void)0;
3774 }
3775 }
3776 var_todo_types = var415;
3777 {
3778 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_types (self) on <self:RapidTypeAnalysis> */
3779 var419 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on <self:RapidTypeAnalysis> */
3780 if (unlikely(var419 == NULL)) {
3781 if(catchStack.cursor >= 0){
3782 longjmp(catchStack.envs[catchStack.cursor], 1);
3783 }
3784 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types");
3785 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 60);
3786 fatal_exit(1);
3787 }
3788 var417 = var419;
3789 RET_LABEL418:(void)0;
3790 }
3791 }
3792 {
3793 core___core__SimpleCollection___add_all(var_todo_types, var417); /* Direct call abstract_collection$SimpleCollection$add_all on <var_todo_types:List[MClassType]>*/
3794 }
3795 for(;;) {
3796 {
3797 var420 = core___core__List___core__abstract_collection__Collection__is_empty(var_todo_types);
3798 }
3799 var421 = !var420;
3800 if (var421){
3801 {
3802 var422 = core___core__List___core__abstract_collection__Sequence__shift(var_todo_types);
3803 }
3804 var_t = var422;
3805 {
3806 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_open_types (self) on <self:RapidTypeAnalysis> */
3807 var425 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_open_types].val; /* _live_open_types on <self:RapidTypeAnalysis> */
3808 if (unlikely(var425 == NULL)) {
3809 if(catchStack.cursor >= 0){
3810 longjmp(catchStack.envs[catchStack.cursor], 1);
3811 }
3812 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_types");
3813 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 65);
3814 fatal_exit(1);
3815 }
3816 var423 = var425;
3817 RET_LABEL424:(void)0;
3818 }
3819 }
3820 var_426 = var423;
3821 {
3822 var427 = core___core__HashSet___core__abstract_collection__Collection__iterator(var_426);
3823 }
3824 var_428 = var427;
3825 for(;;) {
3826 {
3827 var429 = ((short int(*)(val* self))((((long)var_428&3)?class_info[((long)var_428&3)]:var_428->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_428); /* is_ok on <var_428:Iterator[MClassType]>*/
3828 }
3829 if (var429){
3830 } else {
3831 goto BREAK_label430;
3832 }
3833 {
3834 var431 = ((val*(*)(val* self))((((long)var_428&3)?class_info[((long)var_428&3)]:var_428->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_428); /* item on <var_428:Iterator[MClassType]>*/
3835 }
3836 var_ot = var431;
3837 {
3838 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
3839 var434 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
3840 if (unlikely(var434 == NULL)) {
3841 if(catchStack.cursor >= 0){
3842 longjmp(catchStack.envs[catchStack.cursor], 1);
3843 }
3844 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
3845 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
3846 fatal_exit(1);
3847 }
3848 var432 = var434;
3849 RET_LABEL433:(void)0;
3850 }
3851 }
3852 {
3853 var435 = ((short int(*)(val* self, val* p0, val* p1, val* p2))(var_ot->class->vft[COLOR_nitc__model__MType__can_resolve_for]))(var_ot, var_t, var_t, var432); /* can_resolve_for on <var_ot:MClassType>*/
3854 }
3855 var436 = !var435;
3856 if (var436){
3857 goto BREAK_label437;
3858 } else {
3859 }
3860 {
3861 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
3862 var440 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
3863 if (unlikely(var440 == NULL)) {
3864 if(catchStack.cursor >= 0){
3865 longjmp(catchStack.envs[catchStack.cursor], 1);
3866 }
3867 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
3868 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
3869 fatal_exit(1);
3870 }
3871 var438 = var440;
3872 RET_LABEL439:(void)0;
3873 }
3874 }
3875 {
3876 var441 = nitc___nitc__MClassType___MType__anchor_to(var_ot, var438, var_t);
3877 }
3878 var_rt = var441;
3879 {
3880 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_types (self) on <self:RapidTypeAnalysis> */
3881 var444 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on <self:RapidTypeAnalysis> */
3882 if (unlikely(var444 == NULL)) {
3883 if(catchStack.cursor >= 0){
3884 longjmp(catchStack.envs[catchStack.cursor], 1);
3885 }
3886 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types");
3887 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 60);
3888 fatal_exit(1);
3889 }
3890 var442 = var444;
3891 RET_LABEL443:(void)0;
3892 }
3893 }
3894 {
3895 var445 = core___core__HashSet___core__abstract_collection__Collection__has(var442, var_rt);
3896 }
3897 if (var445){
3898 goto BREAK_label437;
3899 } else {
3900 }
3901 {
3902 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
3903 var448 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
3904 if (unlikely(var448 == NULL)) {
3905 if(catchStack.cursor >= 0){
3906 longjmp(catchStack.envs[catchStack.cursor], 1);
3907 }
3908 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
3909 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
3910 fatal_exit(1);
3911 }
3912 var446 = var448;
3913 RET_LABEL447:(void)0;
3914 }
3915 }
3916 {
3917 var449 = ((short int(*)(val* self, val* p0, val* p1))(var_rt->class->vft[COLOR_nitc__model__MType__is_legal_in]))(var_rt, var446, ((val*)NULL)); /* is_legal_in on <var_rt:MClassType>*/
3918 }
3919 var450 = !var449;
3920 if (var450){
3921 goto BREAK_label437;
3922 } else {
3923 }
3924 {
3925 var451 = nitc___nitc__RapidTypeAnalysis___check_depth(self, var_rt);
3926 }
3927 var452 = !var451;
3928 if (var452){
3929 goto BREAK_label437;
3930 } else {
3931 }
3932 {
3933 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_types (self) on <self:RapidTypeAnalysis> */
3934 var455 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on <self:RapidTypeAnalysis> */
3935 if (unlikely(var455 == NULL)) {
3936 if(catchStack.cursor >= 0){
3937 longjmp(catchStack.envs[catchStack.cursor], 1);
3938 }
3939 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types");
3940 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 60);
3941 fatal_exit(1);
3942 }
3943 var453 = var455;
3944 RET_LABEL454:(void)0;
3945 }
3946 }
3947 {
3948 core___core__HashSet___core__abstract_collection__SimpleCollection__add(var453, var_rt); /* Direct call hash_collection$HashSet$add on <var453:HashSet[MClassType]>*/
3949 }
3950 {
3951 core___core__List___core__abstract_collection__Sequence__unshift(var_todo_types, var_rt); /* Direct call list$List$unshift on <var_todo_types:List[MClassType]>*/
3952 }
3953 BREAK_label437: (void)0;
3954 {
3955 ((void(*)(val* self))((((long)var_428&3)?class_info[((long)var_428&3)]:var_428->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_428); /* next on <var_428:Iterator[MClassType]>*/
3956 }
3957 }
3958 BREAK_label430: (void)0;
3959 {
3960 ((void(*)(val* self))((((long)var_428&3)?class_info[((long)var_428&3)]:var_428->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_428); /* finish on <var_428:Iterator[MClassType]>*/
3961 }
3962 } else {
3963 goto BREAK_label456;
3964 }
3965 }
3966 BREAK_label456: (void)0;
3967 {
3968 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_open_cast_types (self) on <self:RapidTypeAnalysis> */
3969 var459 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_open_cast_types].val; /* _live_open_cast_types on <self:RapidTypeAnalysis> */
3970 if (unlikely(var459 == NULL)) {
3971 if(catchStack.cursor >= 0){
3972 longjmp(catchStack.envs[catchStack.cursor], 1);
3973 }
3974 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_cast_types");
3975 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 75);
3976 fatal_exit(1);
3977 }
3978 var457 = var459;
3979 RET_LABEL458:(void)0;
3980 }
3981 }
3982 var_460 = var457;
3983 {
3984 var461 = core___core__HashSet___core__abstract_collection__Collection__iterator(var_460);
3985 }
3986 var_462 = var461;
3987 for(;;) {
3988 {
3989 var463 = ((short int(*)(val* self))((((long)var_462&3)?class_info[((long)var_462&3)]:var_462->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_462); /* is_ok on <var_462:Iterator[MType]>*/
3990 }
3991 if (var463){
3992 } else {
3993 goto BREAK_label464;
3994 }
3995 {
3996 var465 = ((val*(*)(val* self))((((long)var_462&3)?class_info[((long)var_462&3)]:var_462->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_462); /* item on <var_462:Iterator[MType]>*/
3997 }
3998 var_ot466 = var465;
3999 {
4000 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_types (self) on <self:RapidTypeAnalysis> */
4001 var469 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on <self:RapidTypeAnalysis> */
4002 if (unlikely(var469 == NULL)) {
4003 if(catchStack.cursor >= 0){
4004 longjmp(catchStack.envs[catchStack.cursor], 1);
4005 }
4006 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types");
4007 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 60);
4008 fatal_exit(1);
4009 }
4010 var467 = var469;
4011 RET_LABEL468:(void)0;
4012 }
4013 }
4014 var_470 = var467;
4015 {
4016 var471 = core___core__HashSet___core__abstract_collection__Collection__iterator(var_470);
4017 }
4018 var_472 = var471;
4019 for(;;) {
4020 {
4021 var473 = ((short int(*)(val* self))((((long)var_472&3)?class_info[((long)var_472&3)]:var_472->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_472); /* is_ok on <var_472:Iterator[MClassType]>*/
4022 }
4023 if (var473){
4024 } else {
4025 goto BREAK_label474;
4026 }
4027 {
4028 var475 = ((val*(*)(val* self))((((long)var_472&3)?class_info[((long)var_472&3)]:var_472->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_472); /* item on <var_472:Iterator[MClassType]>*/
4029 }
4030 var_t476 = var475;
4031 {
4032 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
4033 var479 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
4034 if (unlikely(var479 == NULL)) {
4035 if(catchStack.cursor >= 0){
4036 longjmp(catchStack.envs[catchStack.cursor], 1);
4037 }
4038 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
4039 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
4040 fatal_exit(1);
4041 }
4042 var477 = var479;
4043 RET_LABEL478:(void)0;
4044 }
4045 }
4046 {
4047 var480 = ((short int(*)(val* self, val* p0, val* p1, val* p2))(var_ot466->class->vft[COLOR_nitc__model__MType__can_resolve_for]))(var_ot466, var_t476, var_t476, var477); /* can_resolve_for on <var_ot466:MType>*/
4048 }
4049 var481 = !var480;
4050 if (var481){
4051 goto BREAK_label482;
4052 } else {
4053 }
4054 {
4055 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
4056 var485 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
4057 if (unlikely(var485 == NULL)) {
4058 if(catchStack.cursor >= 0){
4059 longjmp(catchStack.envs[catchStack.cursor], 1);
4060 }
4061 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
4062 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
4063 fatal_exit(1);
4064 }
4065 var483 = var485;
4066 RET_LABEL484:(void)0;
4067 }
4068 }
4069 {
4070 var486 = ((val*(*)(val* self, val* p0, val* p1))(var_ot466->class->vft[COLOR_nitc__model__MType__anchor_to]))(var_ot466, var483, var_t476); /* anchor_to on <var_ot466:MType>*/
4071 }
4072 var_rt487 = var486;
4073 {
4074 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
4075 var490 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
4076 if (unlikely(var490 == NULL)) {
4077 if(catchStack.cursor >= 0){
4078 longjmp(catchStack.envs[catchStack.cursor], 1);
4079 }
4080 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
4081 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
4082 fatal_exit(1);
4083 }
4084 var488 = var490;
4085 RET_LABEL489:(void)0;
4086 }
4087 }
4088 {
4089 var491 = ((short int(*)(val* self, val* p0, val* p1))(var_rt487->class->vft[COLOR_nitc__model__MType__is_legal_in]))(var_rt487, var488, ((val*)NULL)); /* is_legal_in on <var_rt487:MType>*/
4090 }
4091 var492 = !var491;
4092 if (var492){
4093 goto BREAK_label482;
4094 } else {
4095 }
4096 {
4097 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_cast_types (self) on <self:RapidTypeAnalysis> */
4098 var495 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_cast_types].val; /* _live_cast_types on <self:RapidTypeAnalysis> */
4099 if (unlikely(var495 == NULL)) {
4100 if(catchStack.cursor >= 0){
4101 longjmp(catchStack.envs[catchStack.cursor], 1);
4102 }
4103 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_cast_types");
4104 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 72);
4105 fatal_exit(1);
4106 }
4107 var493 = var495;
4108 RET_LABEL494:(void)0;
4109 }
4110 }
4111 {
4112 core___core__HashSet___core__abstract_collection__SimpleCollection__add(var493, var_rt487); /* Direct call hash_collection$HashSet$add on <var493:HashSet[MType]>*/
4113 }
4114 BREAK_label482: (void)0;
4115 {
4116 ((void(*)(val* self))((((long)var_472&3)?class_info[((long)var_472&3)]:var_472->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_472); /* next on <var_472:Iterator[MClassType]>*/
4117 }
4118 }
4119 BREAK_label474: (void)0;
4120 {
4121 ((void(*)(val* self))((((long)var_472&3)?class_info[((long)var_472&3)]:var_472->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_472); /* finish on <var_472:Iterator[MClassType]>*/
4122 }
4123 {
4124 ((void(*)(val* self))((((long)var_462&3)?class_info[((long)var_462&3)]:var_462->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_462); /* next on <var_462:Iterator[MType]>*/
4125 }
4126 }
4127 BREAK_label464: (void)0;
4128 {
4129 ((void(*)(val* self))((((long)var_462&3)?class_info[((long)var_462&3)]:var_462->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_462); /* finish on <var_462:Iterator[MType]>*/
4130 }
4131 RET_LABEL:;
4132 }
4133 /* method rapid_type_analysis$RapidTypeAnalysis$check_depth for (self: RapidTypeAnalysis, MClassType): Bool */
4134 short int nitc___nitc__RapidTypeAnalysis___check_depth(val* self, val* p0) {
4135 short int var /* : Bool */;
4136 val* var_mtype /* var mtype: MClassType */;
4137 long var1 /* : Int */;
4138 long var_d /* var d: Int */;
4139 short int var2 /* : Bool */;
4140 short int var4 /* : Bool */;
4141 int cltype;
4142 int idtype;
4143 const char* var_class_name;
4144 short int var5 /* : Bool */;
4145 val* var6 /* : ModelBuilder */;
4146 val* var8 /* : ModelBuilder */;
4147 val* var9 /* : ToolContext */;
4148 val* var11 /* : ToolContext */;
4149 val* var12 /* : NativeArray[String] */;
4150 static val* varonce;
4151 static val* varonce13;
4152 val* var14 /* : String */;
4153 char* var15 /* : CString */;
4154 val* var16 /* : String */;
4155 val* var17 /* : nullable Int */;
4156 val* var18 /* : nullable Int */;
4157 val* var19 /* : nullable Bool */;
4158 val* var20 /* : nullable Bool */;
4159 static val* varonce21;
4160 val* var22 /* : String */;
4161 char* var23 /* : CString */;
4162 val* var24 /* : String */;
4163 val* var25 /* : nullable Int */;
4164 val* var26 /* : nullable Int */;
4165 val* var27 /* : nullable Bool */;
4166 val* var28 /* : nullable Bool */;
4167 static val* varonce29;
4168 val* var30 /* : String */;
4169 char* var31 /* : CString */;
4170 val* var32 /* : String */;
4171 val* var33 /* : nullable Int */;
4172 val* var34 /* : nullable Int */;
4173 val* var35 /* : nullable Bool */;
4174 val* var36 /* : nullable Bool */;
4175 val* var37 /* : String */;
4176 val* var38 /* : String */;
4177 val* var39 /* : String */;
4178 var_mtype = p0;
4179 {
4180 var1 = ((long(*)(val* self))(var_mtype->class->vft[COLOR_nitc__model__MType__length]))(var_mtype); /* length on <var_mtype:MClassType>*/
4181 }
4182 var_d = var1;
4183 {
4184 { /* Inline kernel$Int$> (var_d,255l) on <var_d:Int> */
4185 /* Covariant cast for argument 0 (i) <255l:Int> isa OTHER */
4186 /* <255l:Int> isa OTHER */
4187 var4 = 1; /* easy <255l:Int> isa OTHER*/
4188 if (unlikely(!var4)) {
4189 var_class_name = type_core__Int.name;
4190 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
4191 PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 727);
4192 fatal_exit(1);
4193 }
4194 var5 = var_d > 255l;
4195 var2 = var5;
4196 goto RET_LABEL3;
4197 RET_LABEL3:(void)0;
4198 }
4199 }
4200 if (var2){
4201 {
4202 { /* Inline rapid_type_analysis$RapidTypeAnalysis$modelbuilder (self) on <self:RapidTypeAnalysis> */
4203 var8 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___modelbuilder].val; /* _modelbuilder on <self:RapidTypeAnalysis> */
4204 if (unlikely(var8 == NULL)) {
4205 if(catchStack.cursor >= 0){
4206 longjmp(catchStack.envs[catchStack.cursor], 1);
4207 }
4208 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder");
4209 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 53);
4210 fatal_exit(1);
4211 }
4212 var6 = var8;
4213 RET_LABEL7:(void)0;
4214 }
4215 }
4216 {
4217 { /* Inline modelbuilder_base$ModelBuilder$toolcontext (var6) on <var6:ModelBuilder> */
4218 var11 = var6->attrs[COLOR_nitc__modelbuilder_base__ModelBuilder___toolcontext].val; /* _toolcontext on <var6:ModelBuilder> */
4219 if (unlikely(var11 == NULL)) {
4220 if(catchStack.cursor >= 0){
4221 longjmp(catchStack.envs[catchStack.cursor], 1);
4222 }
4223 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _toolcontext");
4224 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__modelbuilder_base, 47);
4225 fatal_exit(1);
4226 }
4227 var9 = var11;
4228 RET_LABEL10:(void)0;
4229 }
4230 }
4231 if (unlikely(varonce==NULL)) {
4232 var12 = NEW_core__NativeArray((int)5l, &type_core__NativeArray__core__String);
4233 if (likely(varonce13!=NULL)) {
4234 var14 = varonce13;
4235 } else {
4236 var15 = "Fatal Error: limitation in the rapidtype analysis engine: a type depth of ";
4237 var17 = (val*)(74l<<2|1);
4238 var18 = (val*)(74l<<2|1);
4239 var19 = (val*)((long)(0)<<2|3);
4240 var20 = (val*)((long)(0)<<2|3);
4241 var16 = core__flat___CString___to_s_unsafe(var15, var17, var18, var19, var20);
4242 var14 = var16;
4243 varonce13 = var14;
4244 }
4245 ((struct instance_core__NativeArray*)var12)->values[0]=var14;
4246 if (likely(varonce21!=NULL)) {
4247 var22 = varonce21;
4248 } else {
4249 var23 = " is too important, the problematic type is `";
4250 var25 = (val*)(44l<<2|1);
4251 var26 = (val*)(44l<<2|1);
4252 var27 = (val*)((long)(0)<<2|3);
4253 var28 = (val*)((long)(0)<<2|3);
4254 var24 = core__flat___CString___to_s_unsafe(var23, var25, var26, var27, var28);
4255 var22 = var24;
4256 varonce21 = var22;
4257 }
4258 ((struct instance_core__NativeArray*)var12)->values[2]=var22;
4259 if (likely(varonce29!=NULL)) {
4260 var30 = varonce29;
4261 } else {
4262 var31 = "`.";
4263 var33 = (val*)(2l<<2|1);
4264 var34 = (val*)(2l<<2|1);
4265 var35 = (val*)((long)(0)<<2|3);
4266 var36 = (val*)((long)(0)<<2|3);
4267 var32 = core__flat___CString___to_s_unsafe(var31, var33, var34, var35, var36);
4268 var30 = var32;
4269 varonce29 = var30;
4270 }
4271 ((struct instance_core__NativeArray*)var12)->values[4]=var30;
4272 } else {
4273 var12 = varonce;
4274 varonce = NULL;
4275 }
4276 var37 = core__flat___Int___core__abstract_text__Object__to_s(var_d);
4277 ((struct instance_core__NativeArray*)var12)->values[1]=var37;
4278 {
4279 var38 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_core__abstract_text__Object__to_s]))(var_mtype); /* to_s on <var_mtype:MClassType>*/
4280 }
4281 ((struct instance_core__NativeArray*)var12)->values[3]=var38;
4282 {
4283 var39 = ((val*(*)(val* self))(var12->class->vft[COLOR_core__abstract_text__NativeArray__native_to_s]))(var12); /* native_to_s on <var12:NativeArray[String]>*/
4284 }
4285 varonce = var12;
4286 {
4287 nitc___nitc__ToolContext___fatal_error(var9, ((val*)NULL), var39); /* Direct call toolcontext$ToolContext$fatal_error on <var9:ToolContext>*/
4288 }
4289 var = 0;
4290 goto RET_LABEL;
4291 } else {
4292 }
4293 var = 1;
4294 goto RET_LABEL;
4295 RET_LABEL:;
4296 return var;
4297 }
4298 /* method rapid_type_analysis$RapidTypeAnalysis$add_new for (self: RapidTypeAnalysis, MClassType, MClassType) */
4299 void nitc___nitc__RapidTypeAnalysis___add_new(val* self, val* p0, val* p1) {
4300 val* var_recv /* var recv: MClassType */;
4301 val* var_mtype /* var mtype: MClassType */;
4302 short int var /* : Bool */;
4303 short int var1 /* : Bool */;
4304 short int var2 /* : Bool */;
4305 val* var3 /* : HashSet[MClassType] */;
4306 val* var5 /* : HashSet[MClassType] */;
4307 short int var6 /* : Bool */;
4308 val* var7 /* : HashSet[MClassType] */;
4309 val* var9 /* : HashSet[MClassType] */;
4310 val* var10 /* : HashSet[MClassType] */;
4311 val* var12 /* : HashSet[MClassType] */;
4312 short int var13 /* : Bool */;
4313 val* var14 /* : HashSet[MClassType] */;
4314 val* var16 /* : HashSet[MClassType] */;
4315 val* var17 /* : MClass */;
4316 val* var19 /* : MClass */;
4317 val* var_mclass /* var mclass: MClass */;
4318 val* var20 /* : HashSet[MClass] */;
4319 val* var22 /* : HashSet[MClass] */;
4320 short int var23 /* : Bool */;
4321 val* var24 /* : HashSet[MClass] */;
4322 val* var26 /* : HashSet[MClass] */;
4323 val* var27 /* : HashSet[MMethod] */;
4324 val* var29 /* : HashSet[MMethod] */;
4325 val* var_ /* var : HashSet[MMethod] */;
4326 val* var30 /* : Iterator[nullable Object] */;
4327 val* var_31 /* var : Iterator[MMethod] */;
4328 short int var32 /* : Bool */;
4329 val* var33 /* : nullable Object */;
4330 val* var_p /* var p: MMethod */;
4331 val* var34 /* : HashSet[MMethodDef] */;
4332 val* var36 /* : HashSet[MMethodDef] */;
4333 val* var_37 /* var : HashSet[MMethodDef] */;
4334 val* var38 /* : Iterator[nullable Object] */;
4335 val* var_39 /* var : Iterator[MMethodDef] */;
4336 short int var40 /* : Bool */;
4337 val* var42 /* : nullable Object */;
4338 val* var_p43 /* var p: MMethodDef */;
4339 val* var44 /* : Array[MMethod] */;
4340 val* var46 /* : Array[MMethod] */;
4341 val* var_47 /* var : Array[MMethod] */;
4342 val* var48 /* : IndexedIterator[nullable Object] */;
4343 val* var_49 /* var : IndexedIterator[MMethod] */;
4344 short int var50 /* : Bool */;
4345 val* var52 /* : nullable Object */;
4346 val* var_p53 /* var p: MMethod */;
4347 val* var54 /* : HashSet[MMethod] */;
4348 val* var56 /* : HashSet[MMethod] */;
4349 val* var57 /* : Array[MMethod] */;
4350 val* var59 /* : Array[MMethod] */;
4351 val* var60 /* : MModule */;
4352 val* var62 /* : MModule */;
4353 val* var63 /* : MClassType */;
4354 val* var_bound_mtype /* var bound_mtype: MClassType */;
4355 val* var64 /* : MModule */;
4356 val* var66 /* : MModule */;
4357 val* var67 /* : Set[MClassDef] */;
4358 val* var_68 /* var : Set[MClassDef] */;
4359 val* var69 /* : Iterator[nullable Object] */;
4360 val* var_70 /* var : Iterator[MClassDef] */;
4361 short int var71 /* : Bool */;
4362 val* var73 /* : nullable Object */;
4363 val* var_cd /* var cd: MClassDef */;
4364 val* var74 /* : ModelBuilder */;
4365 val* var76 /* : ModelBuilder */;
4366 val* var77 /* : Array[AAttrPropdef] */;
4367 val* var_78 /* var : Array[AAttrPropdef] */;
4368 val* var79 /* : IndexedIterator[nullable Object] */;
4369 val* var_80 /* var : IndexedIterator[AAttrPropdef] */;
4370 short int var81 /* : Bool */;
4371 val* var83 /* : nullable Object */;
4372 val* var_npropdef /* var npropdef: AAttrPropdef */;
4373 short int var84 /* : Bool */;
4374 short int var86 /* : Bool */;
4375 short int var87 /* : Bool */;
4376 val* var89 /* : nullable MMethodDef */;
4377 val* var91 /* : nullable MMethodDef */;
4378 val* var_mpropdef /* var mpropdef: MMethodDef */;
4379 val* var92 /* : RapidTypeVisitor */;
4380 val* var_v /* var v: RapidTypeVisitor */;
4381 val* var93 /* : nullable AExpr */;
4382 val* var95 /* : nullable AExpr */;
4383 val* var96 /* : nullable AExpr */;
4384 val* var98 /* : nullable AExpr */;
4385 var_recv = p0;
4386 var_mtype = p1;
4387 {
4388 var = ((short int(*)(val* self))(var_recv->class->vft[COLOR_nitc__model__MType__need_anchor]))(var_recv); /* need_anchor on <var_recv:MClassType>*/
4389 }
4390 var1 = !var;
4391 if (unlikely(!var1)) {
4392 if(catchStack.cursor >= 0){
4393 longjmp(catchStack.envs[catchStack.cursor], 1);
4394 }
4395 PRINT_ERROR("Runtime error: %s", "Assert failed");
4396 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 353);
4397 fatal_exit(1);
4398 }
4399 {
4400 var2 = ((short int(*)(val* self))(var_mtype->class->vft[COLOR_nitc__model__MType__need_anchor]))(var_mtype); /* need_anchor on <var_mtype:MClassType>*/
4401 }
4402 if (var2){
4403 {
4404 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_open_types (self) on <self:RapidTypeAnalysis> */
4405 var5 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_open_types].val; /* _live_open_types on <self:RapidTypeAnalysis> */
4406 if (unlikely(var5 == NULL)) {
4407 if(catchStack.cursor >= 0){
4408 longjmp(catchStack.envs[catchStack.cursor], 1);
4409 }
4410 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_types");
4411 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 65);
4412 fatal_exit(1);
4413 }
4414 var3 = var5;
4415 RET_LABEL4:(void)0;
4416 }
4417 }
4418 {
4419 var6 = core___core__HashSet___core__abstract_collection__Collection__has(var3, var_mtype);
4420 }
4421 if (var6){
4422 goto RET_LABEL;
4423 } else {
4424 }
4425 {
4426 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_open_types (self) on <self:RapidTypeAnalysis> */
4427 var9 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_open_types].val; /* _live_open_types on <self:RapidTypeAnalysis> */
4428 if (unlikely(var9 == NULL)) {
4429 if(catchStack.cursor >= 0){
4430 longjmp(catchStack.envs[catchStack.cursor], 1);
4431 }
4432 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_types");
4433 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 65);
4434 fatal_exit(1);
4435 }
4436 var7 = var9;
4437 RET_LABEL8:(void)0;
4438 }
4439 }
4440 {
4441 core___core__HashSet___core__abstract_collection__SimpleCollection__add(var7, var_mtype); /* Direct call hash_collection$HashSet$add on <var7:HashSet[MClassType]>*/
4442 }
4443 } else {
4444 {
4445 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_types (self) on <self:RapidTypeAnalysis> */
4446 var12 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on <self:RapidTypeAnalysis> */
4447 if (unlikely(var12 == NULL)) {
4448 if(catchStack.cursor >= 0){
4449 longjmp(catchStack.envs[catchStack.cursor], 1);
4450 }
4451 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types");
4452 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 60);
4453 fatal_exit(1);
4454 }
4455 var10 = var12;
4456 RET_LABEL11:(void)0;
4457 }
4458 }
4459 {
4460 var13 = core___core__HashSet___core__abstract_collection__Collection__has(var10, var_mtype);
4461 }
4462 if (var13){
4463 goto RET_LABEL;
4464 } else {
4465 }
4466 {
4467 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_types (self) on <self:RapidTypeAnalysis> */
4468 var16 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_types].val; /* _live_types on <self:RapidTypeAnalysis> */
4469 if (unlikely(var16 == NULL)) {
4470 if(catchStack.cursor >= 0){
4471 longjmp(catchStack.envs[catchStack.cursor], 1);
4472 }
4473 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_types");
4474 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 60);
4475 fatal_exit(1);
4476 }
4477 var14 = var16;
4478 RET_LABEL15:(void)0;
4479 }
4480 }
4481 {
4482 core___core__HashSet___core__abstract_collection__SimpleCollection__add(var14, var_mtype); /* Direct call hash_collection$HashSet$add on <var14:HashSet[MClassType]>*/
4483 }
4484 }
4485 {
4486 { /* Inline model$MClassType$mclass (var_mtype) on <var_mtype:MClassType> */
4487 var19 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on <var_mtype:MClassType> */
4488 if (unlikely(var19 == NULL)) {
4489 if(catchStack.cursor >= 0){
4490 longjmp(catchStack.envs[catchStack.cursor], 1);
4491 }
4492 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
4493 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197);
4494 fatal_exit(1);
4495 }
4496 var17 = var19;
4497 RET_LABEL18:(void)0;
4498 }
4499 }
4500 var_mclass = var17;
4501 {
4502 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_classes (self) on <self:RapidTypeAnalysis> */
4503 var22 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_classes].val; /* _live_classes on <self:RapidTypeAnalysis> */
4504 if (unlikely(var22 == NULL)) {
4505 if(catchStack.cursor >= 0){
4506 longjmp(catchStack.envs[catchStack.cursor], 1);
4507 }
4508 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_classes");
4509 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 69);
4510 fatal_exit(1);
4511 }
4512 var20 = var22;
4513 RET_LABEL21:(void)0;
4514 }
4515 }
4516 {
4517 var23 = core___core__HashSet___core__abstract_collection__Collection__has(var20, var_mclass);
4518 }
4519 if (var23){
4520 goto RET_LABEL;
4521 } else {
4522 }
4523 {
4524 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_classes (self) on <self:RapidTypeAnalysis> */
4525 var26 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_classes].val; /* _live_classes on <self:RapidTypeAnalysis> */
4526 if (unlikely(var26 == NULL)) {
4527 if(catchStack.cursor >= 0){
4528 longjmp(catchStack.envs[catchStack.cursor], 1);
4529 }
4530 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_classes");
4531 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 69);
4532 fatal_exit(1);
4533 }
4534 var24 = var26;
4535 RET_LABEL25:(void)0;
4536 }
4537 }
4538 {
4539 core___core__HashSet___core__abstract_collection__SimpleCollection__add(var24, var_mclass); /* Direct call hash_collection$HashSet$add on <var24:HashSet[MClass]>*/
4540 }
4541 {
4542 { /* Inline rapid_type_analysis$RapidTypeAnalysis$totry_methods (self) on <self:RapidTypeAnalysis> */
4543 var29 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___totry_methods].val; /* _totry_methods on <self:RapidTypeAnalysis> */
4544 if (unlikely(var29 == NULL)) {
4545 if(catchStack.cursor >= 0){
4546 longjmp(catchStack.envs[catchStack.cursor], 1);
4547 }
4548 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _totry_methods");
4549 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 173);
4550 fatal_exit(1);
4551 }
4552 var27 = var29;
4553 RET_LABEL28:(void)0;
4554 }
4555 }
4556 var_ = var27;
4557 {
4558 var30 = core___core__HashSet___core__abstract_collection__Collection__iterator(var_);
4559 }
4560 var_31 = var30;
4561 for(;;) {
4562 {
4563 var32 = ((short int(*)(val* self))((((long)var_31&3)?class_info[((long)var_31&3)]:var_31->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_31); /* is_ok on <var_31:Iterator[MMethod]>*/
4564 }
4565 if (var32){
4566 } else {
4567 goto BREAK_label;
4568 }
4569 {
4570 var33 = ((val*(*)(val* self))((((long)var_31&3)?class_info[((long)var_31&3)]:var_31->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_31); /* item on <var_31:Iterator[MMethod]>*/
4571 }
4572 var_p = var33;
4573 {
4574 nitc___nitc__RapidTypeAnalysis___try_send(self, var_mtype, var_p); /* Direct call rapid_type_analysis$RapidTypeAnalysis$try_send on <self:RapidTypeAnalysis>*/
4575 }
4576 {
4577 ((void(*)(val* self))((((long)var_31&3)?class_info[((long)var_31&3)]:var_31->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_31); /* next on <var_31:Iterator[MMethod]>*/
4578 }
4579 }
4580 BREAK_label: (void)0;
4581 {
4582 ((void(*)(val* self))((((long)var_31&3)?class_info[((long)var_31&3)]:var_31->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_31); /* finish on <var_31:Iterator[MMethod]>*/
4583 }
4584 {
4585 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_super_sends (self) on <self:RapidTypeAnalysis> */
4586 var36 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_super_sends].val; /* _live_super_sends on <self:RapidTypeAnalysis> */
4587 if (unlikely(var36 == NULL)) {
4588 if(catchStack.cursor >= 0){
4589 longjmp(catchStack.envs[catchStack.cursor], 1);
4590 }
4591 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_super_sends");
4592 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 118);
4593 fatal_exit(1);
4594 }
4595 var34 = var36;
4596 RET_LABEL35:(void)0;
4597 }
4598 }
4599 var_37 = var34;
4600 {
4601 var38 = core___core__HashSet___core__abstract_collection__Collection__iterator(var_37);
4602 }
4603 var_39 = var38;
4604 for(;;) {
4605 {
4606 var40 = ((short int(*)(val* self))((((long)var_39&3)?class_info[((long)var_39&3)]:var_39->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_39); /* is_ok on <var_39:Iterator[MMethodDef]>*/
4607 }
4608 if (var40){
4609 } else {
4610 goto BREAK_label41;
4611 }
4612 {
4613 var42 = ((val*(*)(val* self))((((long)var_39&3)?class_info[((long)var_39&3)]:var_39->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_39); /* item on <var_39:Iterator[MMethodDef]>*/
4614 }
4615 var_p43 = var42;
4616 {
4617 nitc___nitc__RapidTypeAnalysis___try_super_send(self, var_mtype, var_p43); /* Direct call rapid_type_analysis$RapidTypeAnalysis$try_super_send on <self:RapidTypeAnalysis>*/
4618 }
4619 {
4620 ((void(*)(val* self))((((long)var_39&3)?class_info[((long)var_39&3)]:var_39->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_39); /* next on <var_39:Iterator[MMethodDef]>*/
4621 }
4622 }
4623 BREAK_label41: (void)0;
4624 {
4625 ((void(*)(val* self))((((long)var_39&3)?class_info[((long)var_39&3)]:var_39->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_39); /* finish on <var_39:Iterator[MMethodDef]>*/
4626 }
4627 {
4628 { /* Inline rapid_type_analysis$RapidTypeAnalysis$totry_methods_to_remove (self) on <self:RapidTypeAnalysis> */
4629 var46 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___totry_methods_to_remove].val; /* _totry_methods_to_remove on <self:RapidTypeAnalysis> */
4630 if (unlikely(var46 == NULL)) {
4631 if(catchStack.cursor >= 0){
4632 longjmp(catchStack.envs[catchStack.cursor], 1);
4633 }
4634 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _totry_methods_to_remove");
4635 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 176);
4636 fatal_exit(1);
4637 }
4638 var44 = var46;
4639 RET_LABEL45:(void)0;
4640 }
4641 }
4642 var_47 = var44;
4643 {
4644 var48 = core___core__AbstractArrayRead___core__abstract_collection__Collection__iterator(var_47);
4645 }
4646 var_49 = var48;
4647 for(;;) {
4648 {
4649 var50 = ((short int(*)(val* self))((((long)var_49&3)?class_info[((long)var_49&3)]:var_49->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_49); /* is_ok on <var_49:IndexedIterator[MMethod]>*/
4650 }
4651 if (var50){
4652 } else {
4653 goto BREAK_label51;
4654 }
4655 {
4656 var52 = ((val*(*)(val* self))((((long)var_49&3)?class_info[((long)var_49&3)]:var_49->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_49); /* item on <var_49:IndexedIterator[MMethod]>*/
4657 }
4658 var_p53 = var52;
4659 {
4660 { /* Inline rapid_type_analysis$RapidTypeAnalysis$totry_methods (self) on <self:RapidTypeAnalysis> */
4661 var56 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___totry_methods].val; /* _totry_methods on <self:RapidTypeAnalysis> */
4662 if (unlikely(var56 == NULL)) {
4663 if(catchStack.cursor >= 0){
4664 longjmp(catchStack.envs[catchStack.cursor], 1);
4665 }
4666 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _totry_methods");
4667 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 173);
4668 fatal_exit(1);
4669 }
4670 var54 = var56;
4671 RET_LABEL55:(void)0;
4672 }
4673 }
4674 {
4675 core___core__HashSet___core__abstract_collection__RemovableCollection__remove(var54, var_p53); /* Direct call hash_collection$HashSet$remove on <var54:HashSet[MMethod]>*/
4676 }
4677 {
4678 ((void(*)(val* self))((((long)var_49&3)?class_info[((long)var_49&3)]:var_49->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_49); /* next on <var_49:IndexedIterator[MMethod]>*/
4679 }
4680 }
4681 BREAK_label51: (void)0;
4682 {
4683 ((void(*)(val* self))((((long)var_49&3)?class_info[((long)var_49&3)]:var_49->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_49); /* finish on <var_49:IndexedIterator[MMethod]>*/
4684 }
4685 {
4686 { /* Inline rapid_type_analysis$RapidTypeAnalysis$totry_methods_to_remove (self) on <self:RapidTypeAnalysis> */
4687 var59 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___totry_methods_to_remove].val; /* _totry_methods_to_remove on <self:RapidTypeAnalysis> */
4688 if (unlikely(var59 == NULL)) {
4689 if(catchStack.cursor >= 0){
4690 longjmp(catchStack.envs[catchStack.cursor], 1);
4691 }
4692 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _totry_methods_to_remove");
4693 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 176);
4694 fatal_exit(1);
4695 }
4696 var57 = var59;
4697 RET_LABEL58:(void)0;
4698 }
4699 }
4700 {
4701 core___core__AbstractArray___core__abstract_collection__RemovableCollection__clear(var57); /* Direct call array$AbstractArray$clear on <var57:Array[MMethod]>*/
4702 }
4703 {
4704 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
4705 var62 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
4706 if (unlikely(var62 == NULL)) {
4707 if(catchStack.cursor >= 0){
4708 longjmp(catchStack.envs[catchStack.cursor], 1);
4709 }
4710 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
4711 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
4712 fatal_exit(1);
4713 }
4714 var60 = var62;
4715 RET_LABEL61:(void)0;
4716 }
4717 }
4718 {
4719 var63 = nitc___nitc__MClassType___MType__anchor_to(var_mtype, var60, var_recv);
4720 }
4721 var_bound_mtype = var63;
4722 {
4723 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
4724 var66 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
4725 if (unlikely(var66 == NULL)) {
4726 if(catchStack.cursor >= 0){
4727 longjmp(catchStack.envs[catchStack.cursor], 1);
4728 }
4729 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
4730 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
4731 fatal_exit(1);
4732 }
4733 var64 = var66;
4734 RET_LABEL65:(void)0;
4735 }
4736 }
4737 {
4738 var67 = nitc___nitc__MClassType___MType__collect_mclassdefs(var_bound_mtype, var64);
4739 }
4740 var_68 = var67;
4741 {
4742 var69 = ((val*(*)(val* self))((((long)var_68&3)?class_info[((long)var_68&3)]:var_68->class)->vft[COLOR_core__abstract_collection__Collection__iterator]))(var_68); /* iterator on <var_68:Set[MClassDef]>*/
4743 }
4744 var_70 = var69;
4745 for(;;) {
4746 {
4747 var71 = ((short int(*)(val* self))((((long)var_70&3)?class_info[((long)var_70&3)]:var_70->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_70); /* is_ok on <var_70:Iterator[MClassDef]>*/
4748 }
4749 if (var71){
4750 } else {
4751 goto BREAK_label72;
4752 }
4753 {
4754 var73 = ((val*(*)(val* self))((((long)var_70&3)?class_info[((long)var_70&3)]:var_70->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_70); /* item on <var_70:Iterator[MClassDef]>*/
4755 }
4756 var_cd = var73;
4757 {
4758 { /* Inline rapid_type_analysis$RapidTypeAnalysis$modelbuilder (self) on <self:RapidTypeAnalysis> */
4759 var76 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___modelbuilder].val; /* _modelbuilder on <self:RapidTypeAnalysis> */
4760 if (unlikely(var76 == NULL)) {
4761 if(catchStack.cursor >= 0){
4762 longjmp(catchStack.envs[catchStack.cursor], 1);
4763 }
4764 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder");
4765 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 53);
4766 fatal_exit(1);
4767 }
4768 var74 = var76;
4769 RET_LABEL75:(void)0;
4770 }
4771 }
4772 {
4773 var77 = nitc__modelize_property___ModelBuilder___collect_attr_propdef(var74, var_cd);
4774 }
4775 var_78 = var77;
4776 {
4777 var79 = core___core__AbstractArrayRead___core__abstract_collection__Collection__iterator(var_78);
4778 }
4779 var_80 = var79;
4780 for(;;) {
4781 {
4782 var81 = ((short int(*)(val* self))((((long)var_80&3)?class_info[((long)var_80&3)]:var_80->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_80); /* is_ok on <var_80:IndexedIterator[AAttrPropdef]>*/
4783 }
4784 if (var81){
4785 } else {
4786 goto BREAK_label82;
4787 }
4788 {
4789 var83 = ((val*(*)(val* self))((((long)var_80&3)?class_info[((long)var_80&3)]:var_80->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_80); /* item on <var_80:IndexedIterator[AAttrPropdef]>*/
4790 }
4791 var_npropdef = var83;
4792 {
4793 { /* Inline modelize_property$AAttrPropdef$has_value (var_npropdef) on <var_npropdef:AAttrPropdef> */
4794 var86 = var_npropdef->attrs[COLOR_nitc__modelize_property__AAttrPropdef___has_value].s; /* _has_value on <var_npropdef:AAttrPropdef> */
4795 var84 = var86;
4796 RET_LABEL85:(void)0;
4797 }
4798 }
4799 var87 = !var84;
4800 if (var87){
4801 goto BREAK_label88;
4802 } else {
4803 }
4804 {
4805 { /* Inline modelize_property$AAttrPropdef$mreadpropdef (var_npropdef) on <var_npropdef:AAttrPropdef> */
4806 var91 = var_npropdef->attrs[COLOR_nitc__modelize_property__AAttrPropdef___mreadpropdef].val; /* _mreadpropdef on <var_npropdef:AAttrPropdef> */
4807 var89 = var91;
4808 RET_LABEL90:(void)0;
4809 }
4810 }
4811 if (unlikely(var89 == NULL)) {
4812 if(catchStack.cursor >= 0){
4813 longjmp(catchStack.envs[catchStack.cursor], 1);
4814 }
4815 PRINT_ERROR("Runtime error: %s", "Cast failed");
4816 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 379);
4817 fatal_exit(1);
4818 }
4819 var_mpropdef = var89;
4820 var92 = NEW_nitc__RapidTypeVisitor(&type_nitc__RapidTypeVisitor);
4821 {
4822 ((void(*)(val* self, val* p0))(var92->class->vft[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor__analysis_61d]))(var92, self); /* analysis= on <var92:RapidTypeVisitor>*/
4823 }
4824 {
4825 ((void(*)(val* self, val* p0))(var92->class->vft[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor__receiver_61d]))(var92, var_bound_mtype); /* receiver= on <var92:RapidTypeVisitor>*/
4826 }
4827 {
4828 ((void(*)(val* self, val* p0))(var92->class->vft[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor__mpropdef_61d]))(var92, var_mpropdef); /* mpropdef= on <var92:RapidTypeVisitor>*/
4829 }
4830 {
4831 ((void(*)(val* self))(var92->class->vft[COLOR_core__kernel__Object__init]))(var92); /* init on <var92:RapidTypeVisitor>*/
4832 }
4833 var_v = var92;
4834 {
4835 { /* Inline parser_nodes$AAttrPropdef$n_expr (var_npropdef) on <var_npropdef:AAttrPropdef> */
4836 var95 = var_npropdef->attrs[COLOR_nitc__parser_nodes__AAttrPropdef___n_expr].val; /* _n_expr on <var_npropdef:AAttrPropdef> */
4837 var93 = var95;
4838 RET_LABEL94:(void)0;
4839 }
4840 }
4841 {
4842 nitc___nitc__Visitor___enter_visit(var_v, var93); /* Direct call parser_nodes$Visitor$enter_visit on <var_v:RapidTypeVisitor>*/
4843 }
4844 {
4845 { /* Inline parser_nodes$AAttrPropdef$n_block (var_npropdef) on <var_npropdef:AAttrPropdef> */
4846 var98 = var_npropdef->attrs[COLOR_nitc__parser_nodes__AAttrPropdef___n_block].val; /* _n_block on <var_npropdef:AAttrPropdef> */
4847 var96 = var98;
4848 RET_LABEL97:(void)0;
4849 }
4850 }
4851 {
4852 nitc___nitc__Visitor___enter_visit(var_v, var96); /* Direct call parser_nodes$Visitor$enter_visit on <var_v:RapidTypeVisitor>*/
4853 }
4854 BREAK_label88: (void)0;
4855 {
4856 ((void(*)(val* self))((((long)var_80&3)?class_info[((long)var_80&3)]:var_80->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_80); /* next on <var_80:IndexedIterator[AAttrPropdef]>*/
4857 }
4858 }
4859 BREAK_label82: (void)0;
4860 {
4861 ((void(*)(val* self))((((long)var_80&3)?class_info[((long)var_80&3)]:var_80->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_80); /* finish on <var_80:IndexedIterator[AAttrPropdef]>*/
4862 }
4863 {
4864 ((void(*)(val* self))((((long)var_70&3)?class_info[((long)var_70&3)]:var_70->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_70); /* next on <var_70:Iterator[MClassDef]>*/
4865 }
4866 }
4867 BREAK_label72: (void)0;
4868 {
4869 ((void(*)(val* self))((((long)var_70&3)?class_info[((long)var_70&3)]:var_70->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_70); /* finish on <var_70:Iterator[MClassDef]>*/
4870 }
4871 RET_LABEL:;
4872 }
4873 /* method rapid_type_analysis$RapidTypeAnalysis$add_cast for (self: RapidTypeAnalysis, MType) */
4874 void nitc___nitc__RapidTypeAnalysis___add_cast(val* self, val* p0) {
4875 val* var_mtype /* var mtype: MType */;
4876 short int var /* : Bool */;
4877 val* var1 /* : HashSet[MType] */;
4878 val* var3 /* : HashSet[MType] */;
4879 val* var4 /* : HashSet[MType] */;
4880 val* var6 /* : HashSet[MType] */;
4881 var_mtype = p0;
4882 {
4883 var = ((short int(*)(val* self))(var_mtype->class->vft[COLOR_nitc__model__MType__need_anchor]))(var_mtype); /* need_anchor on <var_mtype:MType>*/
4884 }
4885 if (var){
4886 {
4887 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_open_cast_types (self) on <self:RapidTypeAnalysis> */
4888 var3 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_open_cast_types].val; /* _live_open_cast_types on <self:RapidTypeAnalysis> */
4889 if (unlikely(var3 == NULL)) {
4890 if(catchStack.cursor >= 0){
4891 longjmp(catchStack.envs[catchStack.cursor], 1);
4892 }
4893 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_open_cast_types");
4894 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 75);
4895 fatal_exit(1);
4896 }
4897 var1 = var3;
4898 RET_LABEL2:(void)0;
4899 }
4900 }
4901 {
4902 core___core__HashSet___core__abstract_collection__SimpleCollection__add(var1, var_mtype); /* Direct call hash_collection$HashSet$add on <var1:HashSet[MType]>*/
4903 }
4904 } else {
4905 {
4906 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_cast_types (self) on <self:RapidTypeAnalysis> */
4907 var6 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_cast_types].val; /* _live_cast_types on <self:RapidTypeAnalysis> */
4908 if (unlikely(var6 == NULL)) {
4909 if(catchStack.cursor >= 0){
4910 longjmp(catchStack.envs[catchStack.cursor], 1);
4911 }
4912 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_cast_types");
4913 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 72);
4914 fatal_exit(1);
4915 }
4916 var4 = var6;
4917 RET_LABEL5:(void)0;
4918 }
4919 }
4920 {
4921 core___core__HashSet___core__abstract_collection__SimpleCollection__add(var4, var_mtype); /* Direct call hash_collection$HashSet$add on <var4:HashSet[MType]>*/
4922 }
4923 }
4924 RET_LABEL:;
4925 }
4926 /* method rapid_type_analysis$RapidTypeAnalysis$try_send for (self: RapidTypeAnalysis, MClassType, MMethod) */
4927 void nitc___nitc__RapidTypeAnalysis___try_send(val* self, val* p0, val* p1) {
4928 val* var_recv /* var recv: MClassType */;
4929 val* var_mproperty /* var mproperty: MMethod */;
4930 val* var /* : MClass */;
4931 val* var2 /* : MClass */;
4932 val* var3 /* : MClassDef */;
4933 val* var5 /* : MClassDef */;
4934 val* var6 /* : MClassType */;
4935 val* var8 /* : MClassType */;
4936 val* var9 /* : MModule */;
4937 val* var11 /* : MModule */;
4938 short int var12 /* : Bool */;
4939 short int var13 /* : Bool */;
4940 val* var14 /* : MModule */;
4941 val* var16 /* : MModule */;
4942 val* var17 /* : MPropDef */;
4943 val* var_d /* var d: MMethodDef */;
4944 var_recv = p0;
4945 var_mproperty = p1;
4946 {
4947 { /* Inline model$MClassType$mclass (var_recv) on <var_recv:MClassType> */
4948 var2 = var_recv->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on <var_recv:MClassType> */
4949 if (unlikely(var2 == NULL)) {
4950 if(catchStack.cursor >= 0){
4951 longjmp(catchStack.envs[catchStack.cursor], 1);
4952 }
4953 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
4954 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197);
4955 fatal_exit(1);
4956 }
4957 var = var2;
4958 RET_LABEL1:(void)0;
4959 }
4960 }
4961 {
4962 { /* Inline model$MClass$intro (var) on <var:MClass> */
4963 var5 = var->attrs[COLOR_nitc__model__MClass___intro].val; /* _intro on <var:MClass> */
4964 if (unlikely(var5 == NULL)) {
4965 if(catchStack.cursor >= 0){
4966 longjmp(catchStack.envs[catchStack.cursor], 1);
4967 }
4968 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro");
4969 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 496);
4970 fatal_exit(1);
4971 }
4972 var3 = var5;
4973 RET_LABEL4:(void)0;
4974 }
4975 }
4976 {
4977 { /* Inline model$MClassDef$bound_mtype (var3) on <var3:MClassDef> */
4978 var8 = var3->attrs[COLOR_nitc__model__MClassDef___bound_mtype].val; /* _bound_mtype on <var3:MClassDef> */
4979 if (unlikely(var8 == NULL)) {
4980 if(catchStack.cursor >= 0){
4981 longjmp(catchStack.envs[catchStack.cursor], 1);
4982 }
4983 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype");
4984 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 594);
4985 fatal_exit(1);
4986 }
4987 var6 = var8;
4988 RET_LABEL7:(void)0;
4989 }
4990 }
4991 var_recv = var6;
4992 {
4993 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
4994 var11 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
4995 if (unlikely(var11 == NULL)) {
4996 if(catchStack.cursor >= 0){
4997 longjmp(catchStack.envs[catchStack.cursor], 1);
4998 }
4999 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
5000 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
5001 fatal_exit(1);
5002 }
5003 var9 = var11;
5004 RET_LABEL10:(void)0;
5005 }
5006 }
5007 {
5008 var12 = nitc___nitc__MType___has_mproperty(var_recv, var9, var_mproperty);
5009 }
5010 var13 = !var12;
5011 if (var13){
5012 goto RET_LABEL;
5013 } else {
5014 }
5015 {
5016 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
5017 var16 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
5018 if (unlikely(var16 == NULL)) {
5019 if(catchStack.cursor >= 0){
5020 longjmp(catchStack.envs[catchStack.cursor], 1);
5021 }
5022 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
5023 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
5024 fatal_exit(1);
5025 }
5026 var14 = var16;
5027 RET_LABEL15:(void)0;
5028 }
5029 }
5030 {
5031 var17 = nitc___nitc__MProperty___lookup_first_definition(var_mproperty, var14, var_recv);
5032 }
5033 var_d = var17;
5034 {
5035 nitc___nitc__RapidTypeAnalysis___add_call(self, var_d); /* Direct call rapid_type_analysis$RapidTypeAnalysis$add_call on <self:RapidTypeAnalysis>*/
5036 }
5037 RET_LABEL:;
5038 }
5039 /* method rapid_type_analysis$RapidTypeAnalysis$add_call for (self: RapidTypeAnalysis, MMethodDef) */
5040 void nitc___nitc__RapidTypeAnalysis___add_call(val* self, val* p0) {
5041 val* var_mpropdef /* var mpropdef: MMethodDef */;
5042 val* var /* : HashSet[MMethodDef] */;
5043 val* var2 /* : HashSet[MMethodDef] */;
5044 short int var3 /* : Bool */;
5045 val* var4 /* : HashSet[MMethodDef] */;
5046 val* var6 /* : HashSet[MMethodDef] */;
5047 val* var7 /* : HashSet[MModule] */;
5048 val* var9 /* : HashSet[MModule] */;
5049 val* var10 /* : MClassDef */;
5050 val* var12 /* : MClassDef */;
5051 val* var13 /* : MModule */;
5052 val* var15 /* : MModule */;
5053 val* var16 /* : List[MMethodDef] */;
5054 val* var18 /* : List[MMethodDef] */;
5055 val* var19 /* : MProperty */;
5056 val* var21 /* : MProperty */;
5057 val* var_mproperty /* var mproperty: MMethod */;
5058 val* var22 /* : Array[MPropDef] */;
5059 val* var24 /* : Array[MPropDef] */;
5060 long var25 /* : Int */;
5061 long var27 /* : Int */;
5062 short int var28 /* : Bool */;
5063 short int var30 /* : Bool */;
5064 int cltype;
5065 int idtype;
5066 const char* var_class_name;
5067 short int var31 /* : Bool */;
5068 val* var32 /* : Array[MPropDef] */;
5069 val* var34 /* : Array[MPropDef] */;
5070 val* var_ /* var : Array[MMethodDef] */;
5071 val* var35 /* : IndexedIterator[nullable Object] */;
5072 val* var_36 /* var : IndexedIterator[MMethodDef] */;
5073 short int var37 /* : Bool */;
5074 val* var38 /* : nullable Object */;
5075 val* var_d /* var d: MMethodDef */;
5076 val* var39 /* : HashSet[MMethodDef] */;
5077 val* var41 /* : HashSet[MMethodDef] */;
5078 short int var42 /* : Bool */;
5079 short int var43 /* : Bool */;
5080 val* var44 /* : Array[MMethod] */;
5081 val* var46 /* : Array[MMethod] */;
5082 val* var47 /* : MProperty */;
5083 val* var49 /* : MProperty */;
5084 var_mpropdef = p0;
5085 {
5086 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_methoddefs (self) on <self:RapidTypeAnalysis> */
5087 var2 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_methoddefs].val; /* _live_methoddefs on <self:RapidTypeAnalysis> */
5088 if (unlikely(var2 == NULL)) {
5089 if(catchStack.cursor >= 0){
5090 longjmp(catchStack.envs[catchStack.cursor], 1);
5091 }
5092 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methoddefs");
5093 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 79);
5094 fatal_exit(1);
5095 }
5096 var = var2;
5097 RET_LABEL1:(void)0;
5098 }
5099 }
5100 {
5101 var3 = core___core__HashSet___core__abstract_collection__Collection__has(var, var_mpropdef);
5102 }
5103 if (var3){
5104 goto RET_LABEL;
5105 } else {
5106 }
5107 {
5108 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_methoddefs (self) on <self:RapidTypeAnalysis> */
5109 var6 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_methoddefs].val; /* _live_methoddefs on <self:RapidTypeAnalysis> */
5110 if (unlikely(var6 == NULL)) {
5111 if(catchStack.cursor >= 0){
5112 longjmp(catchStack.envs[catchStack.cursor], 1);
5113 }
5114 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methoddefs");
5115 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 79);
5116 fatal_exit(1);
5117 }
5118 var4 = var6;
5119 RET_LABEL5:(void)0;
5120 }
5121 }
5122 {
5123 core___core__HashSet___core__abstract_collection__SimpleCollection__add(var4, var_mpropdef); /* Direct call hash_collection$HashSet$add on <var4:HashSet[MMethodDef]>*/
5124 }
5125 {
5126 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_mmodules (self) on <self:RapidTypeAnalysis> */
5127 var9 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_mmodules].val; /* _live_mmodules on <self:RapidTypeAnalysis> */
5128 if (unlikely(var9 == NULL)) {
5129 if(catchStack.cursor >= 0){
5130 longjmp(catchStack.envs[catchStack.cursor], 1);
5131 }
5132 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_mmodules");
5133 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 85);
5134 fatal_exit(1);
5135 }
5136 var7 = var9;
5137 RET_LABEL8:(void)0;
5138 }
5139 }
5140 {
5141 { /* Inline model$MPropDef$mclassdef (var_mpropdef) on <var_mpropdef:MMethodDef> */
5142 var12 = var_mpropdef->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on <var_mpropdef:MMethodDef> */
5143 if (unlikely(var12 == NULL)) {
5144 if(catchStack.cursor >= 0){
5145 longjmp(catchStack.envs[catchStack.cursor], 1);
5146 }
5147 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef");
5148 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2354);
5149 fatal_exit(1);
5150 }
5151 var10 = var12;
5152 RET_LABEL11:(void)0;
5153 }
5154 }
5155 {
5156 { /* Inline model$MClassDef$mmodule (var10) on <var10:MClassDef> */
5157 var15 = var10->attrs[COLOR_nitc__model__MClassDef___mmodule].val; /* _mmodule on <var10:MClassDef> */
5158 if (unlikely(var15 == NULL)) {
5159 if(catchStack.cursor >= 0){
5160 longjmp(catchStack.envs[catchStack.cursor], 1);
5161 }
5162 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mmodule");
5163 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 588);
5164 fatal_exit(1);
5165 }
5166 var13 = var15;
5167 RET_LABEL14:(void)0;
5168 }
5169 }
5170 {
5171 core___core__HashSet___core__abstract_collection__SimpleCollection__add(var7, var13); /* Direct call hash_collection$HashSet$add on <var7:HashSet[MModule]>*/
5172 }
5173 {
5174 { /* Inline rapid_type_analysis$RapidTypeAnalysis$todo (self) on <self:RapidTypeAnalysis> */
5175 var18 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___todo].val; /* _todo on <self:RapidTypeAnalysis> */
5176 if (unlikely(var18 == NULL)) {
5177 if(catchStack.cursor >= 0){
5178 longjmp(catchStack.envs[catchStack.cursor], 1);
5179 }
5180 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _todo");
5181 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 183);
5182 fatal_exit(1);
5183 }
5184 var16 = var18;
5185 RET_LABEL17:(void)0;
5186 }
5187 }
5188 {
5189 core___core__Sequence___SimpleCollection__add(var16, var_mpropdef); /* Direct call abstract_collection$Sequence$add on <var16:List[MMethodDef]>*/
5190 }
5191 {
5192 { /* Inline model$MPropDef$mproperty (var_mpropdef) on <var_mpropdef:MMethodDef> */
5193 var21 = var_mpropdef->attrs[COLOR_nitc__model__MPropDef___mproperty].val; /* _mproperty on <var_mpropdef:MMethodDef> */
5194 if (unlikely(var21 == NULL)) {
5195 if(catchStack.cursor >= 0){
5196 longjmp(catchStack.envs[catchStack.cursor], 1);
5197 }
5198 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty");
5199 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2357);
5200 fatal_exit(1);
5201 }
5202 var19 = var21;
5203 RET_LABEL20:(void)0;
5204 }
5205 }
5206 var_mproperty = var19;
5207 {
5208 { /* Inline model$MProperty$mpropdefs (var_mproperty) on <var_mproperty:MMethod> */
5209 var24 = var_mproperty->attrs[COLOR_nitc__model__MProperty___mpropdefs].val; /* _mpropdefs on <var_mproperty:MMethod> */
5210 if (unlikely(var24 == NULL)) {
5211 if(catchStack.cursor >= 0){
5212 longjmp(catchStack.envs[catchStack.cursor], 1);
5213 }
5214 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdefs");
5215 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2092);
5216 fatal_exit(1);
5217 }
5218 var22 = var24;
5219 RET_LABEL23:(void)0;
5220 }
5221 }
5222 {
5223 { /* Inline array$AbstractArrayRead$length (var22) on <var22:Array[MPropDef](Array[MMethodDef])> */
5224 var27 = var22->attrs[COLOR_core__array__AbstractArrayRead___length].l; /* _length on <var22:Array[MPropDef](Array[MMethodDef])> */
5225 var25 = var27;
5226 RET_LABEL26:(void)0;
5227 }
5228 }
5229 {
5230 { /* Inline kernel$Int$<= (var25,1l) on <var25:Int> */
5231 /* Covariant cast for argument 0 (i) <1l:Int> isa OTHER */
5232 /* <1l:Int> isa OTHER */
5233 var30 = 1; /* easy <1l:Int> isa OTHER*/
5234 if (unlikely(!var30)) {
5235 var_class_name = type_core__Int.name;
5236 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
5237 PRINT_ERROR(" (%s:%d)\n", FILE_core__kernel, 724);
5238 fatal_exit(1);
5239 }
5240 var31 = var25 <= 1l;
5241 var28 = var31;
5242 goto RET_LABEL29;
5243 RET_LABEL29:(void)0;
5244 }
5245 }
5246 if (var28){
5247 goto RET_LABEL;
5248 } else {
5249 }
5250 {
5251 { /* Inline model$MProperty$mpropdefs (var_mproperty) on <var_mproperty:MMethod> */
5252 var34 = var_mproperty->attrs[COLOR_nitc__model__MProperty___mpropdefs].val; /* _mpropdefs on <var_mproperty:MMethod> */
5253 if (unlikely(var34 == NULL)) {
5254 if(catchStack.cursor >= 0){
5255 longjmp(catchStack.envs[catchStack.cursor], 1);
5256 }
5257 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdefs");
5258 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2092);
5259 fatal_exit(1);
5260 }
5261 var32 = var34;
5262 RET_LABEL33:(void)0;
5263 }
5264 }
5265 var_ = var32;
5266 {
5267 var35 = core___core__AbstractArrayRead___core__abstract_collection__Collection__iterator(var_);
5268 }
5269 var_36 = var35;
5270 for(;;) {
5271 {
5272 var37 = ((short int(*)(val* self))((((long)var_36&3)?class_info[((long)var_36&3)]:var_36->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_36); /* is_ok on <var_36:IndexedIterator[MMethodDef]>*/
5273 }
5274 if (var37){
5275 } else {
5276 goto BREAK_label;
5277 }
5278 {
5279 var38 = ((val*(*)(val* self))((((long)var_36&3)?class_info[((long)var_36&3)]:var_36->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_36); /* item on <var_36:IndexedIterator[MMethodDef]>*/
5280 }
5281 var_d = var38;
5282 {
5283 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_methoddefs (self) on <self:RapidTypeAnalysis> */
5284 var41 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_methoddefs].val; /* _live_methoddefs on <self:RapidTypeAnalysis> */
5285 if (unlikely(var41 == NULL)) {
5286 if(catchStack.cursor >= 0){
5287 longjmp(catchStack.envs[catchStack.cursor], 1);
5288 }
5289 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methoddefs");
5290 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 79);
5291 fatal_exit(1);
5292 }
5293 var39 = var41;
5294 RET_LABEL40:(void)0;
5295 }
5296 }
5297 {
5298 var42 = core___core__HashSet___core__abstract_collection__Collection__has(var39, var_d);
5299 }
5300 var43 = !var42;
5301 if (var43){
5302 goto RET_LABEL;
5303 } else {
5304 }
5305 {
5306 ((void(*)(val* self))((((long)var_36&3)?class_info[((long)var_36&3)]:var_36->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_36); /* next on <var_36:IndexedIterator[MMethodDef]>*/
5307 }
5308 }
5309 BREAK_label: (void)0;
5310 {
5311 ((void(*)(val* self))((((long)var_36&3)?class_info[((long)var_36&3)]:var_36->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_36); /* finish on <var_36:IndexedIterator[MMethodDef]>*/
5312 }
5313 {
5314 { /* Inline rapid_type_analysis$RapidTypeAnalysis$totry_methods_to_remove (self) on <self:RapidTypeAnalysis> */
5315 var46 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___totry_methods_to_remove].val; /* _totry_methods_to_remove on <self:RapidTypeAnalysis> */
5316 if (unlikely(var46 == NULL)) {
5317 if(catchStack.cursor >= 0){
5318 longjmp(catchStack.envs[catchStack.cursor], 1);
5319 }
5320 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _totry_methods_to_remove");
5321 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 176);
5322 fatal_exit(1);
5323 }
5324 var44 = var46;
5325 RET_LABEL45:(void)0;
5326 }
5327 }
5328 {
5329 { /* Inline model$MPropDef$mproperty (var_mpropdef) on <var_mpropdef:MMethodDef> */
5330 var49 = var_mpropdef->attrs[COLOR_nitc__model__MPropDef___mproperty].val; /* _mproperty on <var_mpropdef:MMethodDef> */
5331 if (unlikely(var49 == NULL)) {
5332 if(catchStack.cursor >= 0){
5333 longjmp(catchStack.envs[catchStack.cursor], 1);
5334 }
5335 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty");
5336 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2357);
5337 fatal_exit(1);
5338 }
5339 var47 = var49;
5340 RET_LABEL48:(void)0;
5341 }
5342 }
5343 {
5344 core___core__Array___core__abstract_collection__SimpleCollection__add(var44, var47); /* Direct call array$Array$add on <var44:Array[MMethod]>*/
5345 }
5346 RET_LABEL:;
5347 }
5348 /* method rapid_type_analysis$RapidTypeAnalysis$add_send for (self: RapidTypeAnalysis, MType, MMethod) */
5349 void nitc___nitc__RapidTypeAnalysis___add_send(val* self, val* p0, val* p1) {
5350 val* var_recv /* var recv: MType */;
5351 val* var_mproperty /* var mproperty: MMethod */;
5352 val* var /* : HashSet[MMethod] */;
5353 val* var2 /* : HashSet[MMethod] */;
5354 short int var3 /* : Bool */;
5355 val* var4 /* : HashSet[MMethod] */;
5356 val* var6 /* : HashSet[MMethod] */;
5357 val* var7 /* : HashSet[MMethod] */;
5358 val* var9 /* : HashSet[MMethod] */;
5359 val* var10 /* : Array[MPropDef] */;
5360 val* var12 /* : Array[MPropDef] */;
5361 long var13 /* : Int */;
5362 long var15 /* : Int */;
5363 short int var16 /* : Bool */;
5364 short int var18 /* : Bool */;
5365 val* var19 /* : Array[MPropDef] */;
5366 val* var21 /* : Array[MPropDef] */;
5367 val* var22 /* : nullable Object */;
5368 val* var_d /* var d: MMethodDef */;
5369 val* var23 /* : HashSet[MMethod] */;
5370 val* var25 /* : HashSet[MMethod] */;
5371 val* var26 /* : HashSet[MClass] */;
5372 val* var28 /* : HashSet[MClass] */;
5373 val* var_ /* var : HashSet[MClass] */;
5374 val* var29 /* : Iterator[nullable Object] */;
5375 val* var_30 /* var : Iterator[MClass] */;
5376 short int var31 /* : Bool */;
5377 val* var32 /* : nullable Object */;
5378 val* var_c /* var c: MClass */;
5379 val* var33 /* : MClassDef */;
5380 val* var35 /* : MClassDef */;
5381 val* var36 /* : MClassType */;
5382 val* var38 /* : MClassType */;
5383 var_recv = p0;
5384 var_mproperty = p1;
5385 {
5386 { /* Inline rapid_type_analysis$RapidTypeAnalysis$try_methods (self) on <self:RapidTypeAnalysis> */
5387 var2 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___try_methods].val; /* _try_methods on <self:RapidTypeAnalysis> */
5388 if (unlikely(var2 == NULL)) {
5389 if(catchStack.cursor >= 0){
5390 longjmp(catchStack.envs[catchStack.cursor], 1);
5391 }
5392 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _try_methods");
5393 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 179);
5394 fatal_exit(1);
5395 }
5396 var = var2;
5397 RET_LABEL1:(void)0;
5398 }
5399 }
5400 {
5401 var3 = core___core__HashSet___core__abstract_collection__Collection__has(var, var_mproperty);
5402 }
5403 if (var3){
5404 goto RET_LABEL;
5405 } else {
5406 }
5407 {
5408 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_methods (self) on <self:RapidTypeAnalysis> */
5409 var6 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_methods].val; /* _live_methods on <self:RapidTypeAnalysis> */
5410 if (unlikely(var6 == NULL)) {
5411 if(catchStack.cursor >= 0){
5412 longjmp(catchStack.envs[catchStack.cursor], 1);
5413 }
5414 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methods");
5415 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 82);
5416 fatal_exit(1);
5417 }
5418 var4 = var6;
5419 RET_LABEL5:(void)0;
5420 }
5421 }
5422 {
5423 core___core__HashSet___core__abstract_collection__SimpleCollection__add(var4, var_mproperty); /* Direct call hash_collection$HashSet$add on <var4:HashSet[MMethod]>*/
5424 }
5425 {
5426 { /* Inline rapid_type_analysis$RapidTypeAnalysis$try_methods (self) on <self:RapidTypeAnalysis> */
5427 var9 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___try_methods].val; /* _try_methods on <self:RapidTypeAnalysis> */
5428 if (unlikely(var9 == NULL)) {
5429 if(catchStack.cursor >= 0){
5430 longjmp(catchStack.envs[catchStack.cursor], 1);
5431 }
5432 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _try_methods");
5433 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 179);
5434 fatal_exit(1);
5435 }
5436 var7 = var9;
5437 RET_LABEL8:(void)0;
5438 }
5439 }
5440 {
5441 core___core__HashSet___core__abstract_collection__SimpleCollection__add(var7, var_mproperty); /* Direct call hash_collection$HashSet$add on <var7:HashSet[MMethod]>*/
5442 }
5443 {
5444 { /* Inline model$MProperty$mpropdefs (var_mproperty) on <var_mproperty:MMethod> */
5445 var12 = var_mproperty->attrs[COLOR_nitc__model__MProperty___mpropdefs].val; /* _mpropdefs on <var_mproperty:MMethod> */
5446 if (unlikely(var12 == NULL)) {
5447 if(catchStack.cursor >= 0){
5448 longjmp(catchStack.envs[catchStack.cursor], 1);
5449 }
5450 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdefs");
5451 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2092);
5452 fatal_exit(1);
5453 }
5454 var10 = var12;
5455 RET_LABEL11:(void)0;
5456 }
5457 }
5458 {
5459 { /* Inline array$AbstractArrayRead$length (var10) on <var10:Array[MPropDef](Array[MMethodDef])> */
5460 var15 = var10->attrs[COLOR_core__array__AbstractArrayRead___length].l; /* _length on <var10:Array[MPropDef](Array[MMethodDef])> */
5461 var13 = var15;
5462 RET_LABEL14:(void)0;
5463 }
5464 }
5465 {
5466 { /* Inline kernel$Int$== (var13,1l) on <var13:Int> */
5467 var18 = var13 == 1l;
5468 var16 = var18;
5469 goto RET_LABEL17;
5470 RET_LABEL17:(void)0;
5471 }
5472 }
5473 if (var16){
5474 {
5475 { /* Inline model$MProperty$mpropdefs (var_mproperty) on <var_mproperty:MMethod> */
5476 var21 = var_mproperty->attrs[COLOR_nitc__model__MProperty___mpropdefs].val; /* _mpropdefs on <var_mproperty:MMethod> */
5477 if (unlikely(var21 == NULL)) {
5478 if(catchStack.cursor >= 0){
5479 longjmp(catchStack.envs[catchStack.cursor], 1);
5480 }
5481 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdefs");
5482 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2092);
5483 fatal_exit(1);
5484 }
5485 var19 = var21;
5486 RET_LABEL20:(void)0;
5487 }
5488 }
5489 {
5490 var22 = core___core__SequenceRead___Collection__first(var19);
5491 }
5492 var_d = var22;
5493 {
5494 nitc___nitc__RapidTypeAnalysis___add_call(self, var_d); /* Direct call rapid_type_analysis$RapidTypeAnalysis$add_call on <self:RapidTypeAnalysis>*/
5495 }
5496 goto RET_LABEL;
5497 } else {
5498 }
5499 {
5500 { /* Inline rapid_type_analysis$RapidTypeAnalysis$totry_methods (self) on <self:RapidTypeAnalysis> */
5501 var25 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___totry_methods].val; /* _totry_methods on <self:RapidTypeAnalysis> */
5502 if (unlikely(var25 == NULL)) {
5503 if(catchStack.cursor >= 0){
5504 longjmp(catchStack.envs[catchStack.cursor], 1);
5505 }
5506 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _totry_methods");
5507 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 173);
5508 fatal_exit(1);
5509 }
5510 var23 = var25;
5511 RET_LABEL24:(void)0;
5512 }
5513 }
5514 {
5515 core___core__HashSet___core__abstract_collection__SimpleCollection__add(var23, var_mproperty); /* Direct call hash_collection$HashSet$add on <var23:HashSet[MMethod]>*/
5516 }
5517 {
5518 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_classes (self) on <self:RapidTypeAnalysis> */
5519 var28 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_classes].val; /* _live_classes on <self:RapidTypeAnalysis> */
5520 if (unlikely(var28 == NULL)) {
5521 if(catchStack.cursor >= 0){
5522 longjmp(catchStack.envs[catchStack.cursor], 1);
5523 }
5524 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_classes");
5525 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 69);
5526 fatal_exit(1);
5527 }
5528 var26 = var28;
5529 RET_LABEL27:(void)0;
5530 }
5531 }
5532 var_ = var26;
5533 {
5534 var29 = core___core__HashSet___core__abstract_collection__Collection__iterator(var_);
5535 }
5536 var_30 = var29;
5537 for(;;) {
5538 {
5539 var31 = ((short int(*)(val* self))((((long)var_30&3)?class_info[((long)var_30&3)]:var_30->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_30); /* is_ok on <var_30:Iterator[MClass]>*/
5540 }
5541 if (var31){
5542 } else {
5543 goto BREAK_label;
5544 }
5545 {
5546 var32 = ((val*(*)(val* self))((((long)var_30&3)?class_info[((long)var_30&3)]:var_30->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_30); /* item on <var_30:Iterator[MClass]>*/
5547 }
5548 var_c = var32;
5549 {
5550 { /* Inline model$MClass$intro (var_c) on <var_c:MClass> */
5551 var35 = var_c->attrs[COLOR_nitc__model__MClass___intro].val; /* _intro on <var_c:MClass> */
5552 if (unlikely(var35 == NULL)) {
5553 if(catchStack.cursor >= 0){
5554 longjmp(catchStack.envs[catchStack.cursor], 1);
5555 }
5556 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro");
5557 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 496);
5558 fatal_exit(1);
5559 }
5560 var33 = var35;
5561 RET_LABEL34:(void)0;
5562 }
5563 }
5564 {
5565 { /* Inline model$MClassDef$bound_mtype (var33) on <var33:MClassDef> */
5566 var38 = var33->attrs[COLOR_nitc__model__MClassDef___bound_mtype].val; /* _bound_mtype on <var33:MClassDef> */
5567 if (unlikely(var38 == NULL)) {
5568 if(catchStack.cursor >= 0){
5569 longjmp(catchStack.envs[catchStack.cursor], 1);
5570 }
5571 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype");
5572 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 594);
5573 fatal_exit(1);
5574 }
5575 var36 = var38;
5576 RET_LABEL37:(void)0;
5577 }
5578 }
5579 {
5580 nitc___nitc__RapidTypeAnalysis___try_send(self, var36, var_mproperty); /* Direct call rapid_type_analysis$RapidTypeAnalysis$try_send on <self:RapidTypeAnalysis>*/
5581 }
5582 {
5583 ((void(*)(val* self))((((long)var_30&3)?class_info[((long)var_30&3)]:var_30->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_30); /* next on <var_30:Iterator[MClass]>*/
5584 }
5585 }
5586 BREAK_label: (void)0;
5587 {
5588 ((void(*)(val* self))((((long)var_30&3)?class_info[((long)var_30&3)]:var_30->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_30); /* finish on <var_30:Iterator[MClass]>*/
5589 }
5590 RET_LABEL:;
5591 }
5592 /* method rapid_type_analysis$RapidTypeAnalysis$try_super_send for (self: RapidTypeAnalysis, MClassType, MMethodDef) */
5593 void nitc___nitc__RapidTypeAnalysis___try_super_send(val* self, val* p0, val* p1) {
5594 val* var_recv /* var recv: MClassType */;
5595 val* var_mpropdef /* var mpropdef: MMethodDef */;
5596 val* var /* : MClass */;
5597 val* var2 /* : MClass */;
5598 val* var3 /* : MClassDef */;
5599 val* var5 /* : MClassDef */;
5600 val* var6 /* : MClassType */;
5601 val* var8 /* : MClassType */;
5602 val* var9 /* : MModule */;
5603 val* var11 /* : MModule */;
5604 val* var12 /* : Set[MClassDef] */;
5605 val* var13 /* : MClassDef */;
5606 val* var15 /* : MClassDef */;
5607 short int var16 /* : Bool */;
5608 short int var17 /* : Bool */;
5609 val* var18 /* : MModule */;
5610 val* var20 /* : MModule */;
5611 val* var21 /* : MPropDef */;
5612 val* var_d /* var d: MMethodDef */;
5613 var_recv = p0;
5614 var_mpropdef = p1;
5615 {
5616 { /* Inline model$MClassType$mclass (var_recv) on <var_recv:MClassType> */
5617 var2 = var_recv->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on <var_recv:MClassType> */
5618 if (unlikely(var2 == NULL)) {
5619 if(catchStack.cursor >= 0){
5620 longjmp(catchStack.envs[catchStack.cursor], 1);
5621 }
5622 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
5623 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197);
5624 fatal_exit(1);
5625 }
5626 var = var2;
5627 RET_LABEL1:(void)0;
5628 }
5629 }
5630 {
5631 { /* Inline model$MClass$intro (var) on <var:MClass> */
5632 var5 = var->attrs[COLOR_nitc__model__MClass___intro].val; /* _intro on <var:MClass> */
5633 if (unlikely(var5 == NULL)) {
5634 if(catchStack.cursor >= 0){
5635 longjmp(catchStack.envs[catchStack.cursor], 1);
5636 }
5637 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro");
5638 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 496);
5639 fatal_exit(1);
5640 }
5641 var3 = var5;
5642 RET_LABEL4:(void)0;
5643 }
5644 }
5645 {
5646 { /* Inline model$MClassDef$bound_mtype (var3) on <var3:MClassDef> */
5647 var8 = var3->attrs[COLOR_nitc__model__MClassDef___bound_mtype].val; /* _bound_mtype on <var3:MClassDef> */
5648 if (unlikely(var8 == NULL)) {
5649 if(catchStack.cursor >= 0){
5650 longjmp(catchStack.envs[catchStack.cursor], 1);
5651 }
5652 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype");
5653 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 594);
5654 fatal_exit(1);
5655 }
5656 var6 = var8;
5657 RET_LABEL7:(void)0;
5658 }
5659 }
5660 var_recv = var6;
5661 {
5662 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
5663 var11 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
5664 if (unlikely(var11 == NULL)) {
5665 if(catchStack.cursor >= 0){
5666 longjmp(catchStack.envs[catchStack.cursor], 1);
5667 }
5668 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
5669 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
5670 fatal_exit(1);
5671 }
5672 var9 = var11;
5673 RET_LABEL10:(void)0;
5674 }
5675 }
5676 {
5677 var12 = nitc___nitc__MClassType___MType__collect_mclassdefs(var_recv, var9);
5678 }
5679 {
5680 { /* Inline model$MPropDef$mclassdef (var_mpropdef) on <var_mpropdef:MMethodDef> */
5681 var15 = var_mpropdef->attrs[COLOR_nitc__model__MPropDef___mclassdef].val; /* _mclassdef on <var_mpropdef:MMethodDef> */
5682 if (unlikely(var15 == NULL)) {
5683 if(catchStack.cursor >= 0){
5684 longjmp(catchStack.envs[catchStack.cursor], 1);
5685 }
5686 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclassdef");
5687 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2354);
5688 fatal_exit(1);
5689 }
5690 var13 = var15;
5691 RET_LABEL14:(void)0;
5692 }
5693 }
5694 {
5695 var16 = ((short int(*)(val* self, val* p0))((((long)var12&3)?class_info[((long)var12&3)]:var12->class)->vft[COLOR_core__abstract_collection__Collection__has]))(var12, var13); /* has on <var12:Set[MClassDef]>*/
5696 }
5697 var17 = !var16;
5698 if (var17){
5699 goto RET_LABEL;
5700 } else {
5701 }
5702 {
5703 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (self) on <self:RapidTypeAnalysis> */
5704 var20 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <self:RapidTypeAnalysis> */
5705 if (unlikely(var20 == NULL)) {
5706 if(catchStack.cursor >= 0){
5707 longjmp(catchStack.envs[catchStack.cursor], 1);
5708 }
5709 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
5710 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
5711 fatal_exit(1);
5712 }
5713 var18 = var20;
5714 RET_LABEL19:(void)0;
5715 }
5716 }
5717 {
5718 var21 = nitc___nitc__MPropDef___lookup_next_definition(var_mpropdef, var18, var_recv);
5719 }
5720 var_d = var21;
5721 {
5722 nitc___nitc__RapidTypeAnalysis___add_call(self, var_d); /* Direct call rapid_type_analysis$RapidTypeAnalysis$add_call on <self:RapidTypeAnalysis>*/
5723 }
5724 RET_LABEL:;
5725 }
5726 /* method rapid_type_analysis$RapidTypeAnalysis$add_super_send for (self: RapidTypeAnalysis, MType, MMethodDef) */
5727 void nitc___nitc__RapidTypeAnalysis___add_super_send(val* self, val* p0, val* p1) {
5728 val* var_recv /* var recv: MType */;
5729 val* var_mpropdef /* var mpropdef: MMethodDef */;
5730 short int var /* : Bool */;
5731 short int var2 /* : Bool */;
5732 val* var3 /* : HashSet[MMethodDef] */;
5733 val* var5 /* : HashSet[MMethodDef] */;
5734 short int var6 /* : Bool */;
5735 val* var7 /* : HashSet[MMethodDef] */;
5736 val* var9 /* : HashSet[MMethodDef] */;
5737 val* var10 /* : HashSet[MClass] */;
5738 val* var12 /* : HashSet[MClass] */;
5739 val* var_ /* var : HashSet[MClass] */;
5740 val* var13 /* : Iterator[nullable Object] */;
5741 val* var_14 /* var : Iterator[MClass] */;
5742 short int var15 /* : Bool */;
5743 val* var16 /* : nullable Object */;
5744 val* var_c /* var c: MClass */;
5745 val* var17 /* : MClassDef */;
5746 val* var19 /* : MClassDef */;
5747 val* var20 /* : MClassType */;
5748 val* var22 /* : MClassType */;
5749 var_recv = p0;
5750 var_mpropdef = p1;
5751 {
5752 { /* Inline modelize_property$MPropDef$has_supercall (var_mpropdef) on <var_mpropdef:MMethodDef> */
5753 var2 = var_mpropdef->attrs[COLOR_nitc__modelize_property__MPropDef___has_supercall].s; /* _has_supercall on <var_mpropdef:MMethodDef> */
5754 var = var2;
5755 RET_LABEL1:(void)0;
5756 }
5757 }
5758 if (unlikely(!var)) {
5759 if(catchStack.cursor >= 0){
5760 longjmp(catchStack.envs[catchStack.cursor], 1);
5761 }
5762 PRINT_ERROR("Runtime error: %s", "Assert failed");
5763 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 452);
5764 fatal_exit(1);
5765 }
5766 {
5767 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_super_sends (self) on <self:RapidTypeAnalysis> */
5768 var5 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_super_sends].val; /* _live_super_sends on <self:RapidTypeAnalysis> */
5769 if (unlikely(var5 == NULL)) {
5770 if(catchStack.cursor >= 0){
5771 longjmp(catchStack.envs[catchStack.cursor], 1);
5772 }
5773 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_super_sends");
5774 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 118);
5775 fatal_exit(1);
5776 }
5777 var3 = var5;
5778 RET_LABEL4:(void)0;
5779 }
5780 }
5781 {
5782 var6 = core___core__HashSet___core__abstract_collection__Collection__has(var3, var_mpropdef);
5783 }
5784 if (var6){
5785 goto RET_LABEL;
5786 } else {
5787 }
5788 {
5789 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_super_sends (self) on <self:RapidTypeAnalysis> */
5790 var9 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_super_sends].val; /* _live_super_sends on <self:RapidTypeAnalysis> */
5791 if (unlikely(var9 == NULL)) {
5792 if(catchStack.cursor >= 0){
5793 longjmp(catchStack.envs[catchStack.cursor], 1);
5794 }
5795 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_super_sends");
5796 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 118);
5797 fatal_exit(1);
5798 }
5799 var7 = var9;
5800 RET_LABEL8:(void)0;
5801 }
5802 }
5803 {
5804 core___core__HashSet___core__abstract_collection__SimpleCollection__add(var7, var_mpropdef); /* Direct call hash_collection$HashSet$add on <var7:HashSet[MMethodDef]>*/
5805 }
5806 {
5807 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_classes (self) on <self:RapidTypeAnalysis> */
5808 var12 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_classes].val; /* _live_classes on <self:RapidTypeAnalysis> */
5809 if (unlikely(var12 == NULL)) {
5810 if(catchStack.cursor >= 0){
5811 longjmp(catchStack.envs[catchStack.cursor], 1);
5812 }
5813 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_classes");
5814 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 69);
5815 fatal_exit(1);
5816 }
5817 var10 = var12;
5818 RET_LABEL11:(void)0;
5819 }
5820 }
5821 var_ = var10;
5822 {
5823 var13 = core___core__HashSet___core__abstract_collection__Collection__iterator(var_);
5824 }
5825 var_14 = var13;
5826 for(;;) {
5827 {
5828 var15 = ((short int(*)(val* self))((((long)var_14&3)?class_info[((long)var_14&3)]:var_14->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_14); /* is_ok on <var_14:Iterator[MClass]>*/
5829 }
5830 if (var15){
5831 } else {
5832 goto BREAK_label;
5833 }
5834 {
5835 var16 = ((val*(*)(val* self))((((long)var_14&3)?class_info[((long)var_14&3)]:var_14->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_14); /* item on <var_14:Iterator[MClass]>*/
5836 }
5837 var_c = var16;
5838 {
5839 { /* Inline model$MClass$intro (var_c) on <var_c:MClass> */
5840 var19 = var_c->attrs[COLOR_nitc__model__MClass___intro].val; /* _intro on <var_c:MClass> */
5841 if (unlikely(var19 == NULL)) {
5842 if(catchStack.cursor >= 0){
5843 longjmp(catchStack.envs[catchStack.cursor], 1);
5844 }
5845 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _intro");
5846 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 496);
5847 fatal_exit(1);
5848 }
5849 var17 = var19;
5850 RET_LABEL18:(void)0;
5851 }
5852 }
5853 {
5854 { /* Inline model$MClassDef$bound_mtype (var17) on <var17:MClassDef> */
5855 var22 = var17->attrs[COLOR_nitc__model__MClassDef___bound_mtype].val; /* _bound_mtype on <var17:MClassDef> */
5856 if (unlikely(var22 == NULL)) {
5857 if(catchStack.cursor >= 0){
5858 longjmp(catchStack.envs[catchStack.cursor], 1);
5859 }
5860 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _bound_mtype");
5861 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 594);
5862 fatal_exit(1);
5863 }
5864 var20 = var22;
5865 RET_LABEL21:(void)0;
5866 }
5867 }
5868 {
5869 nitc___nitc__RapidTypeAnalysis___try_super_send(self, var20, var_mpropdef); /* Direct call rapid_type_analysis$RapidTypeAnalysis$try_super_send on <self:RapidTypeAnalysis>*/
5870 }
5871 {
5872 ((void(*)(val* self))((((long)var_14&3)?class_info[((long)var_14&3)]:var_14->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_14); /* next on <var_14:Iterator[MClass]>*/
5873 }
5874 }
5875 BREAK_label: (void)0;
5876 {
5877 ((void(*)(val* self))((((long)var_14&3)?class_info[((long)var_14&3)]:var_14->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_14); /* finish on <var_14:Iterator[MClass]>*/
5878 }
5879 RET_LABEL:;
5880 }
5881 /* method rapid_type_analysis$RapidTypeAnalysis$init for (self: RapidTypeAnalysis) */
5882 void nitc___nitc__RapidTypeAnalysis___core__kernel__Object__init(val* self) {
5883 {
5884 ((void(*)(val* self))(self->class->vft[COLOR_nitc___nitc__RapidTypeAnalysis___core__kernel__Object__init]))(self); /* init on <self:RapidTypeAnalysis>*/
5885 }
5886 RET_LABEL:;
5887 }
5888 /* method rapid_type_analysis$RapidTypeVisitor$analysis for (self: RapidTypeVisitor): RapidTypeAnalysis */
5889 val* nitc___nitc__RapidTypeVisitor___analysis(val* self) {
5890 val* var /* : RapidTypeAnalysis */;
5891 val* var1 /* : RapidTypeAnalysis */;
5892 var1 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
5893 if (unlikely(var1 == NULL)) {
5894 if(catchStack.cursor >= 0){
5895 longjmp(catchStack.envs[catchStack.cursor], 1);
5896 }
5897 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
5898 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 465);
5899 fatal_exit(1);
5900 }
5901 var = var1;
5902 RET_LABEL:;
5903 return var;
5904 }
5905 /* method rapid_type_analysis$RapidTypeVisitor$analysis= for (self: RapidTypeVisitor, RapidTypeAnalysis) */
5906 void nitc___nitc__RapidTypeVisitor___analysis_61d(val* self, val* p0) {
5907 self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___analysis].val = p0; /* _analysis on <self:RapidTypeVisitor> */
5908 RET_LABEL:;
5909 }
5910 /* method rapid_type_analysis$RapidTypeVisitor$receiver for (self: RapidTypeVisitor): MClassType */
5911 val* nitc___nitc__RapidTypeVisitor___receiver(val* self) {
5912 val* var /* : MClassType */;
5913 val* var1 /* : MClassType */;
5914 var1 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___receiver].val; /* _receiver on <self:RapidTypeVisitor> */
5915 if (unlikely(var1 == NULL)) {
5916 if(catchStack.cursor >= 0){
5917 longjmp(catchStack.envs[catchStack.cursor], 1);
5918 }
5919 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _receiver");
5920 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 466);
5921 fatal_exit(1);
5922 }
5923 var = var1;
5924 RET_LABEL:;
5925 return var;
5926 }
5927 /* method rapid_type_analysis$RapidTypeVisitor$receiver= for (self: RapidTypeVisitor, MClassType) */
5928 void nitc___nitc__RapidTypeVisitor___receiver_61d(val* self, val* p0) {
5929 self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___receiver].val = p0; /* _receiver on <self:RapidTypeVisitor> */
5930 RET_LABEL:;
5931 }
5932 /* method rapid_type_analysis$RapidTypeVisitor$mpropdef= for (self: RapidTypeVisitor, MPropDef) */
5933 void nitc___nitc__RapidTypeVisitor___mpropdef_61d(val* self, val* p0) {
5934 self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___mpropdef].val = p0; /* _mpropdef on <self:RapidTypeVisitor> */
5935 RET_LABEL:;
5936 }
5937 /* method rapid_type_analysis$RapidTypeVisitor$init for (self: RapidTypeVisitor) */
5938 void nitc___nitc__RapidTypeVisitor___core__kernel__Object__init(val* self) {
5939 val* var /* : MClassType */;
5940 val* var2 /* : MClassType */;
5941 short int var3 /* : Bool */;
5942 short int var4 /* : Bool */;
5943 {
5944 ((void(*)(val* self))(self->class->vft[COLOR_nitc___nitc__RapidTypeVisitor___core__kernel__Object__init]))(self); /* init on <self:RapidTypeVisitor>*/
5945 }
5946 {
5947 { /* Inline rapid_type_analysis$RapidTypeVisitor$receiver (self) on <self:RapidTypeVisitor> */
5948 var2 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___receiver].val; /* _receiver on <self:RapidTypeVisitor> */
5949 if (unlikely(var2 == NULL)) {
5950 if(catchStack.cursor >= 0){
5951 longjmp(catchStack.envs[catchStack.cursor], 1);
5952 }
5953 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _receiver");
5954 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 466);
5955 fatal_exit(1);
5956 }
5957 var = var2;
5958 RET_LABEL1:(void)0;
5959 }
5960 }
5961 {
5962 var3 = ((short int(*)(val* self))(var->class->vft[COLOR_nitc__model__MType__need_anchor]))(var); /* need_anchor on <var:MClassType>*/
5963 }
5964 var4 = !var3;
5965 if (unlikely(!var4)) {
5966 if(catchStack.cursor >= 0){
5967 longjmp(catchStack.envs[catchStack.cursor], 1);
5968 }
5969 PRINT_ERROR("Runtime error: %s", "Assert failed");
5970 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 471);
5971 fatal_exit(1);
5972 }
5973 RET_LABEL:;
5974 }
5975 /* method rapid_type_analysis$RapidTypeVisitor$visit for (self: RapidTypeVisitor, ANode) */
5976 void nitc___nitc__RapidTypeVisitor___nitc__parser_nodes__Visitor__visit(val* self, val* p0) {
5977 val* var_n /* var n: ANode */;
5978 short int var /* : Bool */;
5979 int cltype;
5980 int idtype;
5981 short int var1 /* : Bool */;
5982 val* var2 /* : nullable MType */;
5983 short int var3 /* : Bool */;
5984 short int var4 /* : Bool */;
5985 val* var_other /* var other: nullable Object */;
5986 short int var6 /* : Bool */;
5987 short int var7 /* : Bool */;
5988 short int var_ /* var : Bool */;
5989 short int var8 /* : Bool */;
5990 short int var10 /* : Bool */;
5991 val* var11 /* : nullable MType */;
5992 val* var13 /* : nullable MType */;
5993 val* var_implicit_cast_to /* var implicit_cast_to: nullable MType */;
5994 short int var14 /* : Bool */;
5995 short int var15 /* : Bool */;
5996 short int var17 /* : Bool */;
5997 short int var18 /* : Bool */;
5998 short int var19 /* : Bool */;
5999 int cltype20;
6000 int idtype21;
6001 short int var22 /* : Bool */;
6002 var_n = p0;
6003 /* <var_n:ANode> isa AExpr */
6004 cltype = type_nitc__AExpr.color;
6005 idtype = type_nitc__AExpr.id;
6006 if(cltype >= var_n->type->table_size) {
6007 var = 0;
6008 } else {
6009 var = var_n->type->type_table[cltype] == idtype;
6010 }
6011 if (var){
6012 {
6013 var2 = ((val*(*)(val* self))(var_n->class->vft[COLOR_nitc__typing__AExpr__mtype]))(var_n); /* mtype on <var_n:ANode(AExpr)>*/
6014 }
6015 if (var2 == NULL) {
6016 var3 = 0; /* is null */
6017 } else {
6018 var3 = 1; /* arg is null and recv is not */
6019 }
6020 if (0) {
6021 { /* Inline kernel$Object$!= (var2,((val*)NULL)) on <var2:nullable MType> */
6022 var_other = ((val*)NULL);
6023 {
6024 var6 = ((short int(*)(val* self, val* p0))(var2->class->vft[COLOR_core__kernel__Object___61d_61d]))(var2, var_other); /* == on <var2:nullable MType(MType)>*/
6025 }
6026 var7 = !var6;
6027 var4 = var7;
6028 goto RET_LABEL5;
6029 RET_LABEL5:(void)0;
6030 }
6031 var3 = var4;
6032 }
6033 var_ = var3;
6034 if (var3){
6035 var1 = var_;
6036 } else {
6037 {
6038 { /* Inline typing$AExpr$is_typed (var_n) on <var_n:ANode(AExpr)> */
6039 var10 = var_n->attrs[COLOR_nitc__typing__AExpr___is_typed].s; /* _is_typed on <var_n:ANode(AExpr)> */
6040 var8 = var10;
6041 RET_LABEL9:(void)0;
6042 }
6043 }
6044 var1 = var8;
6045 }
6046 if (var1){
6047 {
6048 ((void(*)(val* self, val* p0))(var_n->class->vft[COLOR_nitc__rapid_type_analysis__ANode__accept_rapid_type_visitor]))(var_n, self); /* accept_rapid_type_visitor on <var_n:ANode(AExpr)>*/
6049 }
6050 {
6051 { /* Inline typing$AExpr$implicit_cast_to (var_n) on <var_n:ANode(AExpr)> */
6052 var13 = var_n->attrs[COLOR_nitc__typing__AExpr___implicit_cast_to].val; /* _implicit_cast_to on <var_n:ANode(AExpr)> */
6053 var11 = var13;
6054 RET_LABEL12:(void)0;
6055 }
6056 }
6057 var_implicit_cast_to = var11;
6058 if (var_implicit_cast_to == NULL) {
6059 var14 = 0; /* is null */
6060 } else {
6061 var14 = 1; /* arg is null and recv is not */
6062 }
6063 if (0) {
6064 { /* Inline kernel$Object$!= (var_implicit_cast_to,((val*)NULL)) on <var_implicit_cast_to:nullable MType> */
6065 var_other = ((val*)NULL);
6066 {
6067 var17 = ((short int(*)(val* self, val* p0))(var_implicit_cast_to->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_implicit_cast_to, var_other); /* == on <var_implicit_cast_to:nullable MType(MType)>*/
6068 }
6069 var18 = !var17;
6070 var15 = var18;
6071 goto RET_LABEL16;
6072 RET_LABEL16:(void)0;
6073 }
6074 var14 = var15;
6075 }
6076 if (var14){
6077 {
6078 nitc___nitc__RapidTypeVisitor___add_cast_type(self, var_implicit_cast_to); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_cast_type on <self:RapidTypeVisitor>*/
6079 }
6080 } else {
6081 }
6082 } else {
6083 }
6084 } else {
6085 {
6086 ((void(*)(val* self, val* p0))(var_n->class->vft[COLOR_nitc__rapid_type_analysis__ANode__accept_rapid_type_visitor]))(var_n, self); /* accept_rapid_type_visitor on <var_n:ANode>*/
6087 }
6088 }
6089 /* <var_n:ANode> isa AAnnotations */
6090 cltype20 = type_nitc__AAnnotations.color;
6091 idtype21 = type_nitc__AAnnotations.id;
6092 if(cltype20 >= var_n->type->table_size) {
6093 var19 = 0;
6094 } else {
6095 var19 = var_n->type->type_table[cltype20] == idtype21;
6096 }
6097 var22 = !var19;
6098 if (var22){
6099 {
6100 ((void(*)(val* self, val* p0))(var_n->class->vft[COLOR_nitc__parser_nodes__ANode__visit_all]))(var_n, self); /* visit_all on <var_n:ANode>*/
6101 }
6102 } else {
6103 }
6104 RET_LABEL:;
6105 }
6106 /* method rapid_type_analysis$RapidTypeVisitor$cleanup_type for (self: RapidTypeVisitor, MType): nullable MClassType */
6107 val* nitc___nitc__RapidTypeVisitor___cleanup_type(val* self, val* p0) {
6108 val* var /* : nullable MClassType */;
6109 val* var_mtype /* var mtype: MType */;
6110 val* var1 /* : RapidTypeAnalysis */;
6111 val* var3 /* : RapidTypeAnalysis */;
6112 val* var4 /* : MModule */;
6113 val* var6 /* : MModule */;
6114 val* var7 /* : MClassType */;
6115 val* var9 /* : MClassType */;
6116 val* var10 /* : MType */;
6117 short int var11 /* : Bool */;
6118 int cltype;
6119 int idtype;
6120 val* var12 /* : MType */;
6121 short int var13 /* : Bool */;
6122 int cltype14;
6123 int idtype15;
6124 short int var16 /* : Bool */;
6125 short int var17 /* : Bool */;
6126 var_mtype = p0;
6127 {
6128 { /* Inline rapid_type_analysis$RapidTypeVisitor$analysis (self) on <self:RapidTypeVisitor> */
6129 var3 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
6130 if (unlikely(var3 == NULL)) {
6131 if(catchStack.cursor >= 0){
6132 longjmp(catchStack.envs[catchStack.cursor], 1);
6133 }
6134 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
6135 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 465);
6136 fatal_exit(1);
6137 }
6138 var1 = var3;
6139 RET_LABEL2:(void)0;
6140 }
6141 }
6142 {
6143 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (var1) on <var1:RapidTypeAnalysis> */
6144 var6 = var1->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <var1:RapidTypeAnalysis> */
6145 if (unlikely(var6 == NULL)) {
6146 if(catchStack.cursor >= 0){
6147 longjmp(catchStack.envs[catchStack.cursor], 1);
6148 }
6149 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
6150 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
6151 fatal_exit(1);
6152 }
6153 var4 = var6;
6154 RET_LABEL5:(void)0;
6155 }
6156 }
6157 {
6158 { /* Inline rapid_type_analysis$RapidTypeVisitor$receiver (self) on <self:RapidTypeVisitor> */
6159 var9 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___receiver].val; /* _receiver on <self:RapidTypeVisitor> */
6160 if (unlikely(var9 == NULL)) {
6161 if(catchStack.cursor >= 0){
6162 longjmp(catchStack.envs[catchStack.cursor], 1);
6163 }
6164 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _receiver");
6165 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 466);
6166 fatal_exit(1);
6167 }
6168 var7 = var9;
6169 RET_LABEL8:(void)0;
6170 }
6171 }
6172 {
6173 var10 = ((val*(*)(val* self, val* p0, val* p1))(var_mtype->class->vft[COLOR_nitc__model__MType__anchor_to]))(var_mtype, var4, var7); /* anchor_to on <var_mtype:MType>*/
6174 }
6175 var_mtype = var10;
6176 /* <var_mtype:MType> isa MNullType */
6177 cltype = type_nitc__MNullType.color;
6178 idtype = type_nitc__MNullType.id;
6179 if(cltype >= var_mtype->type->table_size) {
6180 var11 = 0;
6181 } else {
6182 var11 = var_mtype->type->type_table[cltype] == idtype;
6183 }
6184 if (var11){
6185 var = ((val*)NULL);
6186 goto RET_LABEL;
6187 } else {
6188 }
6189 {
6190 var12 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nitc__model__MType__undecorate]))(var_mtype); /* undecorate on <var_mtype:MType>*/
6191 }
6192 var_mtype = var12;
6193 /* <var_mtype:MType> isa MClassType */
6194 cltype14 = type_nitc__MClassType.color;
6195 idtype15 = type_nitc__MClassType.id;
6196 if(cltype14 >= var_mtype->type->table_size) {
6197 var13 = 0;
6198 } else {
6199 var13 = var_mtype->type->type_table[cltype14] == idtype15;
6200 }
6201 if (unlikely(!var13)) {
6202 if(catchStack.cursor >= 0){
6203 longjmp(catchStack.envs[catchStack.cursor], 1);
6204 }
6205 PRINT_ERROR("Runtime error: %s", "Assert failed");
6206 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 497);
6207 fatal_exit(1);
6208 }
6209 {
6210 var16 = ((short int(*)(val* self))(var_mtype->class->vft[COLOR_nitc__model__MType__need_anchor]))(var_mtype); /* need_anchor on <var_mtype:MType(MClassType)>*/
6211 }
6212 var17 = !var16;
6213 if (unlikely(!var17)) {
6214 if(catchStack.cursor >= 0){
6215 longjmp(catchStack.envs[catchStack.cursor], 1);
6216 }
6217 PRINT_ERROR("Runtime error: %s", "Assert failed");
6218 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 498);
6219 fatal_exit(1);
6220 }
6221 var = var_mtype;
6222 goto RET_LABEL;
6223 RET_LABEL:;
6224 return var;
6225 }
6226 /* method rapid_type_analysis$RapidTypeVisitor$get_method for (self: RapidTypeVisitor, MType, String): MMethod */
6227 val* nitc___nitc__RapidTypeVisitor___get_method(val* self, val* p0, val* p1) {
6228 val* var /* : MMethod */;
6229 val* var_recv /* var recv: MType */;
6230 val* var_name /* var name: String */;
6231 val* var1 /* : nullable MClassType */;
6232 val* var_mtype /* var mtype: nullable MClassType */;
6233 short int var2 /* : Bool */;
6234 short int var3 /* : Bool */;
6235 val* var_other /* var other: nullable Object */;
6236 short int var5 /* : Bool */;
6237 short int var6 /* : Bool */;
6238 val* var7 /* : RapidTypeAnalysis */;
6239 val* var9 /* : RapidTypeAnalysis */;
6240 val* var10 /* : ModelBuilder */;
6241 val* var12 /* : ModelBuilder */;
6242 val* var13 /* : nullable ANode */;
6243 val* var15 /* : nullable ANode */;
6244 val* var16 /* : MClass */;
6245 val* var18 /* : MClass */;
6246 val* var19 /* : RapidTypeAnalysis */;
6247 val* var21 /* : RapidTypeAnalysis */;
6248 val* var22 /* : MModule */;
6249 val* var24 /* : MModule */;
6250 val* var25 /* : MMethod */;
6251 var_recv = p0;
6252 var_name = p1;
6253 {
6254 var1 = nitc___nitc__RapidTypeVisitor___cleanup_type(self, var_recv);
6255 }
6256 var_mtype = var1;
6257 if (var_mtype == NULL) {
6258 var2 = 0; /* is null */
6259 } else {
6260 var2 = 1; /* arg is null and recv is not */
6261 }
6262 if (0) {
6263 { /* Inline kernel$Object$!= (var_mtype,((val*)NULL)) on <var_mtype:nullable MClassType> */
6264 var_other = ((val*)NULL);
6265 {
6266 var5 = ((short int(*)(val* self, val* p0))(var_mtype->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_mtype, var_other); /* == on <var_mtype:nullable MClassType(MClassType)>*/
6267 }
6268 var6 = !var5;
6269 var3 = var6;
6270 goto RET_LABEL4;
6271 RET_LABEL4:(void)0;
6272 }
6273 var2 = var3;
6274 }
6275 if (unlikely(!var2)) {
6276 if(catchStack.cursor >= 0){
6277 longjmp(catchStack.envs[catchStack.cursor], 1);
6278 }
6279 PRINT_ERROR("Runtime error: %s", "Assert failed");
6280 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 505);
6281 fatal_exit(1);
6282 }
6283 {
6284 { /* Inline rapid_type_analysis$RapidTypeVisitor$analysis (self) on <self:RapidTypeVisitor> */
6285 var9 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
6286 if (unlikely(var9 == NULL)) {
6287 if(catchStack.cursor >= 0){
6288 longjmp(catchStack.envs[catchStack.cursor], 1);
6289 }
6290 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
6291 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 465);
6292 fatal_exit(1);
6293 }
6294 var7 = var9;
6295 RET_LABEL8:(void)0;
6296 }
6297 }
6298 {
6299 { /* Inline rapid_type_analysis$RapidTypeAnalysis$modelbuilder (var7) on <var7:RapidTypeAnalysis> */
6300 var12 = var7->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___modelbuilder].val; /* _modelbuilder on <var7:RapidTypeAnalysis> */
6301 if (unlikely(var12 == NULL)) {
6302 if(catchStack.cursor >= 0){
6303 longjmp(catchStack.envs[catchStack.cursor], 1);
6304 }
6305 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _modelbuilder");
6306 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 53);
6307 fatal_exit(1);
6308 }
6309 var10 = var12;
6310 RET_LABEL11:(void)0;
6311 }
6312 }
6313 {
6314 { /* Inline parser_nodes$Visitor$current_node (self) on <self:RapidTypeVisitor> */
6315 var15 = self->attrs[COLOR_nitc__parser_nodes__Visitor___current_node].val; /* _current_node on <self:RapidTypeVisitor> */
6316 var13 = var15;
6317 RET_LABEL14:(void)0;
6318 }
6319 }
6320 if (unlikely(var13 == NULL)) {
6321 if(catchStack.cursor >= 0){
6322 longjmp(catchStack.envs[catchStack.cursor], 1);
6323 }
6324 PRINT_ERROR("Runtime error: %s", "Cast failed");
6325 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 506);
6326 fatal_exit(1);
6327 }
6328 {
6329 { /* Inline model$MClassType$mclass (var_mtype) on <var_mtype:nullable MClassType(MClassType)> */
6330 var18 = var_mtype->attrs[COLOR_nitc__model__MClassType___mclass].val; /* _mclass on <var_mtype:nullable MClassType(MClassType)> */
6331 if (unlikely(var18 == NULL)) {
6332 if(catchStack.cursor >= 0){
6333 longjmp(catchStack.envs[catchStack.cursor], 1);
6334 }
6335 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mclass");
6336 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 1197);
6337 fatal_exit(1);
6338 }
6339 var16 = var18;
6340 RET_LABEL17:(void)0;
6341 }
6342 }
6343 {
6344 { /* Inline rapid_type_analysis$RapidTypeVisitor$analysis (self) on <self:RapidTypeVisitor> */
6345 var21 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
6346 if (unlikely(var21 == NULL)) {
6347 if(catchStack.cursor >= 0){
6348 longjmp(catchStack.envs[catchStack.cursor], 1);
6349 }
6350 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
6351 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 465);
6352 fatal_exit(1);
6353 }
6354 var19 = var21;
6355 RET_LABEL20:(void)0;
6356 }
6357 }
6358 {
6359 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (var19) on <var19:RapidTypeAnalysis> */
6360 var24 = var19->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <var19:RapidTypeAnalysis> */
6361 if (unlikely(var24 == NULL)) {
6362 if(catchStack.cursor >= 0){
6363 longjmp(catchStack.envs[catchStack.cursor], 1);
6364 }
6365 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
6366 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
6367 fatal_exit(1);
6368 }
6369 var22 = var24;
6370 RET_LABEL23:(void)0;
6371 }
6372 }
6373 {
6374 var25 = nitc___nitc__ModelBuilder___force_get_primitive_method(var10, var13, var_name, var16, var22);
6375 }
6376 var = var25;
6377 goto RET_LABEL;
6378 RET_LABEL:;
6379 return var;
6380 }
6381 /* method rapid_type_analysis$RapidTypeVisitor$add_type for (self: RapidTypeVisitor, MClassType) */
6382 void nitc___nitc__RapidTypeVisitor___add_type(val* self, val* p0) {
6383 val* var_mtype /* var mtype: MClassType */;
6384 val* var /* : RapidTypeAnalysis */;
6385 val* var2 /* : RapidTypeAnalysis */;
6386 val* var3 /* : MClassType */;
6387 val* var5 /* : MClassType */;
6388 var_mtype = p0;
6389 {
6390 { /* Inline rapid_type_analysis$RapidTypeVisitor$analysis (self) on <self:RapidTypeVisitor> */
6391 var2 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
6392 if (unlikely(var2 == NULL)) {
6393 if(catchStack.cursor >= 0){
6394 longjmp(catchStack.envs[catchStack.cursor], 1);
6395 }
6396 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
6397 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 465);
6398 fatal_exit(1);
6399 }
6400 var = var2;
6401 RET_LABEL1:(void)0;
6402 }
6403 }
6404 {
6405 { /* Inline rapid_type_analysis$RapidTypeVisitor$receiver (self) on <self:RapidTypeVisitor> */
6406 var5 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___receiver].val; /* _receiver on <self:RapidTypeVisitor> */
6407 if (unlikely(var5 == NULL)) {
6408 if(catchStack.cursor >= 0){
6409 longjmp(catchStack.envs[catchStack.cursor], 1);
6410 }
6411 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _receiver");
6412 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 466);
6413 fatal_exit(1);
6414 }
6415 var3 = var5;
6416 RET_LABEL4:(void)0;
6417 }
6418 }
6419 {
6420 nitc___nitc__RapidTypeAnalysis___add_new(var, var3, var_mtype); /* Direct call rapid_type_analysis$RapidTypeAnalysis$add_new on <var:RapidTypeAnalysis>*/
6421 }
6422 RET_LABEL:;
6423 }
6424 /* method rapid_type_analysis$RapidTypeVisitor$add_monomorphic_send for (self: RapidTypeVisitor, MType, MMethod) */
6425 void nitc___nitc__RapidTypeVisitor___add_monomorphic_send(val* self, val* p0, val* p1) {
6426 val* var_mtype /* var mtype: MType */;
6427 val* var_mproperty /* var mproperty: MMethod */;
6428 val* var /* : RapidTypeAnalysis */;
6429 val* var2 /* : RapidTypeAnalysis */;
6430 val* var3 /* : HashSet[MMethod] */;
6431 val* var5 /* : HashSet[MMethod] */;
6432 val* var6 /* : RapidTypeAnalysis */;
6433 val* var8 /* : RapidTypeAnalysis */;
6434 short int var9 /* : Bool */;
6435 int cltype;
6436 int idtype;
6437 const char* var_class_name;
6438 var_mtype = p0;
6439 var_mproperty = p1;
6440 {
6441 { /* Inline rapid_type_analysis$RapidTypeVisitor$analysis (self) on <self:RapidTypeVisitor> */
6442 var2 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
6443 if (unlikely(var2 == NULL)) {
6444 if(catchStack.cursor >= 0){
6445 longjmp(catchStack.envs[catchStack.cursor], 1);
6446 }
6447 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
6448 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 465);
6449 fatal_exit(1);
6450 }
6451 var = var2;
6452 RET_LABEL1:(void)0;
6453 }
6454 }
6455 {
6456 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_methods (var) on <var:RapidTypeAnalysis> */
6457 var5 = var->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_methods].val; /* _live_methods on <var:RapidTypeAnalysis> */
6458 if (unlikely(var5 == NULL)) {
6459 if(catchStack.cursor >= 0){
6460 longjmp(catchStack.envs[catchStack.cursor], 1);
6461 }
6462 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_methods");
6463 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 82);
6464 fatal_exit(1);
6465 }
6466 var3 = var5;
6467 RET_LABEL4:(void)0;
6468 }
6469 }
6470 {
6471 core___core__HashSet___core__abstract_collection__SimpleCollection__add(var3, var_mproperty); /* Direct call hash_collection$HashSet$add on <var3:HashSet[MMethod]>*/
6472 }
6473 {
6474 { /* Inline rapid_type_analysis$RapidTypeVisitor$analysis (self) on <self:RapidTypeVisitor> */
6475 var8 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
6476 if (unlikely(var8 == NULL)) {
6477 if(catchStack.cursor >= 0){
6478 longjmp(catchStack.envs[catchStack.cursor], 1);
6479 }
6480 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
6481 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 465);
6482 fatal_exit(1);
6483 }
6484 var6 = var8;
6485 RET_LABEL7:(void)0;
6486 }
6487 }
6488 /* <var_mtype:MType> isa MClassType */
6489 cltype = type_nitc__MClassType.color;
6490 idtype = type_nitc__MClassType.id;
6491 if(cltype >= var_mtype->type->table_size) {
6492 var9 = 0;
6493 } else {
6494 var9 = var_mtype->type->type_table[cltype] == idtype;
6495 }
6496 if (unlikely(!var9)) {
6497 var_class_name = var_mtype == NULL ? "null" : var_mtype->type->name;
6498 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
6499 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 514);
6500 fatal_exit(1);
6501 }
6502 {
6503 nitc___nitc__RapidTypeAnalysis___try_send(var6, var_mtype, var_mproperty); /* Direct call rapid_type_analysis$RapidTypeAnalysis$try_send on <var6:RapidTypeAnalysis>*/
6504 }
6505 RET_LABEL:;
6506 }
6507 /* method rapid_type_analysis$RapidTypeVisitor$add_cast_type for (self: RapidTypeVisitor, MType) */
6508 void nitc___nitc__RapidTypeVisitor___add_cast_type(val* self, val* p0) {
6509 val* var_mtype /* var mtype: MType */;
6510 val* var /* : RapidTypeAnalysis */;
6511 val* var2 /* : RapidTypeAnalysis */;
6512 var_mtype = p0;
6513 {
6514 { /* Inline rapid_type_analysis$RapidTypeVisitor$analysis (self) on <self:RapidTypeVisitor> */
6515 var2 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
6516 if (unlikely(var2 == NULL)) {
6517 if(catchStack.cursor >= 0){
6518 longjmp(catchStack.envs[catchStack.cursor], 1);
6519 }
6520 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
6521 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 465);
6522 fatal_exit(1);
6523 }
6524 var = var2;
6525 RET_LABEL1:(void)0;
6526 }
6527 }
6528 {
6529 nitc___nitc__RapidTypeAnalysis___add_cast(var, var_mtype); /* Direct call rapid_type_analysis$RapidTypeAnalysis$add_cast on <var:RapidTypeAnalysis>*/
6530 }
6531 RET_LABEL:;
6532 }
6533 /* method rapid_type_analysis$RapidTypeVisitor$add_callsite for (self: RapidTypeVisitor, nullable CallSite) */
6534 void nitc___nitc__RapidTypeVisitor___add_callsite(val* self, val* p0) {
6535 val* var_callsite /* var callsite: nullable CallSite */;
6536 short int var /* : Bool */;
6537 short int var1 /* : Bool */;
6538 val* var_other /* var other: nullable Object */;
6539 short int var3 /* : Bool */;
6540 short int var4 /* : Bool */;
6541 val* var5 /* : MMethodDef */;
6542 val* var7 /* : MMethodDef */;
6543 val* var8 /* : Array[MProperty] */;
6544 val* var10 /* : Array[MProperty] */;
6545 val* var_ /* var : Array[MProperty] */;
6546 val* var11 /* : IndexedIterator[nullable Object] */;
6547 val* var_12 /* var : IndexedIterator[MProperty] */;
6548 short int var13 /* : Bool */;
6549 val* var14 /* : nullable Object */;
6550 val* var_m /* var m: MProperty */;
6551 short int var15 /* : Bool */;
6552 int cltype;
6553 int idtype;
6554 val* var16 /* : RapidTypeAnalysis */;
6555 val* var18 /* : RapidTypeAnalysis */;
6556 val* var19 /* : MType */;
6557 val* var21 /* : MType */;
6558 val* var22 /* : RapidTypeAnalysis */;
6559 val* var24 /* : RapidTypeAnalysis */;
6560 val* var25 /* : MType */;
6561 val* var27 /* : MType */;
6562 val* var28 /* : MMethod */;
6563 val* var30 /* : MMethod */;
6564 val* var31 /* : RapidTypeAnalysis */;
6565 val* var33 /* : RapidTypeAnalysis */;
6566 val* var34 /* : HashSet[CallSite] */;
6567 val* var36 /* : HashSet[CallSite] */;
6568 var_callsite = p0;
6569 if (var_callsite == NULL) {
6570 var = 0; /* is null */
6571 } else {
6572 var = 1; /* arg is null and recv is not */
6573 }
6574 if (0) {
6575 { /* Inline kernel$Object$!= (var_callsite,((val*)NULL)) on <var_callsite:nullable CallSite> */
6576 var_other = ((val*)NULL);
6577 {
6578 var3 = ((short int(*)(val* self, val* p0))(var_callsite->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_callsite, var_other); /* == on <var_callsite:nullable CallSite(CallSite)>*/
6579 }
6580 var4 = !var3;
6581 var1 = var4;
6582 goto RET_LABEL2;
6583 RET_LABEL2:(void)0;
6584 }
6585 var = var1;
6586 }
6587 if (var){
6588 {
6589 { /* Inline typing$CallSite$mpropdef (var_callsite) on <var_callsite:nullable CallSite(CallSite)> */
6590 var7 = var_callsite->attrs[COLOR_nitc__typing__CallSite___mpropdef].val; /* _mpropdef on <var_callsite:nullable CallSite(CallSite)> */
6591 if (unlikely(var7 == NULL)) {
6592 if(catchStack.cursor >= 0){
6593 longjmp(catchStack.envs[catchStack.cursor], 1);
6594 }
6595 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mpropdef");
6596 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__typing, 659);
6597 fatal_exit(1);
6598 }
6599 var5 = var7;
6600 RET_LABEL6:(void)0;
6601 }
6602 }
6603 {
6604 { /* Inline model$MMethodDef$initializers (var5) on <var5:MMethodDef> */
6605 var10 = var5->attrs[COLOR_nitc__model__MMethodDef___initializers].val; /* _initializers on <var5:MMethodDef> */
6606 if (unlikely(var10 == NULL)) {
6607 if(catchStack.cursor >= 0){
6608 longjmp(catchStack.envs[catchStack.cursor], 1);
6609 }
6610 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _initializers");
6611 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__model, 2492);
6612 fatal_exit(1);
6613 }
6614 var8 = var10;
6615 RET_LABEL9:(void)0;
6616 }
6617 }
6618 var_ = var8;
6619 {
6620 var11 = core___core__AbstractArrayRead___core__abstract_collection__Collection__iterator(var_);
6621 }
6622 var_12 = var11;
6623 for(;;) {
6624 {
6625 var13 = ((short int(*)(val* self))((((long)var_12&3)?class_info[((long)var_12&3)]:var_12->class)->vft[COLOR_core__abstract_collection__Iterator__is_ok]))(var_12); /* is_ok on <var_12:IndexedIterator[MProperty]>*/
6626 }
6627 if (var13){
6628 } else {
6629 goto BREAK_label;
6630 }
6631 {
6632 var14 = ((val*(*)(val* self))((((long)var_12&3)?class_info[((long)var_12&3)]:var_12->class)->vft[COLOR_core__abstract_collection__Iterator__item]))(var_12); /* item on <var_12:IndexedIterator[MProperty]>*/
6633 }
6634 var_m = var14;
6635 /* <var_m:MProperty> isa MMethod */
6636 cltype = type_nitc__MMethod.color;
6637 idtype = type_nitc__MMethod.id;
6638 if(cltype >= var_m->type->table_size) {
6639 var15 = 0;
6640 } else {
6641 var15 = var_m->type->type_table[cltype] == idtype;
6642 }
6643 if (var15){
6644 {
6645 { /* Inline rapid_type_analysis$RapidTypeVisitor$analysis (self) on <self:RapidTypeVisitor> */
6646 var18 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
6647 if (unlikely(var18 == NULL)) {
6648 if(catchStack.cursor >= 0){
6649 longjmp(catchStack.envs[catchStack.cursor], 1);
6650 }
6651 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
6652 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 465);
6653 fatal_exit(1);
6654 }
6655 var16 = var18;
6656 RET_LABEL17:(void)0;
6657 }
6658 }
6659 {
6660 { /* Inline typing$CallSite$recv (var_callsite) on <var_callsite:nullable CallSite(CallSite)> */
6661 var21 = var_callsite->attrs[COLOR_nitc__typing__CallSite___recv].val; /* _recv on <var_callsite:nullable CallSite(CallSite)> */
6662 if (unlikely(var21 == NULL)) {
6663 if(catchStack.cursor >= 0){
6664 longjmp(catchStack.envs[catchStack.cursor], 1);
6665 }
6666 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _recv");
6667 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__typing, 642);
6668 fatal_exit(1);
6669 }
6670 var19 = var21;
6671 RET_LABEL20:(void)0;
6672 }
6673 }
6674 {
6675 nitc___nitc__RapidTypeAnalysis___add_send(var16, var19, var_m); /* Direct call rapid_type_analysis$RapidTypeAnalysis$add_send on <var16:RapidTypeAnalysis>*/
6676 }
6677 } else {
6678 }
6679 {
6680 ((void(*)(val* self))((((long)var_12&3)?class_info[((long)var_12&3)]:var_12->class)->vft[COLOR_core__abstract_collection__Iterator__next]))(var_12); /* next on <var_12:IndexedIterator[MProperty]>*/
6681 }
6682 }
6683 BREAK_label: (void)0;
6684 {
6685 ((void(*)(val* self))((((long)var_12&3)?class_info[((long)var_12&3)]:var_12->class)->vft[COLOR_core__abstract_collection__Iterator__finish]))(var_12); /* finish on <var_12:IndexedIterator[MProperty]>*/
6686 }
6687 {
6688 { /* Inline rapid_type_analysis$RapidTypeVisitor$analysis (self) on <self:RapidTypeVisitor> */
6689 var24 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
6690 if (unlikely(var24 == NULL)) {
6691 if(catchStack.cursor >= 0){
6692 longjmp(catchStack.envs[catchStack.cursor], 1);
6693 }
6694 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
6695 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 465);
6696 fatal_exit(1);
6697 }
6698 var22 = var24;
6699 RET_LABEL23:(void)0;
6700 }
6701 }
6702 {
6703 { /* Inline typing$CallSite$recv (var_callsite) on <var_callsite:nullable CallSite(CallSite)> */
6704 var27 = var_callsite->attrs[COLOR_nitc__typing__CallSite___recv].val; /* _recv on <var_callsite:nullable CallSite(CallSite)> */
6705 if (unlikely(var27 == NULL)) {
6706 if(catchStack.cursor >= 0){
6707 longjmp(catchStack.envs[catchStack.cursor], 1);
6708 }
6709 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _recv");
6710 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__typing, 642);
6711 fatal_exit(1);
6712 }
6713 var25 = var27;
6714 RET_LABEL26:(void)0;
6715 }
6716 }
6717 {
6718 { /* Inline typing$CallSite$mproperty (var_callsite) on <var_callsite:nullable CallSite(CallSite)> */
6719 var30 = var_callsite->attrs[COLOR_nitc__typing__CallSite___mproperty].val; /* _mproperty on <var_callsite:nullable CallSite(CallSite)> */
6720 if (unlikely(var30 == NULL)) {
6721 if(catchStack.cursor >= 0){
6722 longjmp(catchStack.envs[catchStack.cursor], 1);
6723 }
6724 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mproperty");
6725 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__typing, 656);
6726 fatal_exit(1);
6727 }
6728 var28 = var30;
6729 RET_LABEL29:(void)0;
6730 }
6731 }
6732 {
6733 nitc___nitc__RapidTypeAnalysis___add_send(var22, var25, var28); /* Direct call rapid_type_analysis$RapidTypeAnalysis$add_send on <var22:RapidTypeAnalysis>*/
6734 }
6735 {
6736 { /* Inline rapid_type_analysis$RapidTypeVisitor$analysis (self) on <self:RapidTypeVisitor> */
6737 var33 = self->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <self:RapidTypeVisitor> */
6738 if (unlikely(var33 == NULL)) {
6739 if(catchStack.cursor >= 0){
6740 longjmp(catchStack.envs[catchStack.cursor], 1);
6741 }
6742 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
6743 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 465);
6744 fatal_exit(1);
6745 }
6746 var31 = var33;
6747 RET_LABEL32:(void)0;
6748 }
6749 }
6750 {
6751 { /* Inline rapid_type_analysis$RapidTypeAnalysis$live_callsites (var31) on <var31:RapidTypeAnalysis> */
6752 var36 = var31->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___live_callsites].val; /* _live_callsites on <var31:RapidTypeAnalysis> */
6753 if (unlikely(var36 == NULL)) {
6754 if(catchStack.cursor >= 0){
6755 longjmp(catchStack.envs[catchStack.cursor], 1);
6756 }
6757 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _live_callsites");
6758 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 89);
6759 fatal_exit(1);
6760 }
6761 var34 = var36;
6762 RET_LABEL35:(void)0;
6763 }
6764 }
6765 {
6766 core___core__HashSet___core__abstract_collection__SimpleCollection__add(var34, var_callsite); /* Direct call hash_collection$HashSet$add on <var34:HashSet[CallSite]>*/
6767 }
6768 } else {
6769 }
6770 RET_LABEL:;
6771 }
6772 /* method rapid_type_analysis$ANode$accept_rapid_type_visitor for (self: ANode, RapidTypeVisitor) */
6773 void nitc__rapid_type_analysis___ANode___accept_rapid_type_visitor(val* self, val* p0) {
6774 val* var_v /* var v: RapidTypeVisitor */;
6775 var_v = p0;
6776 RET_LABEL:;
6777 }
6778 /* method rapid_type_analysis$AExpr$allocate_mtype for (self: AExpr, RapidTypeVisitor) */
6779 void nitc__rapid_type_analysis___AExpr___allocate_mtype(val* self, val* p0) {
6780 val* var_v /* var v: RapidTypeVisitor */;
6781 val* var /* : nullable MType */;
6782 val* var_mtype /* var mtype: nullable MType */;
6783 short int var1 /* : Bool */;
6784 int cltype;
6785 int idtype;
6786 short int var2 /* : Bool */;
6787 val* var3 /* : nullable MType */;
6788 short int var4 /* : Bool */;
6789 int cltype5;
6790 int idtype6;
6791 const char* var_class_name;
6792 var_v = p0;
6793 {
6794 var = ((val*(*)(val* self))(self->class->vft[COLOR_nitc__typing__AExpr__mtype]))(self); /* mtype on <self:AExpr>*/
6795 }
6796 var_mtype = var;
6797 /* <var_mtype:nullable MType> isa MClassType */
6798 cltype = type_nitc__MClassType.color;
6799 idtype = type_nitc__MClassType.id;
6800 if(var_mtype == NULL) {
6801 var1 = 0;
6802 } else {
6803 if(cltype >= var_mtype->type->table_size) {
6804 var1 = 0;
6805 } else {
6806 var1 = var_mtype->type->type_table[cltype] == idtype;
6807 }
6808 }
6809 var2 = !var1;
6810 if (var2){
6811 goto RET_LABEL;
6812 } else {
6813 }
6814 {
6815 var3 = ((val*(*)(val* self))(self->class->vft[COLOR_nitc__typing__AExpr__mtype]))(self); /* mtype on <self:AExpr>*/
6816 }
6817 /* <var3:nullable MType> isa MClassType */
6818 cltype5 = type_nitc__MClassType.color;
6819 idtype6 = type_nitc__MClassType.id;
6820 if(var3 == NULL) {
6821 var4 = 0;
6822 } else {
6823 if(cltype5 >= var3->type->table_size) {
6824 var4 = 0;
6825 } else {
6826 var4 = var3->type->type_table[cltype5] == idtype6;
6827 }
6828 }
6829 if (unlikely(!var4)) {
6830 var_class_name = var3 == NULL ? "null" : var3->type->name;
6831 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
6832 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 547);
6833 fatal_exit(1);
6834 }
6835 {
6836 nitc___nitc__RapidTypeVisitor___add_type(var_v, var3); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_type on <var_v:RapidTypeVisitor>*/
6837 }
6838 RET_LABEL:;
6839 }
6840 /* method rapid_type_analysis$AIntegerExpr$accept_rapid_type_visitor for (self: AIntegerExpr, RapidTypeVisitor) */
6841 void nitc__rapid_type_analysis___AIntegerExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
6842 val* var_v /* var v: RapidTypeVisitor */;
6843 var_v = p0;
6844 {
6845 nitc__rapid_type_analysis___AExpr___allocate_mtype(self, var_v); /* Direct call rapid_type_analysis$AExpr$allocate_mtype on <self:AIntegerExpr>*/
6846 }
6847 RET_LABEL:;
6848 }
6849 /* method rapid_type_analysis$AFloatExpr$accept_rapid_type_visitor for (self: AFloatExpr, RapidTypeVisitor) */
6850 void nitc__rapid_type_analysis___AFloatExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
6851 val* var_v /* var v: RapidTypeVisitor */;
6852 var_v = p0;
6853 {
6854 nitc__rapid_type_analysis___AExpr___allocate_mtype(self, var_v); /* Direct call rapid_type_analysis$AExpr$allocate_mtype on <self:AFloatExpr>*/
6855 }
6856 RET_LABEL:;
6857 }
6858 /* method rapid_type_analysis$ACharExpr$accept_rapid_type_visitor for (self: ACharExpr, RapidTypeVisitor) */
6859 void nitc__rapid_type_analysis___ACharExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
6860 val* var_v /* var v: RapidTypeVisitor */;
6861 var_v = p0;
6862 {
6863 nitc__rapid_type_analysis___AExpr___allocate_mtype(self, var_v); /* Direct call rapid_type_analysis$AExpr$allocate_mtype on <self:ACharExpr>*/
6864 }
6865 RET_LABEL:;
6866 }
6867 /* method rapid_type_analysis$AArrayExpr$accept_rapid_type_visitor for (self: AArrayExpr, RapidTypeVisitor) */
6868 void nitc__rapid_type_analysis___AArrayExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
6869 val* var_v /* var v: RapidTypeVisitor */;
6870 val* var /* : nullable MType */;
6871 val* var2 /* : nullable MType */;
6872 short int var3 /* : Bool */;
6873 int cltype;
6874 int idtype;
6875 const char* var_class_name;
6876 val* var_mtype /* var mtype: MClassType */;
6877 val* var4 /* : RapidTypeAnalysis */;
6878 val* var6 /* : RapidTypeAnalysis */;
6879 val* var7 /* : MModule */;
6880 val* var9 /* : MModule */;
6881 val* var10 /* : Array[MType] */;
6882 val* var11 /* : nullable Object */;
6883 val* var12 /* : MClassType */;
6884 val* var_native /* var native: MClassType */;
6885 val* var13 /* : nullable MClassType */;
6886 static val* varonce;
6887 val* var14 /* : String */;
6888 char* var15 /* : CString */;
6889 val* var16 /* : String */;
6890 val* var17 /* : nullable Int */;
6891 val* var18 /* : nullable Int */;
6892 val* var19 /* : nullable Bool */;
6893 val* var20 /* : nullable Bool */;
6894 val* var21 /* : MMethod */;
6895 val* var_prop /* var prop: MMethod */;
6896 val* var22 /* : nullable CallSite */;
6897 val* var24 /* : nullable CallSite */;
6898 val* var25 /* : nullable CallSite */;
6899 val* var27 /* : nullable CallSite */;
6900 var_v = p0;
6901 {
6902 { /* Inline typing$AExpr$mtype (self) on <self:AArrayExpr> */
6903 var2 = self->attrs[COLOR_nitc__typing__AExpr___mtype].val; /* _mtype on <self:AArrayExpr> */
6904 var = var2;
6905 RET_LABEL1:(void)0;
6906 }
6907 }
6908 /* <var:nullable MType> isa MClassType */
6909 cltype = type_nitc__MClassType.color;
6910 idtype = type_nitc__MClassType.id;
6911 if(var == NULL) {
6912 var3 = 0;
6913 } else {
6914 if(cltype >= var->type->table_size) {
6915 var3 = 0;
6916 } else {
6917 var3 = var->type->type_table[cltype] == idtype;
6918 }
6919 }
6920 if (unlikely(!var3)) {
6921 var_class_name = var == NULL ? "null" : var->type->name;
6922 PRINT_ERROR("Runtime error: Cast failed. Expected `%s`, got `%s`", "MClassType", var_class_name);
6923 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 575);
6924 fatal_exit(1);
6925 }
6926 var_mtype = var;
6927 {
6928 nitc___nitc__RapidTypeVisitor___add_type(var_v, var_mtype); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_type on <var_v:RapidTypeVisitor>*/
6929 }
6930 {
6931 { /* Inline rapid_type_analysis$RapidTypeVisitor$analysis (var_v) on <var_v:RapidTypeVisitor> */
6932 var6 = var_v->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <var_v:RapidTypeVisitor> */
6933 if (unlikely(var6 == NULL)) {
6934 if(catchStack.cursor >= 0){
6935 longjmp(catchStack.envs[catchStack.cursor], 1);
6936 }
6937 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
6938 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 465);
6939 fatal_exit(1);
6940 }
6941 var4 = var6;
6942 RET_LABEL5:(void)0;
6943 }
6944 }
6945 {
6946 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (var4) on <var4:RapidTypeAnalysis> */
6947 var9 = var4->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <var4:RapidTypeAnalysis> */
6948 if (unlikely(var9 == NULL)) {
6949 if(catchStack.cursor >= 0){
6950 longjmp(catchStack.envs[catchStack.cursor], 1);
6951 }
6952 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
6953 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
6954 fatal_exit(1);
6955 }
6956 var7 = var9;
6957 RET_LABEL8:(void)0;
6958 }
6959 }
6960 {
6961 var10 = ((val*(*)(val* self))(var_mtype->class->vft[COLOR_nitc__model__MClassType__arguments]))(var_mtype); /* arguments on <var_mtype:MClassType>*/
6962 }
6963 {
6964 var11 = core___core__SequenceRead___Collection__first(var10);
6965 }
6966 {
6967 var12 = nitc__model___MModule___native_array_type(var7, var11);
6968 }
6969 var_native = var12;
6970 {
6971 nitc___nitc__RapidTypeVisitor___add_type(var_v, var_native); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_type on <var_v:RapidTypeVisitor>*/
6972 }
6973 {
6974 var13 = nitc___nitc__RapidTypeVisitor___cleanup_type(var_v, var_mtype);
6975 }
6976 if (unlikely(var13 == NULL)) {
6977 if(catchStack.cursor >= 0){
6978 longjmp(catchStack.envs[catchStack.cursor], 1);
6979 }
6980 PRINT_ERROR("Runtime error: %s", "Cast failed");
6981 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 579);
6982 fatal_exit(1);
6983 }
6984 var_mtype = var13;
6985 if (likely(varonce!=NULL)) {
6986 var14 = varonce;
6987 } else {
6988 var15 = "with_native";
6989 var17 = (val*)(11l<<2|1);
6990 var18 = (val*)(11l<<2|1);
6991 var19 = (val*)((long)(0)<<2|3);
6992 var20 = (val*)((long)(0)<<2|3);
6993 var16 = core__flat___CString___to_s_unsafe(var15, var17, var18, var19, var20);
6994 var14 = var16;
6995 varonce = var14;
6996 }
6997 {
6998 var21 = nitc___nitc__RapidTypeVisitor___get_method(var_v, var_mtype, var14);
6999 }
7000 var_prop = var21;
7001 {
7002 nitc___nitc__RapidTypeVisitor___add_monomorphic_send(var_v, var_mtype, var_prop); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_monomorphic_send on <var_v:RapidTypeVisitor>*/
7003 }
7004 {
7005 { /* Inline typing$AArrayExpr$with_capacity_callsite (self) on <self:AArrayExpr> */
7006 var24 = self->attrs[COLOR_nitc__typing__AArrayExpr___with_capacity_callsite].val; /* _with_capacity_callsite on <self:AArrayExpr> */
7007 var22 = var24;
7008 RET_LABEL23:(void)0;
7009 }
7010 }
7011 {
7012 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var22); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7013 }
7014 {
7015 { /* Inline typing$AArrayExpr$push_callsite (self) on <self:AArrayExpr> */
7016 var27 = self->attrs[COLOR_nitc__typing__AArrayExpr___push_callsite].val; /* _push_callsite on <self:AArrayExpr> */
7017 var25 = var27;
7018 RET_LABEL26:(void)0;
7019 }
7020 }
7021 {
7022 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var25); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7023 }
7024 RET_LABEL:;
7025 }
7026 /* method rapid_type_analysis$AStringFormExpr$accept_rapid_type_visitor for (self: AStringFormExpr, RapidTypeVisitor) */
7027 void nitc__rapid_type_analysis___AStringFormExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
7028 val* var_v /* var v: RapidTypeVisitor */;
7029 val* var /* : RapidTypeAnalysis */;
7030 val* var2 /* : RapidTypeAnalysis */;
7031 val* var3 /* : MModule */;
7032 val* var5 /* : MModule */;
7033 val* var6 /* : MClassType */;
7034 val* var_native /* var native: MClassType */;
7035 static val* varonce;
7036 val* var7 /* : String */;
7037 char* var8 /* : CString */;
7038 val* var9 /* : String */;
7039 val* var10 /* : nullable Int */;
7040 val* var11 /* : nullable Int */;
7041 val* var12 /* : nullable Bool */;
7042 val* var13 /* : nullable Bool */;
7043 val* var14 /* : MMethod */;
7044 val* var_prop /* var prop: MMethod */;
7045 val* var15 /* : nullable CallSite */;
7046 val* var17 /* : nullable CallSite */;
7047 val* var18 /* : nullable CallSite */;
7048 val* var20 /* : nullable CallSite */;
7049 val* var21 /* : nullable CallSite */;
7050 val* var23 /* : nullable CallSite */;
7051 val* var24 /* : nullable CallSite */;
7052 val* var26 /* : nullable CallSite */;
7053 val* var27 /* : nullable CallSite */;
7054 val* var29 /* : nullable CallSite */;
7055 var_v = p0;
7056 {
7057 { /* Inline rapid_type_analysis$RapidTypeVisitor$analysis (var_v) on <var_v:RapidTypeVisitor> */
7058 var2 = var_v->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <var_v:RapidTypeVisitor> */
7059 if (unlikely(var2 == NULL)) {
7060 if(catchStack.cursor >= 0){
7061 longjmp(catchStack.envs[catchStack.cursor], 1);
7062 }
7063 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
7064 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 465);
7065 fatal_exit(1);
7066 }
7067 var = var2;
7068 RET_LABEL1:(void)0;
7069 }
7070 }
7071 {
7072 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (var) on <var:RapidTypeAnalysis> */
7073 var5 = var->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <var:RapidTypeAnalysis> */
7074 if (unlikely(var5 == NULL)) {
7075 if(catchStack.cursor >= 0){
7076 longjmp(catchStack.envs[catchStack.cursor], 1);
7077 }
7078 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
7079 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
7080 fatal_exit(1);
7081 }
7082 var3 = var5;
7083 RET_LABEL4:(void)0;
7084 }
7085 }
7086 {
7087 var6 = nitc__model___MModule___c_string_type(var3);
7088 }
7089 var_native = var6;
7090 {
7091 nitc___nitc__RapidTypeVisitor___add_type(var_v, var_native); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_type on <var_v:RapidTypeVisitor>*/
7092 }
7093 if (likely(varonce!=NULL)) {
7094 var7 = varonce;
7095 } else {
7096 var8 = "to_s_unsafe";
7097 var10 = (val*)(11l<<2|1);
7098 var11 = (val*)(11l<<2|1);
7099 var12 = (val*)((long)(0)<<2|3);
7100 var13 = (val*)((long)(0)<<2|3);
7101 var9 = core__flat___CString___to_s_unsafe(var8, var10, var11, var12, var13);
7102 var7 = var9;
7103 varonce = var7;
7104 }
7105 {
7106 var14 = nitc___nitc__RapidTypeVisitor___get_method(var_v, var_native, var7);
7107 }
7108 var_prop = var14;
7109 {
7110 nitc___nitc__RapidTypeVisitor___add_monomorphic_send(var_v, var_native, var_prop); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_monomorphic_send on <var_v:RapidTypeVisitor>*/
7111 }
7112 {
7113 { /* Inline typing$AugmentedStringFormExpr$to_re (self) on <self:AStringFormExpr> */
7114 var17 = self->attrs[COLOR_nitc__typing__AugmentedStringFormExpr___to_re].val; /* _to_re on <self:AStringFormExpr> */
7115 var15 = var17;
7116 RET_LABEL16:(void)0;
7117 }
7118 }
7119 {
7120 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var15); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7121 }
7122 {
7123 { /* Inline typing$AugmentedStringFormExpr$ignore_case (self) on <self:AStringFormExpr> */
7124 var20 = self->attrs[COLOR_nitc__typing__AugmentedStringFormExpr___ignore_case].val; /* _ignore_case on <self:AStringFormExpr> */
7125 var18 = var20;
7126 RET_LABEL19:(void)0;
7127 }
7128 }
7129 {
7130 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var18); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7131 }
7132 {
7133 { /* Inline typing$AugmentedStringFormExpr$newline (self) on <self:AStringFormExpr> */
7134 var23 = self->attrs[COLOR_nitc__typing__AugmentedStringFormExpr___newline].val; /* _newline on <self:AStringFormExpr> */
7135 var21 = var23;
7136 RET_LABEL22:(void)0;
7137 }
7138 }
7139 {
7140 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var21); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7141 }
7142 {
7143 { /* Inline typing$AugmentedStringFormExpr$extended (self) on <self:AStringFormExpr> */
7144 var26 = self->attrs[COLOR_nitc__typing__AugmentedStringFormExpr___extended].val; /* _extended on <self:AStringFormExpr> */
7145 var24 = var26;
7146 RET_LABEL25:(void)0;
7147 }
7148 }
7149 {
7150 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var24); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7151 }
7152 {
7153 { /* Inline typing$AugmentedStringFormExpr$to_bytes_with_copy (self) on <self:AStringFormExpr> */
7154 var29 = self->attrs[COLOR_nitc__typing__AugmentedStringFormExpr___to_bytes_with_copy].val; /* _to_bytes_with_copy on <self:AStringFormExpr> */
7155 var27 = var29;
7156 RET_LABEL28:(void)0;
7157 }
7158 }
7159 {
7160 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var27); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7161 }
7162 RET_LABEL:;
7163 }
7164 /* method rapid_type_analysis$ASuperstringExpr$accept_rapid_type_visitor for (self: ASuperstringExpr, RapidTypeVisitor) */
7165 void nitc__rapid_type_analysis___ASuperstringExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
7166 val* var_v /* var v: RapidTypeVisitor */;
7167 val* var /* : RapidTypeAnalysis */;
7168 val* var2 /* : RapidTypeAnalysis */;
7169 val* var3 /* : MModule */;
7170 val* var5 /* : MModule */;
7171 val* var_mmodule /* var mmodule: MModule */;
7172 val* var6 /* : MClassType */;
7173 val* var_object_type /* var object_type: MClassType */;
7174 val* var7 /* : MClassType */;
7175 val* var_arraytype /* var arraytype: MClassType */;
7176 val* var8 /* : MClassType */;
7177 val* var_nattype /* var nattype: MClassType */;
7178 static val* varonce;
7179 val* var9 /* : String */;
7180 char* var10 /* : CString */;
7181 val* var11 /* : String */;
7182 val* var12 /* : nullable Int */;
7183 val* var13 /* : nullable Int */;
7184 val* var14 /* : nullable Bool */;
7185 val* var15 /* : nullable Bool */;
7186 val* var16 /* : MMethod */;
7187 val* var_prop /* var prop: MMethod */;
7188 static val* varonce17;
7189 val* var18 /* : String */;
7190 char* var19 /* : CString */;
7191 val* var20 /* : String */;
7192 val* var21 /* : nullable Int */;
7193 val* var22 /* : nullable Int */;
7194 val* var23 /* : nullable Bool */;
7195 val* var24 /* : nullable Bool */;
7196 val* var25 /* : MMethod */;
7197 val* var_prop2 /* var prop2: MMethod */;
7198 static val* varonce26;
7199 val* var27 /* : String */;
7200 char* var28 /* : CString */;
7201 val* var29 /* : String */;
7202 val* var30 /* : nullable Int */;
7203 val* var31 /* : nullable Int */;
7204 val* var32 /* : nullable Bool */;
7205 val* var33 /* : nullable Bool */;
7206 val* var34 /* : MMethod */;
7207 var_v = p0;
7208 {
7209 { /* Inline rapid_type_analysis$RapidTypeVisitor$analysis (var_v) on <var_v:RapidTypeVisitor> */
7210 var2 = var_v->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <var_v:RapidTypeVisitor> */
7211 if (unlikely(var2 == NULL)) {
7212 if(catchStack.cursor >= 0){
7213 longjmp(catchStack.envs[catchStack.cursor], 1);
7214 }
7215 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
7216 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 465);
7217 fatal_exit(1);
7218 }
7219 var = var2;
7220 RET_LABEL1:(void)0;
7221 }
7222 }
7223 {
7224 { /* Inline rapid_type_analysis$RapidTypeAnalysis$mainmodule (var) on <var:RapidTypeAnalysis> */
7225 var5 = var->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeAnalysis___mainmodule].val; /* _mainmodule on <var:RapidTypeAnalysis> */
7226 if (unlikely(var5 == NULL)) {
7227 if(catchStack.cursor >= 0){
7228 longjmp(catchStack.envs[catchStack.cursor], 1);
7229 }
7230 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _mainmodule");
7231 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 56);
7232 fatal_exit(1);
7233 }
7234 var3 = var5;
7235 RET_LABEL4:(void)0;
7236 }
7237 }
7238 var_mmodule = var3;
7239 {
7240 var6 = nitc__model___MModule___string_type(var_mmodule);
7241 }
7242 var_object_type = var6;
7243 {
7244 var7 = nitc__model___MModule___array_type(var_mmodule, var_object_type);
7245 }
7246 var_arraytype = var7;
7247 {
7248 nitc___nitc__RapidTypeVisitor___add_type(var_v, var_arraytype); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_type on <var_v:RapidTypeVisitor>*/
7249 }
7250 {
7251 var8 = nitc__model___MModule___native_array_type(var_mmodule, var_object_type);
7252 }
7253 var_nattype = var8;
7254 {
7255 nitc___nitc__RapidTypeVisitor___add_type(var_v, var_nattype); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_type on <var_v:RapidTypeVisitor>*/
7256 }
7257 if (likely(varonce!=NULL)) {
7258 var9 = varonce;
7259 } else {
7260 var10 = "join";
7261 var12 = (val*)(4l<<2|1);
7262 var13 = (val*)(4l<<2|1);
7263 var14 = (val*)((long)(0)<<2|3);
7264 var15 = (val*)((long)(0)<<2|3);
7265 var11 = core__flat___CString___to_s_unsafe(var10, var12, var13, var14, var15);
7266 var9 = var11;
7267 varonce = var9;
7268 }
7269 {
7270 var16 = nitc___nitc__RapidTypeVisitor___get_method(var_v, var_arraytype, var9);
7271 }
7272 var_prop = var16;
7273 {
7274 nitc___nitc__RapidTypeVisitor___add_monomorphic_send(var_v, var_arraytype, var_prop); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_monomorphic_send on <var_v:RapidTypeVisitor>*/
7275 }
7276 if (likely(varonce17!=NULL)) {
7277 var18 = varonce17;
7278 } else {
7279 var19 = "with_native";
7280 var21 = (val*)(11l<<2|1);
7281 var22 = (val*)(11l<<2|1);
7282 var23 = (val*)((long)(0)<<2|3);
7283 var24 = (val*)((long)(0)<<2|3);
7284 var20 = core__flat___CString___to_s_unsafe(var19, var21, var22, var23, var24);
7285 var18 = var20;
7286 varonce17 = var18;
7287 }
7288 {
7289 var25 = nitc___nitc__RapidTypeVisitor___get_method(var_v, var_arraytype, var18);
7290 }
7291 var_prop2 = var25;
7292 {
7293 nitc___nitc__RapidTypeVisitor___add_monomorphic_send(var_v, var_arraytype, var_prop2); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_monomorphic_send on <var_v:RapidTypeVisitor>*/
7294 }
7295 if (likely(varonce26!=NULL)) {
7296 var27 = varonce26;
7297 } else {
7298 var28 = "native_to_s";
7299 var30 = (val*)(11l<<2|1);
7300 var31 = (val*)(11l<<2|1);
7301 var32 = (val*)((long)(0)<<2|3);
7302 var33 = (val*)((long)(0)<<2|3);
7303 var29 = core__flat___CString___to_s_unsafe(var28, var30, var31, var32, var33);
7304 var27 = var29;
7305 varonce26 = var27;
7306 }
7307 {
7308 var34 = nitc___nitc__RapidTypeVisitor___get_method(var_v, var_nattype, var27);
7309 }
7310 {
7311 nitc___nitc__RapidTypeVisitor___add_monomorphic_send(var_v, var_nattype, var34); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_monomorphic_send on <var_v:RapidTypeVisitor>*/
7312 }
7313 RET_LABEL:;
7314 }
7315 /* method rapid_type_analysis$ACrangeExpr$accept_rapid_type_visitor for (self: ACrangeExpr, RapidTypeVisitor) */
7316 void nitc__rapid_type_analysis___ACrangeExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
7317 val* var_v /* var v: RapidTypeVisitor */;
7318 val* var /* : nullable MType */;
7319 val* var2 /* : nullable MType */;
7320 val* var_mtype /* var mtype: nullable MType */;
7321 short int var3 /* : Bool */;
7322 int cltype;
7323 int idtype;
7324 short int var4 /* : Bool */;
7325 val* var5 /* : nullable CallSite */;
7326 val* var7 /* : nullable CallSite */;
7327 var_v = p0;
7328 {
7329 { /* Inline typing$AExpr$mtype (self) on <self:ACrangeExpr> */
7330 var2 = self->attrs[COLOR_nitc__typing__AExpr___mtype].val; /* _mtype on <self:ACrangeExpr> */
7331 var = var2;
7332 RET_LABEL1:(void)0;
7333 }
7334 }
7335 var_mtype = var;
7336 /* <var_mtype:nullable MType> isa MClassType */
7337 cltype = type_nitc__MClassType.color;
7338 idtype = type_nitc__MClassType.id;
7339 if(var_mtype == NULL) {
7340 var3 = 0;
7341 } else {
7342 if(cltype >= var_mtype->type->table_size) {
7343 var3 = 0;
7344 } else {
7345 var3 = var_mtype->type->type_table[cltype] == idtype;
7346 }
7347 }
7348 var4 = !var3;
7349 if (var4){
7350 goto RET_LABEL;
7351 } else {
7352 }
7353 {
7354 nitc___nitc__RapidTypeVisitor___add_type(var_v, var_mtype); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_type on <var_v:RapidTypeVisitor>*/
7355 }
7356 {
7357 { /* Inline typing$ARangeExpr$init_callsite (self) on <self:ACrangeExpr> */
7358 var7 = self->attrs[COLOR_nitc__typing__ARangeExpr___init_callsite].val; /* _init_callsite on <self:ACrangeExpr> */
7359 var5 = var7;
7360 RET_LABEL6:(void)0;
7361 }
7362 }
7363 {
7364 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var5); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7365 }
7366 RET_LABEL:;
7367 }
7368 /* method rapid_type_analysis$AOrangeExpr$accept_rapid_type_visitor for (self: AOrangeExpr, RapidTypeVisitor) */
7369 void nitc__rapid_type_analysis___AOrangeExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
7370 val* var_v /* var v: RapidTypeVisitor */;
7371 val* var /* : nullable MType */;
7372 val* var2 /* : nullable MType */;
7373 val* var_mtype /* var mtype: nullable MType */;
7374 short int var3 /* : Bool */;
7375 int cltype;
7376 int idtype;
7377 short int var4 /* : Bool */;
7378 val* var5 /* : nullable CallSite */;
7379 val* var7 /* : nullable CallSite */;
7380 var_v = p0;
7381 {
7382 { /* Inline typing$AExpr$mtype (self) on <self:AOrangeExpr> */
7383 var2 = self->attrs[COLOR_nitc__typing__AExpr___mtype].val; /* _mtype on <self:AOrangeExpr> */
7384 var = var2;
7385 RET_LABEL1:(void)0;
7386 }
7387 }
7388 var_mtype = var;
7389 /* <var_mtype:nullable MType> isa MClassType */
7390 cltype = type_nitc__MClassType.color;
7391 idtype = type_nitc__MClassType.id;
7392 if(var_mtype == NULL) {
7393 var3 = 0;
7394 } else {
7395 if(cltype >= var_mtype->type->table_size) {
7396 var3 = 0;
7397 } else {
7398 var3 = var_mtype->type->type_table[cltype] == idtype;
7399 }
7400 }
7401 var4 = !var3;
7402 if (var4){
7403 goto RET_LABEL;
7404 } else {
7405 }
7406 {
7407 nitc___nitc__RapidTypeVisitor___add_type(var_v, var_mtype); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_type on <var_v:RapidTypeVisitor>*/
7408 }
7409 {
7410 { /* Inline typing$ARangeExpr$init_callsite (self) on <self:AOrangeExpr> */
7411 var7 = self->attrs[COLOR_nitc__typing__ARangeExpr___init_callsite].val; /* _init_callsite on <self:AOrangeExpr> */
7412 var5 = var7;
7413 RET_LABEL6:(void)0;
7414 }
7415 }
7416 {
7417 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var5); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7418 }
7419 RET_LABEL:;
7420 }
7421 /* method rapid_type_analysis$ATrueExpr$accept_rapid_type_visitor for (self: ATrueExpr, RapidTypeVisitor) */
7422 void nitc__rapid_type_analysis___ATrueExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
7423 val* var_v /* var v: RapidTypeVisitor */;
7424 var_v = p0;
7425 {
7426 nitc__rapid_type_analysis___AExpr___allocate_mtype(self, var_v); /* Direct call rapid_type_analysis$AExpr$allocate_mtype on <self:ATrueExpr>*/
7427 }
7428 RET_LABEL:;
7429 }
7430 /* method rapid_type_analysis$AFalseExpr$accept_rapid_type_visitor for (self: AFalseExpr, RapidTypeVisitor) */
7431 void nitc__rapid_type_analysis___AFalseExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
7432 val* var_v /* var v: RapidTypeVisitor */;
7433 var_v = p0;
7434 {
7435 nitc__rapid_type_analysis___AExpr___allocate_mtype(self, var_v); /* Direct call rapid_type_analysis$AExpr$allocate_mtype on <self:AFalseExpr>*/
7436 }
7437 RET_LABEL:;
7438 }
7439 /* method rapid_type_analysis$AIsaExpr$accept_rapid_type_visitor for (self: AIsaExpr, RapidTypeVisitor) */
7440 void nitc__rapid_type_analysis___AIsaExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
7441 val* var_v /* var v: RapidTypeVisitor */;
7442 val* var /* : nullable MType */;
7443 val* var2 /* : nullable MType */;
7444 val* var_cast_type /* var cast_type: nullable MType */;
7445 short int var3 /* : Bool */;
7446 short int var4 /* : Bool */;
7447 val* var_other /* var other: nullable Object */;
7448 short int var6 /* : Bool */;
7449 short int var8 /* : Bool */;
7450 var_v = p0;
7451 {
7452 { /* Inline typing$AIsaExpr$cast_type (self) on <self:AIsaExpr> */
7453 var2 = self->attrs[COLOR_nitc__typing__AIsaExpr___cast_type].val; /* _cast_type on <self:AIsaExpr> */
7454 var = var2;
7455 RET_LABEL1:(void)0;
7456 }
7457 }
7458 var_cast_type = var;
7459 if (var_cast_type == NULL) {
7460 var3 = 1; /* is null */
7461 } else {
7462 var3 = 0; /* arg is null but recv is not */
7463 }
7464 if (0) {
7465 { /* Inline kernel$Object$== (var_cast_type,((val*)NULL)) on <var_cast_type:nullable MType> */
7466 var_other = ((val*)NULL);
7467 {
7468 { /* Inline kernel$Object$is_same_instance (var_cast_type,var_other) on <var_cast_type:nullable MType(MType)> */
7469 var8 = var_cast_type == var_other;
7470 var6 = var8;
7471 goto RET_LABEL7;
7472 RET_LABEL7:(void)0;
7473 }
7474 }
7475 var4 = var6;
7476 goto RET_LABEL5;
7477 RET_LABEL5:(void)0;
7478 }
7479 var3 = var4;
7480 }
7481 if (var3){
7482 goto RET_LABEL;
7483 } else {
7484 }
7485 {
7486 nitc___nitc__RapidTypeVisitor___add_cast_type(var_v, var_cast_type); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_cast_type on <var_v:RapidTypeVisitor>*/
7487 }
7488 RET_LABEL:;
7489 }
7490 /* method rapid_type_analysis$AAsCastExpr$accept_rapid_type_visitor for (self: AAsCastExpr, RapidTypeVisitor) */
7491 void nitc__rapid_type_analysis___AAsCastExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
7492 val* var_v /* var v: RapidTypeVisitor */;
7493 val* var /* : nullable MType */;
7494 val* var2 /* : nullable MType */;
7495 val* var_mtype /* var mtype: nullable MType */;
7496 short int var3 /* : Bool */;
7497 short int var4 /* : Bool */;
7498 val* var_other /* var other: nullable Object */;
7499 short int var6 /* : Bool */;
7500 short int var8 /* : Bool */;
7501 var_v = p0;
7502 {
7503 { /* Inline typing$AExpr$mtype (self) on <self:AAsCastExpr> */
7504 var2 = self->attrs[COLOR_nitc__typing__AExpr___mtype].val; /* _mtype on <self:AAsCastExpr> */
7505 var = var2;
7506 RET_LABEL1:(void)0;
7507 }
7508 }
7509 var_mtype = var;
7510 if (var_mtype == NULL) {
7511 var3 = 1; /* is null */
7512 } else {
7513 var3 = 0; /* arg is null but recv is not */
7514 }
7515 if (0) {
7516 { /* Inline kernel$Object$== (var_mtype,((val*)NULL)) on <var_mtype:nullable MType> */
7517 var_other = ((val*)NULL);
7518 {
7519 { /* Inline kernel$Object$is_same_instance (var_mtype,var_other) on <var_mtype:nullable MType(MType)> */
7520 var8 = var_mtype == var_other;
7521 var6 = var8;
7522 goto RET_LABEL7;
7523 RET_LABEL7:(void)0;
7524 }
7525 }
7526 var4 = var6;
7527 goto RET_LABEL5;
7528 RET_LABEL5:(void)0;
7529 }
7530 var3 = var4;
7531 }
7532 if (var3){
7533 goto RET_LABEL;
7534 } else {
7535 }
7536 {
7537 nitc___nitc__RapidTypeVisitor___add_cast_type(var_v, var_mtype); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_cast_type on <var_v:RapidTypeVisitor>*/
7538 }
7539 RET_LABEL:;
7540 }
7541 /* method rapid_type_analysis$ASendExpr$accept_rapid_type_visitor for (self: ASendExpr, RapidTypeVisitor) */
7542 void nitc__rapid_type_analysis___ASendExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
7543 val* var_v /* var v: RapidTypeVisitor */;
7544 val* var /* : nullable CallSite */;
7545 val* var2 /* : nullable CallSite */;
7546 var_v = p0;
7547 {
7548 { /* Inline typing$ASendExpr$callsite (self) on <self:ASendExpr> */
7549 var2 = self->attrs[COLOR_nitc__typing__ASendExpr___callsite].val; /* _callsite on <self:ASendExpr> */
7550 var = var2;
7551 RET_LABEL1:(void)0;
7552 }
7553 }
7554 {
7555 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7556 }
7557 RET_LABEL:;
7558 }
7559 /* method rapid_type_analysis$ASendReassignFormExpr$accept_rapid_type_visitor for (self: ASendReassignFormExpr, RapidTypeVisitor) */
7560 void nitc__rapid_type_analysis___ASendReassignFormExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
7561 val* var_v /* var v: RapidTypeVisitor */;
7562 val* var /* : nullable CallSite */;
7563 val* var2 /* : nullable CallSite */;
7564 val* var3 /* : nullable CallSite */;
7565 val* var5 /* : nullable CallSite */;
7566 val* var6 /* : nullable CallSite */;
7567 val* var8 /* : nullable CallSite */;
7568 var_v = p0;
7569 {
7570 { /* Inline typing$ASendExpr$callsite (self) on <self:ASendReassignFormExpr> */
7571 var2 = self->attrs[COLOR_nitc__typing__ASendExpr___callsite].val; /* _callsite on <self:ASendReassignFormExpr> */
7572 var = var2;
7573 RET_LABEL1:(void)0;
7574 }
7575 }
7576 {
7577 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7578 }
7579 {
7580 { /* Inline typing$AReassignFormExpr$reassign_callsite (self) on <self:ASendReassignFormExpr> */
7581 var5 = self->attrs[COLOR_nitc__typing__AReassignFormExpr___reassign_callsite].val; /* _reassign_callsite on <self:ASendReassignFormExpr> */
7582 var3 = var5;
7583 RET_LABEL4:(void)0;
7584 }
7585 }
7586 {
7587 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var3); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7588 }
7589 {
7590 { /* Inline typing$ASendReassignFormExpr$write_callsite (self) on <self:ASendReassignFormExpr> */
7591 var8 = self->attrs[COLOR_nitc__typing__ASendReassignFormExpr___write_callsite].val; /* _write_callsite on <self:ASendReassignFormExpr> */
7592 var6 = var8;
7593 RET_LABEL7:(void)0;
7594 }
7595 }
7596 {
7597 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var6); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7598 }
7599 RET_LABEL:;
7600 }
7601 /* method rapid_type_analysis$AVarReassignExpr$accept_rapid_type_visitor for (self: AVarReassignExpr, RapidTypeVisitor) */
7602 void nitc__rapid_type_analysis___AVarReassignExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
7603 val* var_v /* var v: RapidTypeVisitor */;
7604 val* var /* : nullable CallSite */;
7605 val* var2 /* : nullable CallSite */;
7606 var_v = p0;
7607 {
7608 { /* Inline typing$AReassignFormExpr$reassign_callsite (self) on <self:AVarReassignExpr> */
7609 var2 = self->attrs[COLOR_nitc__typing__AReassignFormExpr___reassign_callsite].val; /* _reassign_callsite on <self:AVarReassignExpr> */
7610 var = var2;
7611 RET_LABEL1:(void)0;
7612 }
7613 }
7614 {
7615 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7616 }
7617 RET_LABEL:;
7618 }
7619 /* method rapid_type_analysis$AAttrReassignExpr$accept_rapid_type_visitor for (self: AAttrReassignExpr, RapidTypeVisitor) */
7620 void nitc__rapid_type_analysis___AAttrReassignExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
7621 val* var_v /* var v: RapidTypeVisitor */;
7622 val* var /* : nullable CallSite */;
7623 val* var2 /* : nullable CallSite */;
7624 var_v = p0;
7625 {
7626 { /* Inline typing$AReassignFormExpr$reassign_callsite (self) on <self:AAttrReassignExpr> */
7627 var2 = self->attrs[COLOR_nitc__typing__AReassignFormExpr___reassign_callsite].val; /* _reassign_callsite on <self:AAttrReassignExpr> */
7628 var = var2;
7629 RET_LABEL1:(void)0;
7630 }
7631 }
7632 {
7633 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7634 }
7635 RET_LABEL:;
7636 }
7637 /* method rapid_type_analysis$ASuperExpr$accept_rapid_type_visitor for (self: ASuperExpr, RapidTypeVisitor) */
7638 void nitc__rapid_type_analysis___ASuperExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
7639 val* var_v /* var v: RapidTypeVisitor */;
7640 val* var /* : nullable CallSite */;
7641 val* var2 /* : nullable CallSite */;
7642 val* var_callsite /* var callsite: nullable CallSite */;
7643 short int var3 /* : Bool */;
7644 short int var4 /* : Bool */;
7645 val* var_other /* var other: nullable Object */;
7646 short int var6 /* : Bool */;
7647 short int var7 /* : Bool */;
7648 val* var8 /* : RapidTypeAnalysis */;
7649 val* var10 /* : RapidTypeAnalysis */;
7650 val* var11 /* : MClassType */;
7651 val* var13 /* : MClassType */;
7652 val* var14 /* : nullable MMethodDef */;
7653 val* var16 /* : nullable MMethodDef */;
7654 var_v = p0;
7655 {
7656 { /* Inline typing$ASuperExpr$callsite (self) on <self:ASuperExpr> */
7657 var2 = self->attrs[COLOR_nitc__typing__ASuperExpr___callsite].val; /* _callsite on <self:ASuperExpr> */
7658 var = var2;
7659 RET_LABEL1:(void)0;
7660 }
7661 }
7662 var_callsite = var;
7663 if (var_callsite == NULL) {
7664 var3 = 0; /* is null */
7665 } else {
7666 var3 = 1; /* arg is null and recv is not */
7667 }
7668 if (0) {
7669 { /* Inline kernel$Object$!= (var_callsite,((val*)NULL)) on <var_callsite:nullable CallSite> */
7670 var_other = ((val*)NULL);
7671 {
7672 var6 = ((short int(*)(val* self, val* p0))(var_callsite->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_callsite, var_other); /* == on <var_callsite:nullable CallSite(CallSite)>*/
7673 }
7674 var7 = !var6;
7675 var4 = var7;
7676 goto RET_LABEL5;
7677 RET_LABEL5:(void)0;
7678 }
7679 var3 = var4;
7680 }
7681 if (var3){
7682 {
7683 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var_callsite); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7684 }
7685 goto RET_LABEL;
7686 } else {
7687 }
7688 {
7689 { /* Inline rapid_type_analysis$RapidTypeVisitor$analysis (var_v) on <var_v:RapidTypeVisitor> */
7690 var10 = var_v->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___analysis].val; /* _analysis on <var_v:RapidTypeVisitor> */
7691 if (unlikely(var10 == NULL)) {
7692 if(catchStack.cursor >= 0){
7693 longjmp(catchStack.envs[catchStack.cursor], 1);
7694 }
7695 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _analysis");
7696 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 465);
7697 fatal_exit(1);
7698 }
7699 var8 = var10;
7700 RET_LABEL9:(void)0;
7701 }
7702 }
7703 {
7704 { /* Inline rapid_type_analysis$RapidTypeVisitor$receiver (var_v) on <var_v:RapidTypeVisitor> */
7705 var13 = var_v->attrs[COLOR_nitc__rapid_type_analysis__RapidTypeVisitor___receiver].val; /* _receiver on <var_v:RapidTypeVisitor> */
7706 if (unlikely(var13 == NULL)) {
7707 if(catchStack.cursor >= 0){
7708 longjmp(catchStack.envs[catchStack.cursor], 1);
7709 }
7710 PRINT_ERROR("Runtime error: %s", "Uninitialized attribute _receiver");
7711 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 466);
7712 fatal_exit(1);
7713 }
7714 var11 = var13;
7715 RET_LABEL12:(void)0;
7716 }
7717 }
7718 {
7719 { /* Inline typing$ASuperExpr$mpropdef (self) on <self:ASuperExpr> */
7720 var16 = self->attrs[COLOR_nitc__typing__ASuperExpr___mpropdef].val; /* _mpropdef on <self:ASuperExpr> */
7721 var14 = var16;
7722 RET_LABEL15:(void)0;
7723 }
7724 }
7725 if (unlikely(var14 == NULL)) {
7726 if(catchStack.cursor >= 0){
7727 longjmp(catchStack.envs[catchStack.cursor], 1);
7728 }
7729 PRINT_ERROR("Runtime error: %s", "Cast failed");
7730 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 711);
7731 fatal_exit(1);
7732 }
7733 {
7734 nitc___nitc__RapidTypeAnalysis___add_super_send(var8, var11, var14); /* Direct call rapid_type_analysis$RapidTypeAnalysis$add_super_send on <var8:RapidTypeAnalysis>*/
7735 }
7736 RET_LABEL:;
7737 }
7738 /* method rapid_type_analysis$AForGroup$accept_rapid_type_visitor for (self: AForGroup, RapidTypeVisitor) */
7739 void nitc__rapid_type_analysis___AForGroup___ANode__accept_rapid_type_visitor(val* self, val* p0) {
7740 val* var_v /* var v: RapidTypeVisitor */;
7741 val* var /* : nullable CallSite */;
7742 val* var2 /* : nullable CallSite */;
7743 val* var3 /* : nullable CallSite */;
7744 val* var5 /* : nullable CallSite */;
7745 val* var6 /* : nullable Array[Variable] */;
7746 val* var8 /* : nullable Array[Variable] */;
7747 long var9 /* : Int */;
7748 long var11 /* : Int */;
7749 short int var12 /* : Bool */;
7750 short int var14 /* : Bool */;
7751 val* var15 /* : nullable CallSite */;
7752 val* var17 /* : nullable CallSite */;
7753 val* var18 /* : nullable Array[Variable] */;
7754 val* var20 /* : nullable Array[Variable] */;
7755 long var21 /* : Int */;
7756 long var23 /* : Int */;
7757 short int var24 /* : Bool */;
7758 short int var26 /* : Bool */;
7759 val* var27 /* : nullable CallSite */;
7760 val* var29 /* : nullable CallSite */;
7761 val* var30 /* : nullable CallSite */;
7762 val* var32 /* : nullable CallSite */;
7763 val* var33 /* : nullable CallSite */;
7764 val* var35 /* : nullable CallSite */;
7765 val* var36 /* : nullable CallSite */;
7766 val* var38 /* : nullable CallSite */;
7767 val* var_mf /* var mf: nullable CallSite */;
7768 short int var39 /* : Bool */;
7769 short int var40 /* : Bool */;
7770 val* var_other /* var other: nullable Object */;
7771 short int var42 /* : Bool */;
7772 short int var43 /* : Bool */;
7773 var_v = p0;
7774 {
7775 { /* Inline typing$AForGroup$method_iterator (self) on <self:AForGroup> */
7776 var2 = self->attrs[COLOR_nitc__typing__AForGroup___method_iterator].val; /* _method_iterator on <self:AForGroup> */
7777 var = var2;
7778 RET_LABEL1:(void)0;
7779 }
7780 }
7781 {
7782 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7783 }
7784 {
7785 { /* Inline typing$AForGroup$method_is_ok (self) on <self:AForGroup> */
7786 var5 = self->attrs[COLOR_nitc__typing__AForGroup___method_is_ok].val; /* _method_is_ok on <self:AForGroup> */
7787 var3 = var5;
7788 RET_LABEL4:(void)0;
7789 }
7790 }
7791 {
7792 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var3); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7793 }
7794 {
7795 { /* Inline scope$AForGroup$variables (self) on <self:AForGroup> */
7796 var8 = self->attrs[COLOR_nitc__scope__AForGroup___variables].val; /* _variables on <self:AForGroup> */
7797 var6 = var8;
7798 RET_LABEL7:(void)0;
7799 }
7800 }
7801 if (var6 == NULL) {
7802 if(catchStack.cursor >= 0){
7803 longjmp(catchStack.envs[catchStack.cursor], 1);
7804 }
7805 PRINT_ERROR("Runtime error: %s", "Receiver is null");
7806 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 720);
7807 fatal_exit(1);
7808 } else {
7809 { /* Inline array$AbstractArrayRead$length (var6) on <var6:nullable Array[Variable]> */
7810 if (unlikely(var6 == NULL)) {
7811 if(catchStack.cursor >= 0){
7812 longjmp(catchStack.envs[catchStack.cursor], 1);
7813 }
7814 PRINT_ERROR("Runtime error: %s", "Receiver is null");
7815 PRINT_ERROR(" (%s:%d)\n", FILE_core__array, 26);
7816 fatal_exit(1);
7817 }
7818 var11 = var6->attrs[COLOR_core__array__AbstractArrayRead___length].l; /* _length on <var6:nullable Array[Variable]> */
7819 var9 = var11;
7820 RET_LABEL10:(void)0;
7821 }
7822 }
7823 {
7824 { /* Inline kernel$Int$== (var9,1l) on <var9:Int> */
7825 var14 = var9 == 1l;
7826 var12 = var14;
7827 goto RET_LABEL13;
7828 RET_LABEL13:(void)0;
7829 }
7830 }
7831 if (var12){
7832 {
7833 { /* Inline typing$AForGroup$method_item (self) on <self:AForGroup> */
7834 var17 = self->attrs[COLOR_nitc__typing__AForGroup___method_item].val; /* _method_item on <self:AForGroup> */
7835 var15 = var17;
7836 RET_LABEL16:(void)0;
7837 }
7838 }
7839 {
7840 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var15); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7841 }
7842 } else {
7843 {
7844 { /* Inline scope$AForGroup$variables (self) on <self:AForGroup> */
7845 var20 = self->attrs[COLOR_nitc__scope__AForGroup___variables].val; /* _variables on <self:AForGroup> */
7846 var18 = var20;
7847 RET_LABEL19:(void)0;
7848 }
7849 }
7850 if (var18 == NULL) {
7851 if(catchStack.cursor >= 0){
7852 longjmp(catchStack.envs[catchStack.cursor], 1);
7853 }
7854 PRINT_ERROR("Runtime error: %s", "Receiver is null");
7855 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 722);
7856 fatal_exit(1);
7857 } else {
7858 { /* Inline array$AbstractArrayRead$length (var18) on <var18:nullable Array[Variable]> */
7859 if (unlikely(var18 == NULL)) {
7860 if(catchStack.cursor >= 0){
7861 longjmp(catchStack.envs[catchStack.cursor], 1);
7862 }
7863 PRINT_ERROR("Runtime error: %s", "Receiver is null");
7864 PRINT_ERROR(" (%s:%d)\n", FILE_core__array, 26);
7865 fatal_exit(1);
7866 }
7867 var23 = var18->attrs[COLOR_core__array__AbstractArrayRead___length].l; /* _length on <var18:nullable Array[Variable]> */
7868 var21 = var23;
7869 RET_LABEL22:(void)0;
7870 }
7871 }
7872 {
7873 { /* Inline kernel$Int$== (var21,2l) on <var21:Int> */
7874 var26 = var21 == 2l;
7875 var24 = var26;
7876 goto RET_LABEL25;
7877 RET_LABEL25:(void)0;
7878 }
7879 }
7880 if (var24){
7881 {
7882 { /* Inline typing$AForGroup$method_key (self) on <self:AForGroup> */
7883 var29 = self->attrs[COLOR_nitc__typing__AForGroup___method_key].val; /* _method_key on <self:AForGroup> */
7884 var27 = var29;
7885 RET_LABEL28:(void)0;
7886 }
7887 }
7888 {
7889 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var27); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7890 }
7891 {
7892 { /* Inline typing$AForGroup$method_item (self) on <self:AForGroup> */
7893 var32 = self->attrs[COLOR_nitc__typing__AForGroup___method_item].val; /* _method_item on <self:AForGroup> */
7894 var30 = var32;
7895 RET_LABEL31:(void)0;
7896 }
7897 }
7898 {
7899 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var30); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7900 }
7901 } else {
7902 if(catchStack.cursor >= 0){
7903 longjmp(catchStack.envs[catchStack.cursor], 1);
7904 }
7905 PRINT_ERROR("Runtime error: %s", "Aborted");
7906 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 726);
7907 fatal_exit(1);
7908 }
7909 }
7910 {
7911 { /* Inline typing$AForGroup$method_next (self) on <self:AForGroup> */
7912 var35 = self->attrs[COLOR_nitc__typing__AForGroup___method_next].val; /* _method_next on <self:AForGroup> */
7913 var33 = var35;
7914 RET_LABEL34:(void)0;
7915 }
7916 }
7917 {
7918 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var33); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7919 }
7920 {
7921 { /* Inline typing$AForGroup$method_finish (self) on <self:AForGroup> */
7922 var38 = self->attrs[COLOR_nitc__typing__AForGroup___method_finish].val; /* _method_finish on <self:AForGroup> */
7923 var36 = var38;
7924 RET_LABEL37:(void)0;
7925 }
7926 }
7927 var_mf = var36;
7928 if (var_mf == NULL) {
7929 var39 = 0; /* is null */
7930 } else {
7931 var39 = 1; /* arg is null and recv is not */
7932 }
7933 if (0) {
7934 { /* Inline kernel$Object$!= (var_mf,((val*)NULL)) on <var_mf:nullable CallSite> */
7935 var_other = ((val*)NULL);
7936 {
7937 var42 = ((short int(*)(val* self, val* p0))(var_mf->class->vft[COLOR_core__kernel__Object___61d_61d]))(var_mf, var_other); /* == on <var_mf:nullable CallSite(CallSite)>*/
7938 }
7939 var43 = !var42;
7940 var40 = var43;
7941 goto RET_LABEL41;
7942 RET_LABEL41:(void)0;
7943 }
7944 var39 = var40;
7945 }
7946 if (var39){
7947 {
7948 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var_mf); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7949 }
7950 } else {
7951 }
7952 RET_LABEL:;
7953 }
7954 /* method rapid_type_analysis$ANewExpr$accept_rapid_type_visitor for (self: ANewExpr, RapidTypeVisitor) */
7955 void nitc__rapid_type_analysis___ANewExpr___ANode__accept_rapid_type_visitor(val* self, val* p0) {
7956 val* var_v /* var v: RapidTypeVisitor */;
7957 val* var /* : nullable MClassType */;
7958 val* var2 /* : nullable MClassType */;
7959 val* var_mtype /* var mtype: MClassType */;
7960 val* var3 /* : nullable CallSite */;
7961 val* var5 /* : nullable CallSite */;
7962 var_v = p0;
7963 {
7964 { /* Inline typing$ANewExpr$recvtype (self) on <self:ANewExpr> */
7965 var2 = self->attrs[COLOR_nitc__typing__ANewExpr___recvtype].val; /* _recvtype on <self:ANewExpr> */
7966 var = var2;
7967 RET_LABEL1:(void)0;
7968 }
7969 }
7970 if (unlikely(var == NULL)) {
7971 if(catchStack.cursor >= 0){
7972 longjmp(catchStack.envs[catchStack.cursor], 1);
7973 }
7974 PRINT_ERROR("Runtime error: %s", "Cast failed");
7975 PRINT_ERROR(" (%s:%d)\n", FILE_nitc__rapid_type_analysis, 737);
7976 fatal_exit(1);
7977 }
7978 var_mtype = var;
7979 {
7980 nitc___nitc__RapidTypeVisitor___add_type(var_v, var_mtype); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_type on <var_v:RapidTypeVisitor>*/
7981 }
7982 {
7983 { /* Inline typing$ANewExpr$callsite (self) on <self:ANewExpr> */
7984 var5 = self->attrs[COLOR_nitc__typing__ANewExpr___callsite].val; /* _callsite on <self:ANewExpr> */
7985 var3 = var5;
7986 RET_LABEL4:(void)0;
7987 }
7988 }
7989 {
7990 nitc___nitc__RapidTypeVisitor___add_callsite(var_v, var3); /* Direct call rapid_type_analysis$RapidTypeVisitor$add_callsite on <var_v:RapidTypeVisitor>*/
7991 }
7992 RET_LABEL:;
7993 }