gistfile1.txt

#include <mruby.h>
#include <mruby/value.h>
#include <mruby/array.h>
#include <mruby/hash.h>
#include <mruby/throw.h>
#include <mruby/proc.h>
#include <mruby/string.h>
#include <mruby/range.h>
#include <mruby/error.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#undef mrb_int
typedef mrb_float mrb_float2;

#define mrb_float_value2(n) ({\
  mrb_value rc;               \
  rc.f = n;                   \
  rc;                         \
})

#define mmc_boxing_array(src, size, boxing_func)  ({      \
  mrb_value ary;                                          \
  ary = mrb_ary_new_capa(mrb, (size));                    \
  for (int i = 0; i < (size); i++) {                      \
    mrb_ary_push(mrb, ary, (boxing_func)(mrb, (src)[i])); \
  }                                                       \
  ary;                                                    \
})

typedef void *gproc;
struct gctab {
  int size;
  int csize;
  int osize;
  struct gctab *prev;
  mrb_value **complex;
  mrb_value **object;
  void *caller_alloc;
  int ret_status;
  mrb_value *single[0];
};

void mrb_mark_local(mrb_state *mrb)
{
  struct gctab *curtab = (struct gctab *)mrb->ud;
  while (curtab) {
    for (int i = curtab->size; i--;) {
      mrb_gc_mark(mrb, mrb_basic_ptr(*curtab->single[i]));
    }

    for (int i = curtab->osize; i--;) {
      mrb_gc_mark(mrb, mrb_basic_ptr(*curtab->object[i]));
    }

    for (int i = curtab->csize; i--;) {
      mrb_value *cptr = curtab->complex[i];
      for (int j = 0; cptr[j].value.ttt != MRB_TT_FREE; j++) {
        mrb_gc_mark(mrb, mrb_basic_ptr(cptr[j]));
      }
    }
    curtab = curtab->prev;
  }
}
struct env2 {
struct env1 *prev;
};
struct env4 {
struct env3 *prev;
};
struct env7 {
struct env6 *prev;
};
struct env10 {
struct env9 *prev;
};
struct env13 {
struct env12 *prev;
};
struct env23 {
struct env22 *prev;
};
struct env50 {
struct env49 *prev;
};
struct env47 {
struct env46 *prev;
};
struct env44 {
struct env43 *prev;
};
struct env41 {
struct env40 *prev;
};
struct env29 {
struct env28 *prev;
};
struct env26 {
struct env25 *prev;
};
struct range_mrb_int {
  mrb_int first;
  mrb_int last;
  mrb_bool exclude_end;
};
struct env16 {
char *v10546;
struct env15 *prev;
};
struct env35 {
struct env34 *prev;
};
struct env32 {
struct env31 *prev;
};
struct env38 {
struct env37 *prev;
};
struct env20 {
struct env19 *prev;
};
struct env17 {
struct env16 *prev;
};
struct cls0_44 {
};
struct cls7_44 {
};
struct cls1_45 {
char *v427; /* @buf */
mrb_int v429; /* @index */
mrb_int v433; /* @length */
};
struct cls1_47 {
char *v427; /* @buf */
mrb_int v429; /* @index */
mrb_int v433; /* @length */
};
struct cls8_44 {
};
struct cls3_44 {
};
struct cls5_44 {
};
struct cls9_44 {
};
static mrb_value main_Object_0(mrb_state *, mrb_value self,struct gctab *);
static mrb_value top__Object__1(mrb_state *, mrb_value self,struct gctab *);
static mrb_value parse__Object__2(mrb_state *, mrb_value self, char *v283,struct gctab *);
struct cls7_44 * const0;
static mrb_value parse__Object__24(mrb_state *, mrb_value self, char *v283,struct gctab *);
static mrb_value parse__Object__38(mrb_state *, mrb_value self, char *v283,struct gctab *);
static mrb_value parse__Object__40(mrb_state *, mrb_value self, char *v283,struct gctab *);
static mrb_value parse__Object__42(mrb_state *, mrb_value self, char *v283,struct gctab *);
static mrb_int initialize__Context__46(mrb_state *, struct cls1_47 * self, char *v2964,struct gctab *);
static mrb_value parse_uvalue__Context__26(mrb_state *, struct cls1_47 * self,struct gctab *);
static mrb_int initialize__Context__37(mrb_state *, struct cls1_47 * self, char *v2964,struct gctab *);
static mrb_int initialize__Context__39(mrb_state *, struct cls1_47 * self, char *v2964,struct gctab *);
static mrb_int initialize__Context__41(mrb_state *, struct cls1_47 * self, char *v2964,struct gctab *);
static mrb_int initialize__Context__43(mrb_state *, struct cls1_47 * self, char *v2964,struct gctab *);
static mrb_value skip_uwhite__Context__26(mrb_state *, struct cls1_47 * self,struct gctab *);
static char * current__Context__26(mrb_state *, struct cls1_47 * self,struct gctab *);
static mrb_value parse_uobject__Context__26(mrb_state *, struct cls1_47 * self,struct gctab *);
static mrb_value parse_uarray__Context__26(mrb_state *, struct cls1_47 * self,struct gctab *);
static mrb_value parse_ustring__Context__26(mrb_state *, struct cls1_47 * self,struct gctab *);
static mrb_value parse_unumber__Context__26(mrb_state *, struct cls1_47 * self,struct gctab *);
static mrb_bool parse_uconstant__Context__31(mrb_state *, struct cls1_47 * self, char *v20249, mrb_bool v20250,struct gctab *);
static mrb_bool parse_uconstant__Context__30(mrb_state *, struct cls1_47 * self, char *v20249, mrb_bool v20250,struct gctab *);
static mrb_value parse_uconstant__Context__28(mrb_state *, struct cls1_47 * self, char *v20249, mrb_value v20250,struct gctab *);
static mrb_value error__Context__27(mrb_state *, struct cls1_47 * self, char *v17553,struct gctab *);
static mrb_value include_q__Array__5(mrb_state *, char * *self, char *v10542,struct gctab *);
struct proc17 {
int id;
void *code[2];
struct env16 *env;
char * *self;
};
static char * next__Context__26(mrb_state *, struct cls1_47 * self,struct gctab *);
static mrb_bool has_unext_q__Context__26(mrb_state *, struct cls1_47 * self,struct gctab *);
static mrb_value error__Context__34(mrb_state *, struct cls1_47 * self, char *v17553,struct gctab *);
static mrb_int back__Context__26(mrb_state *, struct cls1_47 * self,struct gctab *);
static mrb_value error__Context__35(mrb_state *, struct cls1_47 * self, char *v17553,struct gctab *);
static mrb_value error__Context__36(mrb_state *, struct cls1_47 * self, char *v17553,struct gctab *);
static mrb_value error__Context__33(mrb_state *, struct cls1_47 * self, char *v17553,struct gctab *);
static mrb_value error__Context__32(mrb_state *, struct cls1_47 * self, char *v17553,struct gctab *);
static mrb_value error__Context__29(mrb_state *, struct cls1_47 * self, char *v17553,struct gctab *);
static mrb_value each__Array__6(mrb_state *, char * *self, gproc v12130,struct gctab *);
static mrb_value p17_Array_0_8(mrb_state *, gproc cgproc, char *v10555, struct gctab *);
int main(int argc, char **argv)
{
  mrb_state *mrb = mrb_open();
  struct mrb_jmpbuf c_jmp;

  MRB_TRY(&c_jmp) {
    mrb->jmp = &c_jmp;
    main_Object_0(mrb, mrb_top_self(mrb), NULL);
  }
  MRB_CATCH(&c_jmp) {
    mrb_p(mrb, mrb_obj_value(mrb->exc));
    return 1;
  }
  MRB_END_EXC(&c_jmp);

  return 0;
}
static mrb_value main_Object_0(mrb_state *mrb, mrb_value self, struct gctab *prevgctab) {
mrb_value v13;
struct gctab *gctab = prevgctab;
L0:; 
v13 = top__Object__1(mrb, self, gctab);
return v13;
}
static mrb_value top__Object__1(mrb_state *mrb, mrb_value self, struct gctab *prevgctab) {
struct env2 env;
struct REnv *venv = NULL;
char *v139 = "{\"foo\": \"bar\"}";
mrb_value v141;
mrb_value v143;
char *v146 = "{\"foo\": \"baz\", \"abc\": \"abaz\"}";
mrb_value v148;
mrb_value v150;
char *v153 = "[true, \"foo\"]";
mrb_value v155;
mrb_value v157;
char *v160 = "{\"label\":[true, \"foo\"]}";
mrb_value v162;
mrb_value v164;
char *v167 = "[true, {\"foo\" : \"bar\"}]";
mrb_value v169;
mrb_value v171;
struct gctab *gctab = prevgctab;
L6:; 
v141 = parse__Object__2(mrb, self, "{\"foo\": \"bar\"}", gctab);
mrb->ud = (void *)gctab;
mrb_p(mrb, v141);
v143 = v141;
v148 = parse__Object__24(mrb, self, "{\"foo\": \"baz\", \"abc\": \"abaz\"}", gctab);
mrb->ud = (void *)gctab;
mrb_p(mrb, v148);
v150 = v148;
v155 = parse__Object__38(mrb, self, "[true, \"foo\"]", gctab);
mrb->ud = (void *)gctab;
mrb_p(mrb, v155);
v157 = v155;
v162 = parse__Object__40(mrb, self, "{\"label\":[true, \"foo\"]}", gctab);
mrb->ud = (void *)gctab;
mrb_p(mrb, v162);
v164 = v162;
v169 = parse__Object__42(mrb, self, "[true, {\"foo\" : \"bar\"}]", gctab);
mrb->ud = (void *)gctab;
mrb_p(mrb, v169);
v171 = v169;
return v171;
}
static mrb_value parse__Object__2(mrb_state *mrb, mrb_value self, char *v283, struct gctab *prevgctab) {
struct env4 env;
struct REnv *venv = NULL;
struct cls1_45 * v296;
mrb_value v298;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = prevgctab;
L12:; 
v296 = alloca(sizeof(struct cls1_45));
v296->v427 = NULL;
initialize__Context__46(mrb, v296, "{\"foo\": \"bar\"}", gctab);
v298 = parse_uvalue__Context__26(mrb, v296, gctab);
mrb_gc_arena_restore(mrb, ai);
return v298;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value parse__Object__24(mrb_state *mrb, mrb_value self, char *v283, struct gctab *prevgctab) {
struct env4 env;
struct REnv *venv = NULL;
struct cls1_47 * v296;
mrb_value v298;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = prevgctab;
L12:; 
v296 = alloca(sizeof(struct cls1_47));
v296->v427 = NULL;
initialize__Context__37(mrb, v296, "{\"foo\": \"baz\", \"abc\": \"abaz\"}", gctab);
v298 = parse_uvalue__Context__26(mrb, v296, gctab);
mrb_gc_arena_restore(mrb, ai);
return v298;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value parse__Object__38(mrb_state *mrb, mrb_value self, char *v283, struct gctab *prevgctab) {
struct env4 env;
struct REnv *venv = NULL;
struct cls1_47 * v296;
mrb_value v298;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = prevgctab;
L12:; 
v296 = alloca(sizeof(struct cls1_47));
v296->v427 = NULL;
initialize__Context__39(mrb, v296, "[true, \"foo\"]", gctab);
v298 = parse_uvalue__Context__26(mrb, v296, gctab);
mrb_gc_arena_restore(mrb, ai);
return v298;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value parse__Object__40(mrb_state *mrb, mrb_value self, char *v283, struct gctab *prevgctab) {
struct env4 env;
struct REnv *venv = NULL;
struct cls1_47 * v296;
mrb_value v298;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = prevgctab;
L12:; 
v296 = alloca(sizeof(struct cls1_47));
v296->v427 = NULL;
initialize__Context__41(mrb, v296, "{\"label\":[true, \"foo\"]}", gctab);
v298 = parse_uvalue__Context__26(mrb, v296, gctab);
mrb_gc_arena_restore(mrb, ai);
return v298;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value parse__Object__42(mrb_state *mrb, mrb_value self, char *v283, struct gctab *prevgctab) {
struct env4 env;
struct REnv *venv = NULL;
struct cls1_47 * v296;
mrb_value v298;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = prevgctab;
L12:; 
v296 = alloca(sizeof(struct cls1_47));
v296->v427 = NULL;
initialize__Context__43(mrb, v296, "[true, {\"foo\" : \"bar\"}]", gctab);
v298 = parse_uvalue__Context__26(mrb, v296, gctab);
mrb_gc_arena_restore(mrb, ai);
return v298;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_int initialize__Context__46(mrb_state *mrb, struct cls1_47 * self, char *v2964, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int v2975;
struct gctab *gctab = prevgctab;
L162:; 
self->v427 = "{\"foo\": \"bar\"}"; /* [:char, "*", nil] -> [:char, "*", nil] */
self->v429 = 0; /* mrb_int -> mrb_int */
v2975 = 14;
self->v433 = v2975; /* mrb_int -> mrb_int */
return v2975;
}
static mrb_value parse_uvalue__Context__26(mrb_state *mrb, struct cls1_47 * self, struct gctab *prevgctab) {
struct env10 env;
struct REnv *venv = NULL;
mrb_value v5652;
char *v5655;
char *v5657 = "{";
mrb_bool v5660;
mrb_value v5681;
char *v5700 = "[";
mrb_bool v5703;
mrb_value v5724;
char *v5743 = "\"";
mrb_bool v5746;
mrb_value v5767;
char *v5786 = "0";
mrb_bool v5789;
mrb_value v5940;
char *v5799 = "1";
mrb_bool v5802;
char *v5812 = "2";
mrb_bool v5815;
char *v5825 = "3";
mrb_bool v5828;
char *v5838 = "4";
mrb_bool v5841;
char *v5851 = "5";
mrb_bool v5854;
char *v5864 = "6";
mrb_bool v5867;
char *v5877 = "7";
mrb_bool v5880;
char *v5890 = "8";
mrb_bool v5893;
char *v5903 = "9";
mrb_bool v5906;
char *v5916 = "-";
mrb_bool v5919;
char *v5959 = "t";
mrb_bool v5962;
char *v5982 = "true";
mrb_bool v5985;
char *v6004 = "f";
mrb_bool v6007;
char *v6027 = "false";
mrb_bool v6030;
char *v6049 = "n";
mrb_bool v6052;
char *v6072 = "null";
mrb_value v6075;
char *v6095 = "Invalid sequence";
mrb_value v6097;
mrb_value v6113;
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab) + 0 * sizeof(mrb_value *));
gctab->prev = prevgctab;
gctab->complex = NULL;
gctab->object = NULL;
gctab->size = 0;
gctab->csize = 0;
gctab->osize = 0;
gctab->ret_status = 0;
L312:; 
v5652 = skip_uwhite__Context__26(mrb, self, gctab);
gctab->caller_alloc = alloca(sizeof(char) * 4);
v5655 = current__Context__26(mrb, self, gctab);
v5660 = (!strcmp("{", v5655));
if (v5660) goto L314; else goto L313;
L314:; 
v5681 = parse_uobject__Context__26(mrb, self, gctab);
return v5681;
L313:; 
L316:; 
v5703 = (!strcmp("[", v5655));
if (v5703) goto L318; else goto L317;
L318:; 
v5724 = parse_uarray__Context__26(mrb, self, gctab);
return v5724;
L317:; 
L320:; 
v5746 = (!strcmp("\"", v5655));
if (v5746) goto L322; else goto L321;
L322:; 
v5767 = parse_ustring__Context__26(mrb, self, gctab);
return v5767;
L321:; 
L324:; 
v5789 = (!strcmp("0", v5655));
if (v5789) goto L336; else goto L325;
L336:; 
v5940 = parse_unumber__Context__26(mrb, self, gctab);
return v5940;
L325:; 
v5802 = (!strcmp("1", v5655));
if (v5802) goto L336; else goto L326;
L326:; 
v5815 = (!strcmp("2", v5655));
if (v5815) goto L336; else goto L327;
L327:; 
v5828 = (!strcmp("3", v5655));
if (v5828) goto L336; else goto L328;
L328:; 
v5841 = (!strcmp("4", v5655));
if (v5841) goto L336; else goto L329;
L329:; 
v5854 = (!strcmp("5", v5655));
if (v5854) goto L336; else goto L330;
L330:; 
v5867 = (!strcmp("6", v5655));
if (v5867) goto L336; else goto L331;
L331:; 
v5880 = (!strcmp("7", v5655));
if (v5880) goto L336; else goto L332;
L332:; 
v5893 = (!strcmp("8", v5655));
if (v5893) goto L336; else goto L333;
L333:; 
v5906 = (!strcmp("9", v5655));
if (v5906) goto L336; else goto L334;
L334:; 
v5919 = (!strcmp("-", v5655));
if (v5919) goto L336; else goto L335;
L335:; 
L338:; 
v5962 = (!strcmp("t", v5655));
if (v5962) goto L340; else goto L339;
L340:; 
v5985 = parse_uconstant__Context__31(mrb, self, "true", 1, gctab);
return ((v5985) ? mrb_true_value() : mrb_false_value());
L339:; 
L342:; 
v6007 = (!strcmp("f", v5655));
if (v6007) goto L344; else goto L343;
L344:; 
v6030 = parse_uconstant__Context__30(mrb, self, "false", 0, gctab);
return ((v6030) ? mrb_true_value() : mrb_false_value());
L343:; 
L346:; 
v6052 = (!strcmp("n", v5655));
if (v6052) goto L348; else goto L347;
L348:; 
v6075 = parse_uconstant__Context__28(mrb, self, "null", mrb_nil_value(), gctab);
return v6075;
L347:; 
L350:; 
v6097 = error__Context__27(mrb, self, "Invalid sequence", gctab);
v6113 = v6097;
L352:; 
return v6113;
}
static mrb_int initialize__Context__37(mrb_state *mrb, struct cls1_47 * self, char *v2964, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int v2975;
struct gctab *gctab = prevgctab;
L162:; 
self->v427 = "{\"foo\": \"baz\", \"abc\": \"abaz\"}"; /* [:char, "*", nil] -> [:char, "*", nil] */
self->v429 = 0; /* mrb_int -> mrb_int */
v2975 = 29;
self->v433 = v2975; /* mrb_int -> mrb_int */
return v2975;
}
static mrb_int initialize__Context__39(mrb_state *mrb, struct cls1_47 * self, char *v2964, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int v2975;
struct gctab *gctab = prevgctab;
L162:; 
self->v427 = "[true, \"foo\"]"; /* [:char, "*", nil] -> [:char, "*", nil] */
self->v429 = 0; /* mrb_int -> mrb_int */
v2975 = 13;
self->v433 = v2975; /* mrb_int -> mrb_int */
return v2975;
}
static mrb_int initialize__Context__41(mrb_state *mrb, struct cls1_47 * self, char *v2964, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int v2975;
struct gctab *gctab = prevgctab;
L162:; 
self->v427 = "{\"label\":[true, \"foo\"]}"; /* [:char, "*", nil] -> [:char, "*", nil] */
self->v429 = 0; /* mrb_int -> mrb_int */
v2975 = 23;
self->v433 = v2975; /* mrb_int -> mrb_int */
return v2975;
}
static mrb_int initialize__Context__43(mrb_state *mrb, struct cls1_47 * self, char *v2964, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int v2975;
struct gctab *gctab = prevgctab;
L162:; 
self->v427 = "[true, {\"foo\" : \"bar\"}]"; /* [:char, "*", nil] -> [:char, "*", nil] */
self->v429 = 0; /* mrb_int -> mrb_int */
v2975 = 23;
self->v433 = v2975; /* mrb_int -> mrb_int */
return v2975;
}
static mrb_value skip_uwhite__Context__26(mrb_state *mrb, struct cls1_47 * self, struct gctab *prevgctab) {
struct env13 env;
struct REnv *venv = NULL;
char *v8803 = " ";
char *v8804 = "\t";
char *v8805 = "\r";
char *v8806 = "\n";
char *v8808;
mrb_int v8809;
char *v8811;
mrb_value v8813;
mrb_int v8794;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = prevgctab;
L502:; 
L504:; 
char * v8807[6] = {
" ", "\t", "\r", "\n"};
 v8808 = self->v427;
 v8809 = self->v429;
{ char *tmpstr = alloca(2);
tmpstr[0] = v8808[v8809];
tmpstr[1] = '\0';
v8811 = tmpstr;
};
v8813 = include_q__Array__5(mrb, v8807, v8811, gctab);
if ((mrb_test(v8813))) goto L503; else goto L505;
L503:; 
 v8794 = self->v429;
self->v429 = (v8794 + 1); /* mrb_int -> mrb_int */
goto L504;
L505:; 
mrb_gc_arena_restore(mrb, ai);
return mrb_nil_value();
mrb_gc_arena_restore(mrb, ai);
}
static char * current__Context__26(mrb_state *mrb, struct cls1_47 * self, struct gctab *prevgctab) {
struct env23 env;
struct REnv *venv = NULL;
char *v14889;
mrb_int v14890;
char *v14892;
struct gctab *gctab = prevgctab;
L895:; 
 v14889 = self->v427;
 v14890 = self->v429;
{ char *tmpstr = prevgctab->caller_alloc; prevgctab->caller_alloc += ((0 + 1) * 4);
tmpstr[0] = v14889[v14890];
tmpstr[1] = '\0';
v14892 = tmpstr;
};
return v14892;
}
static mrb_value parse_uobject__Context__26(mrb_state *mrb, struct cls1_47 * self, struct gctab *prevgctab) {
struct env50 env;
struct REnv *venv = NULL;
char *v40521;
mrb_value v40522;
mrb_value v40736;
mrb_bool v40747;
mrb_value v40751;
mrb_value v40537;
char *v40540;
char *v40542 = "}";
mrb_bool v40544;
char *v40559;
char *v40573 = "\"";
mrb_bool v40575;
mrb_value v40595;
char *v40589 = "Expected \"\\\"\" but not found";
mrb_value v40591;
mrb_int v40606;
mrb_value v40609;
mrb_value v40613;
char *v40616;
char *v40618 = ":";
mrb_bool v40620;
mrb_value v40640;
mrb_value v40642;
char *v40634 = "Expected \":\" but not found";
mrb_value v40636;
mrb_value v40651;
mrb_value v40654;
mrb_value v40663;
char *v40666;
char *v40668 = "}";
mrb_bool v40670;
char *v40685;
char *v40699 = ",";
mrb_bool v40701;
mrb_value v40721;
char *v40715 = "Expected \",\" or \"}\" but not found";
mrb_value v40717;
char *v40732;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab) + 3 * sizeof(mrb_value *));
gctab->prev = prevgctab;
gctab->complex = NULL;
gctab->object = NULL;
gctab->size = 0;
gctab->csize = 0;
gctab->osize = 0;
gctab->ret_status = 0;
L2319:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v40521 = next__Context__26(mrb, self, gctab);
v40522 = mrb_hash_new(mrb);
v40736 = v40522;
L2331:; 
gctab->single[0] = &v40736;
gctab->size = 1;
v40747 = has_unext_q__Context__26(mrb, self, gctab);
v40751 = v40736;
if (v40747) goto L2320; else goto L2332;
L2320:; 
v40537 = skip_uwhite__Context__26(mrb, self, gctab);
gctab->caller_alloc = alloca(sizeof(char) * 4);
v40540 = next__Context__26(mrb, self, gctab);
v40544 = (!strcmp(v40540, "}"));
if (v40544) goto L2321; else goto L2322;
L2321:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v40559 = next__Context__26(mrb, self, gctab);
v40751 = v40736;
L2332:; 
mrb_gc_arena_restore(mrb, ai);
return v40751;
L2322:; 
v40575 = (!strcmp(v40540, "\""));
v40575 = (!(v40575));
v40595 = v40736;
if (v40575) goto L2323; else goto L2324;
L2323:; 
v40591 = error__Context__34(mrb, self, "Expected \"\\\"\" but not found", gctab);
v40595 = v40736;
L2324:; 
gctab->single[0] = &v40595;
v40606 = back__Context__26(mrb, self, gctab);
v40609 = parse_ustring__Context__26(mrb, self, gctab);
gctab->single[1] = &v40609;
gctab->size = 2;
v40613 = skip_uwhite__Context__26(mrb, self, gctab);
gctab->caller_alloc = alloca(sizeof(char) * 4);
v40616 = next__Context__26(mrb, self, gctab);
v40620 = (!strcmp(v40616, ":"));
v40620 = (!(v40620));
v40640 = v40595;
v40642 = v40609;
if (v40620) goto L2325; else goto L2326;
L2325:; 
v40636 = error__Context__35(mrb, self, "Expected \":\" but not found", gctab);
v40640 = v40595;
v40642 = v40609;
L2326:; 
gctab->single[0] = &v40640;
gctab->single[1] = &v40642;
v40651 = skip_uwhite__Context__26(mrb, self, gctab);
v40654 = parse_uvalue__Context__26(mrb, self, gctab);
mrb_hash_set(mrb, v40640, v40642, v40654)
;gctab->single[2] = &v40654;
gctab->size = 3;
v40663 = skip_uwhite__Context__26(mrb, self, gctab);
gctab->caller_alloc = alloca(sizeof(char) * 4);
v40666 = current__Context__26(mrb, self, gctab);
v40670 = (!strcmp(v40666, "}"));
if (v40670) goto L2327; else goto L2328;
L2327:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
gctab->size = 1;
v40685 = next__Context__26(mrb, self, gctab);
v40751 = v40640;
goto L2332;
L2328:; 
v40701 = (!strcmp(v40666, ","));
v40701 = (!(v40701));
v40721 = v40640;
if (v40701) goto L2329; else goto L2330;
L2329:; 
v40717 = error__Context__36(mrb, self, "Expected \",\" or \"}\" but not found", gctab);
v40721 = v40640;
L2330:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
gctab->single[0] = &v40721;
v40732 = next__Context__26(mrb, self, gctab);
v40736 = v40721;
goto L2331;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value parse_uarray__Context__26(mrb_state *mrb, struct cls1_47 * self, struct gctab *prevgctab) {
struct env47 env;
struct REnv *venv = NULL;
char *v37724;
mrb_value v37725;
mrb_value v37819;
mrb_bool v37827;
mrb_value v37831;
mrb_value v37737;
char *v37740;
char *v37741 = "]";
mrb_bool v37743;
mrb_value v37764;
mrb_value v37768;
char *v37771;
mrb_value v37776;
char *v37778 = "]";
mrb_bool v37780;
char *v37800 = ",";
mrb_bool v37802;
char *v37813 = "Expected \",\" or \"]\" but not found";
mrb_value v37815;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab) + 2 * sizeof(mrb_value *));
gctab->prev = prevgctab;
gctab->complex = NULL;
gctab->object = NULL;
gctab->size = 0;
gctab->csize = 0;
gctab->osize = 0;
gctab->ret_status = 0;
L2161:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v37724 = next__Context__26(mrb, self, gctab);
{
mrb_value tmpele[] = {

};
mrb->ud = (void *)gctab;
v37725 = mrb_ary_new_from_values(mrb, 0, tmpele);
ARY_SET_LEN(mrb_ary_ptr(v37725), 0);
}
v37819 = v37725;
L2168:; 
gctab->single[0] = &v37819;
gctab->size = 1;
v37827 = has_unext_q__Context__26(mrb, self, gctab);
v37831 = v37819;
if (v37827) goto L2162; else goto L2169;
L2162:; 
v37737 = skip_uwhite__Context__26(mrb, self, gctab);
gctab->caller_alloc = alloca(sizeof(char) * 4);
v37740 = current__Context__26(mrb, self, gctab);
v37743 = (!strcmp(v37740, "]"));
if (v37743) goto L2163; else goto L2164;
L2163:; 
v37831 = v37819;
L2169:; 
mrb_gc_arena_restore(mrb, ai);
return v37831;
L2164:; 
v37764 = parse_uvalue__Context__26(mrb, self, gctab);
gctab->single[1] = &v37764;
gctab->size = 2;
v37768 = skip_uwhite__Context__26(mrb, self, gctab);
gctab->caller_alloc = alloca(sizeof(char) * 4);
v37771 = next__Context__26(mrb, self, gctab);
mrb_ary_push(mrb, v37819, v37764);
v37776 = v37819;
v37780 = (!strcmp(v37771, "]"));
if (v37780) goto L2165; else goto L2166;
L2165:; 
v37831 = v37819;
goto L2169;
L2166:; 
v37802 = (!strcmp(v37771, ","));
v37802 = (!(v37802));
v37819 = v37819;
if (v37802) goto L2167; else goto L2168;
L2167:; 
gctab->size = 1;
v37815 = error__Context__33(mrb, self, "Expected \",\" or \"]\" but not found", gctab);
v37819 = v37819;
goto L2168;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value parse_ustring__Context__26(mrb_state *mrb, struct cls1_47 * self, struct gctab *prevgctab) {
struct env44 env;
struct REnv *venv = NULL;
char *v33867;
char *v33868 = "";
mrb_value v35012;
mrb_bool v35026;
char *v33886;
char *v33888 = "\\";
mrb_bool v33891;
char *v33924;
char *v33926 = "\\";
mrb_bool v33929;
mrb_value v33967;
char *v33968;
mrb_value v34912;
mrb_value v33982;
char *v33945 = "/";
mrb_bool v33948;
char *v33999 = "b";
mrb_bool v34002;
char *v34034 = "\b";
mrb_value v34036;
char *v34053 = "f";
mrb_bool v34056;
char *v34088 = "\f";
mrb_value v34090;
char *v34107 = "n";
mrb_bool v34110;
char *v34142 = "\n";
mrb_value v34144;
char *v34161 = "r";
mrb_bool v34164;
char *v34196 = "\r";
mrb_value v34198;
char *v34215 = "t";
mrb_bool v34218;
char *v34250 = "\t";
mrb_value v34252;
char *v34269 = "u";
mrb_bool v34272;
mrb_value v34393;
mrb_int v34395;
mrb_bool v34407;
mrb_value v34411;
mrb_int v34413;
char *v34321;
mrb_value v34324;
char *v34326 = "0123456789abcdef";
mrb_value v34329;
mrb_bool v34333;
mrb_int v34351;
mrb_value v34445;
mrb_value v34878;
mrb_value v34447;
mrb_value v34492;
mrb_value v34494;
mrb_value v34504;
mrb_value v34506;
mrb_value v34551;
mrb_value v34553;
mrb_value v34566;
mrb_value v34568;
mrb_value v34578;
mrb_value v34580;
mrb_value v34625;
mrb_value v34627;
mrb_value v34640;
mrb_value v34642;
mrb_value v34655;
mrb_value v34657;
mrb_value v34667;
mrb_value v34669;
mrb_value v34714;
mrb_value v34716;
mrb_value v34729;
mrb_value v34731;
mrb_value v34744;
mrb_value v34746;
mrb_value v34759;
mrb_value v34761;
mrb_value v34771;
mrb_value v34773;
mrb_value v34799;
mrb_value v34801;
mrb_value v34814;
mrb_value v34816;
mrb_value v34829;
mrb_value v34831;
mrb_value v34844;
mrb_value v34846;
mrb_value v34859;
mrb_value v34861;
mrb_value v34871;
mrb_value v34873;
char *v34906 = "Invalid string token";
mrb_value v34908;
char *v34939 = "\"";
mrb_bool v34942;
mrb_value v35007;
char *v35043 = "Invalid string token";
mrb_value v35045;
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab) + 2 * sizeof(mrb_value *));
gctab->prev = prevgctab;
gctab->complex = NULL;
gctab->object = NULL;
gctab->size = 0;
gctab->csize = 0;
gctab->osize = 0;
gctab->ret_status = 0;
L1961:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v33867 = next__Context__26(mrb, self, gctab);
v35012 = (mrb_str_new_cstr(mrb, ""));
L2010:; 
gctab->single[0] = &v35012;
gctab->size = 1;
v35026 = has_unext_q__Context__26(mrb, self, gctab);
if (v35026) goto L1962; else goto L2011;
L1962:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v33886 = next__Context__26(mrb, self, gctab);
v33891 = (!strcmp("\\", v33886));
if (v33891) goto L1964; else goto L1963;
L1964:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v33924 = next__Context__26(mrb, self, gctab);
v33929 = (!strcmp("\\", v33924));
v33967 = v35012;
v33968 = v33924;
if (v33929) goto L1967; else goto L1965;
L1967:; 
v33982 = mrb_str_cat_cstr(mrb, v33967, v33968);
v34912 = v33982;
L2004:; 
v35012 = v34912;
goto L2010;
L1965:; 
v33948 = (!strcmp("/", v33924));
v33967 = v35012;
v33968 = v33924;
if (v33948) goto L1967; else goto L1966;
L1966:; 
L1968:; 
v34002 = (!strcmp("b", v33924));
if (v34002) goto L1970; else goto L1969;
L1970:; 
v34036 = mrb_str_cat_cstr(mrb, v35012, "\b");
v34912 = v34036;
goto L2004;
L1969:; 
L1971:; 
v34056 = (!strcmp("f", v33924));
if (v34056) goto L1973; else goto L1972;
L1973:; 
v34090 = mrb_str_cat_cstr(mrb, v35012, "\f");
v34912 = v34090;
goto L2004;
L1972:; 
L1974:; 
v34110 = (!strcmp("n", v33924));
if (v34110) goto L1976; else goto L1975;
L1976:; 
v34144 = mrb_str_cat_cstr(mrb, v35012, "\n");
v34912 = v34144;
goto L2004;
L1975:; 
L1977:; 
v34164 = (!strcmp("r", v33924));
if (v34164) goto L1979; else goto L1978;
L1979:; 
v34198 = mrb_str_cat_cstr(mrb, v35012, "\r");
v34912 = v34198;
goto L2004;
L1978:; 
L1980:; 
v34218 = (!strcmp("t", v33924));
if (v34218) goto L1982; else goto L1981;
L1982:; 
v34252 = mrb_str_cat_cstr(mrb, v35012, "\t");
v34912 = v34252;
goto L2004;
L1981:; 
L1983:; 
v34272 = (!strcmp("u", v33924));
if (v34272) goto L1985; else goto L1984;
L1985:; 
v34393 = v35012;
v34395 = 0;
L1990:; 
gctab->single[0] = &v34393;
v34407 = has_unext_q__Context__26(mrb, self, gctab);
v34411 = v34393;
v34413 = v34395;
if (v34407) goto L1986; else goto L1991;
L1986:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v34321 = next__Context__26(mrb, self, gctab);
v34324 = (mrb_str_new_cstr(mrb, v34321));
v34329 = mrb_fixnum_value(mrb_str_index(mrb, (mrb_str_new_cstr(mrb, "0123456789abcdef")), RSTRING_PTR(v34324),strlen(RSTRING_PTR(v34324)), 0));
gctab->single[1] = &v34324;
gctab->size = 2;
if (!mrb_nil_p(v34329)) {
}
else {
v34333 = mrb_nil_p(mrb_nil_value());
}
if (v34333) goto L1987; else goto L1989;
L1987:; 
gctab->size = 1;
v34351 = back__Context__26(mrb, self, gctab);
v34411 = v34393;
v34413 = v34395;
L1991:; 
if ((v34413 < 128)) goto L1992; else goto L1993;
L1992:; 
{ char *tmpstr = alloca(2);
tmpstr[0] = v34413;
tmpstr[1] = '\0';
gctab->single[0] = &v34411;
gctab->single[1] = &v34411;
gctab->size = 2;
mrb->ud = (void *)gctab;
v34445 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34447 = mrb_str_cat_str(mrb, v34411, v34445);
v34878 = v34447;
L2002:; 
v34912 = v34878;
goto L2004;
L1993:; 
if ((v34413 < 2048)) goto L1994; else goto L1995;
L1994:; 
{ char *tmpstr = alloca(2);
tmpstr[0] = (192 | (v34413 >> 6));
tmpstr[1] = '\0';
mrb->ud = (void *)gctab;
v34492 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34494 = mrb_str_cat_str(mrb, v34411, v34492);
v34494 = v34494;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 + (v34413 & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v34494;
gctab->size = 1;
mrb->ud = (void *)gctab;
v34504 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34506 = mrb_str_cat_str(mrb, v34494, v34504);
v34878 = v34506;
goto L2002;
L1995:; 
if ((v34413 < 65536)) goto L1996; else goto L1997;
L1996:; 
{ char *tmpstr = alloca(2);
tmpstr[0] = (224 | (v34413 >> 12));
tmpstr[1] = '\0';
gctab->single[0] = &v34411;
gctab->size = 2;
mrb->ud = (void *)gctab;
v34551 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34553 = mrb_str_cat_str(mrb, v34411, v34551);
v34553 = v34553;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v34413 >> 6) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v34553;
gctab->size = 1;
mrb->ud = (void *)gctab;
v34566 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34568 = mrb_str_cat_str(mrb, v34553, v34566);
v34568 = v34568;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | (v34413 & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v34568;
mrb->ud = (void *)gctab;
v34578 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34580 = mrb_str_cat_str(mrb, v34568, v34578);
v34878 = v34580;
goto L2002;
L1997:; 
if ((v34413 < 2097152)) goto L1998; else goto L1999;
L1998:; 
{ char *tmpstr = alloca(2);
tmpstr[0] = (240 | (v34413 >> 18));
tmpstr[1] = '\0';
gctab->single[0] = &v34411;
gctab->size = 2;
mrb->ud = (void *)gctab;
v34625 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34627 = mrb_str_cat_str(mrb, v34411, v34625);
v34627 = v34627;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v34413 >> 12) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v34627;
gctab->size = 1;
mrb->ud = (void *)gctab;
v34640 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34642 = mrb_str_cat_str(mrb, v34627, v34640);
v34642 = v34642;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v34413 >> 6) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v34642;
mrb->ud = (void *)gctab;
v34655 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34657 = mrb_str_cat_str(mrb, v34642, v34655);
v34657 = v34657;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | (v34413 & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v34657;
mrb->ud = (void *)gctab;
v34667 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34669 = mrb_str_cat_str(mrb, v34657, v34667);
v34878 = v34669;
goto L2002;
L1999:; 
if ((v34413 < 67108864)) goto L2000; else goto L2001;
L2000:; 
{ char *tmpstr = alloca(2);
tmpstr[0] = (248 | (v34413 >> 24));
tmpstr[1] = '\0';
gctab->single[0] = &v34411;
gctab->size = 2;
mrb->ud = (void *)gctab;
v34714 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34716 = mrb_str_cat_str(mrb, v34411, v34714);
v34716 = v34716;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v34413 >> 18) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v34716;
gctab->size = 1;
mrb->ud = (void *)gctab;
v34729 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34731 = mrb_str_cat_str(mrb, v34716, v34729);
v34731 = v34731;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v34413 >> 12) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v34731;
mrb->ud = (void *)gctab;
v34744 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34746 = mrb_str_cat_str(mrb, v34731, v34744);
v34746 = v34746;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v34413 >> 6) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v34746;
mrb->ud = (void *)gctab;
v34759 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34761 = mrb_str_cat_str(mrb, v34746, v34759);
v34761 = v34761;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | (v34413 & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v34761;
mrb->ud = (void *)gctab;
v34771 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34773 = mrb_str_cat_str(mrb, v34761, v34771);
v34878 = v34773;
goto L2002;
L2001:; 
{ char *tmpstr = alloca(2);
tmpstr[0] = (252 | (v34413 >> 30));
tmpstr[1] = '\0';
gctab->single[0] = &v34411;
gctab->size = 2;
mrb->ud = (void *)gctab;
v34799 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34801 = mrb_str_cat_str(mrb, v34411, v34799);
v34801 = v34801;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v34413 >> 24) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v34801;
gctab->size = 1;
mrb->ud = (void *)gctab;
v34814 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34816 = mrb_str_cat_str(mrb, v34801, v34814);
v34816 = v34816;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v34413 >> 18) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v34816;
mrb->ud = (void *)gctab;
v34829 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34831 = mrb_str_cat_str(mrb, v34816, v34829);
v34831 = v34831;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v34413 >> 12) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v34831;
mrb->ud = (void *)gctab;
v34844 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34846 = mrb_str_cat_str(mrb, v34831, v34844);
v34846 = v34846;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v34413 >> 6) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v34846;
mrb->ud = (void *)gctab;
v34859 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34861 = mrb_str_cat_str(mrb, v34846, v34859);
v34861 = v34861;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | (v34413 & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v34861;
mrb->ud = (void *)gctab;
v34871 = mrb_str_new_cstr(mrb, tmpstr);
}
mrb->ud = (void *)gctab;
v34873 = mrb_str_cat_str(mrb, v34861, v34871);
v34878 = v34873;
goto L2002;
L1989:; 
v34393 = v34393;
v34395 = ((v34395 * 16) | (mrb_fixnum(v34329)));
goto L1990;
L1984:; 
L2003:; 
gctab->single[0] = &v35012;
v34908 = error__Context__32(mrb, self, "Invalid string token", gctab);
v34912 = v35012;
goto L2004;
L1963:; 
L2005:; 
v34942 = (!strcmp("\"", v33886));
if (v34942) goto L2007; else goto L2006;
L2007:; 
return v35012;
L2006:; 
L2009:; 
v35007 = mrb_str_cat_cstr(mrb, v35012, v33886);
v35012 = v35007;
goto L2010;
L2011:; 
gctab->size = 0;
v35045 = error__Context__32(mrb, self, "Invalid string token", gctab);
return v35045;
}
static mrb_value parse_unumber__Context__26(mrb_state *mrb, struct cls1_47 * self, struct gctab *prevgctab) {
struct env41 env;
struct REnv *venv = NULL;
char *v31084;
char *v31137;
mrb_bool v31144;
char *v31148;
char *v31096;
char *v31098 = "0123456789+-.eE";
mrb_bool v31101;
mrb_value v31132;
mrb_int v31120;
char *v31154 = ".";
mrb_bool v31156;
mrb_float2 v31167;
mrb_int v31178;
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab) + 0 * sizeof(mrb_value *));
gctab->prev = prevgctab;
gctab->complex = NULL;
gctab->object = NULL;
gctab->size = 0;
gctab->csize = 0;
gctab->osize = 0;
gctab->ret_status = 0;
L1803:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v31084 = next__Context__26(mrb, self, gctab);
v31137 = v31084;
L1808:; 
v31144 = has_unext_q__Context__26(mrb, self, gctab);
v31148 = v31137;
if (v31144) goto L1804; else goto L1809;
L1804:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v31096 = next__Context__26(mrb, self, gctab);
v31101 = (mrb_str_index(mrb, (mrb_str_new_cstr(mrb, "0123456789+-.eE")), v31096, strlen(v31096), 0) >= 0);
if (v31101) goto L1805; else goto L1806;
L1805:; 
L1807:; 
v31132 = mrb_str_cat_cstr(mrb, (mrb_str_new_cstr(mrb, v31137)), v31096);
v31137 = RSTRING_PTR(v31132);
goto L1808;
L1806:; 
v31120 = back__Context__26(mrb, self, gctab);
v31148 = v31137;
L1809:; 
v31156 = (mrb_str_index(mrb, (mrb_str_new_cstr(mrb, v31148)), ".", strlen("."), 0) >= 0);
if (v31156) goto L1810; else goto L1811;
L1810:; 
v31167 = ({mrb_float2 res; sscanf(v31148, "%g", &res); res;});
return (mrb_float_value2(v31167));
L1811:; 
v31178 = ({mrb_int res; sscanf(v31148, "%d", &res); res;});
return (mrb_fixnum_value(v31178));
}
static mrb_bool parse_uconstant__Context__31(mrb_state *mrb, struct cls1_47 * self, char *v20249, mrb_bool v20250, struct gctab *prevgctab) {
struct env29 env;
struct REnv *venv = NULL;
char *v20267 = "";
mrb_int v20268;
char *v20362;
mrb_bool v20363;
mrb_value v20365;
mrb_int v20366;
mrb_bool v20373;
char *v20282;
mrb_bool v20287;
char *v20346;
mrb_bool v20347;
mrb_value v20349;
mrb_int v20350;
char *v20351;
mrb_value v20358;
mrb_bool v20313;
mrb_int v20327;
char *v20341 = "Unknown token";
mrb_value v20343;
char *v20386 = "Unknown token";
mrb_value v20388;
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab) + 1 * sizeof(mrb_value *));
gctab->prev = prevgctab;
gctab->complex = NULL;
gctab->object = NULL;
gctab->size = 0;
gctab->csize = 0;
gctab->osize = 0;
gctab->ret_status = 0;
L1195:; 
 v20268 = self->v429;
v20362 = "true";
v20363 = 1;
v20365 = (mrb_str_new_cstr(mrb, ""));
v20366 = v20268;
L1202:; 
gctab->single[0] = &v20365;
gctab->size = 1;
v20373 = has_unext_q__Context__26(mrb, self, gctab);
if (v20373) goto L1196; else goto L1203;
L1196:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v20282 = next__Context__26(mrb, self, gctab);
v20287 = (mrb_str_index(mrb, (mrb_str_new_cstr(mrb, v20362)), v20282, strlen(v20282), 0) >= 0);
if (v20287) goto L1197; else goto L1198;
L1197:; 
v20346 = v20362;
v20347 = v20363;
v20349 = v20365;
v20350 = v20366;
v20351 = v20282;
L1201:; 
v20362 = v20346;
v20363 = v20347;
v20358 = mrb_str_cat_cstr(mrb, v20349, v20351);
v20365 = v20358;
v20366 = v20350;
goto L1202;
L1198:; 
v20313 = (!strcmp(RSTRING_PTR(v20365), v20362));
if (v20313) goto L1199; else goto L1200;
L1199:; 
gctab->size = 0;
v20327 = back__Context__26(mrb, self, gctab);
return v20363;
L1200:; 
self->v429 = v20366; /* mrb_int -> mrb_int */
gctab->size = 1;
v20343 = error__Context__29(mrb, self, "Unknown token", gctab);
v20346 = v20362;
v20347 = v20363;
v20349 = v20365;
v20350 = v20366;
v20351 = v20282;
goto L1201;
L1203:; 
gctab->size = 0;
v20388 = error__Context__29(mrb, self, "Unknown token", gctab);
return (mrb_test(v20388));
}
static mrb_bool parse_uconstant__Context__30(mrb_state *mrb, struct cls1_47 * self, char *v20249, mrb_bool v20250, struct gctab *prevgctab) {
struct env29 env;
struct REnv *venv = NULL;
char *v20267 = "";
mrb_int v20268;
char *v20362;
mrb_bool v20363;
mrb_value v20365;
mrb_int v20366;
mrb_bool v20373;
char *v20282;
mrb_bool v20287;
char *v20346;
mrb_bool v20347;
mrb_value v20349;
mrb_int v20350;
char *v20351;
mrb_value v20358;
mrb_bool v20313;
mrb_int v20327;
char *v20341 = "Unknown token";
mrb_value v20343;
char *v20386 = "Unknown token";
mrb_value v20388;
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab) + 1 * sizeof(mrb_value *));
gctab->prev = prevgctab;
gctab->complex = NULL;
gctab->object = NULL;
gctab->size = 0;
gctab->csize = 0;
gctab->osize = 0;
gctab->ret_status = 0;
L1195:; 
 v20268 = self->v429;
v20362 = "false";
v20363 = 0;
v20365 = (mrb_str_new_cstr(mrb, ""));
v20366 = v20268;
L1202:; 
gctab->single[0] = &v20365;
gctab->size = 1;
v20373 = has_unext_q__Context__26(mrb, self, gctab);
if (v20373) goto L1196; else goto L1203;
L1196:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v20282 = next__Context__26(mrb, self, gctab);
v20287 = (mrb_str_index(mrb, (mrb_str_new_cstr(mrb, v20362)), v20282, strlen(v20282), 0) >= 0);
if (v20287) goto L1197; else goto L1198;
L1197:; 
v20346 = v20362;
v20347 = v20363;
v20349 = v20365;
v20350 = v20366;
v20351 = v20282;
L1201:; 
v20362 = v20346;
v20363 = v20347;
v20358 = mrb_str_cat_cstr(mrb, v20349, v20351);
v20365 = v20358;
v20366 = v20350;
goto L1202;
L1198:; 
v20313 = (!strcmp(RSTRING_PTR(v20365), v20362));
if (v20313) goto L1199; else goto L1200;
L1199:; 
gctab->size = 0;
v20327 = back__Context__26(mrb, self, gctab);
return v20363;
L1200:; 
self->v429 = v20366; /* mrb_int -> mrb_int */
gctab->size = 1;
v20343 = error__Context__29(mrb, self, "Unknown token", gctab);
v20346 = v20362;
v20347 = v20363;
v20349 = v20365;
v20350 = v20366;
v20351 = v20282;
goto L1201;
L1203:; 
gctab->size = 0;
v20388 = error__Context__29(mrb, self, "Unknown token", gctab);
return (mrb_test(v20388));
}
static mrb_value parse_uconstant__Context__28(mrb_state *mrb, struct cls1_47 * self, char *v20249, mrb_value v20250, struct gctab *prevgctab) {
struct env29 env;
struct REnv *venv = NULL;
char *v20267 = "";
mrb_int v20268;
char *v20362;
mrb_value v20363;
mrb_value v20365;
mrb_int v20366;
mrb_bool v20373;
char *v20282;
mrb_bool v20287;
char *v20346;
mrb_value v20347;
mrb_value v20349;
mrb_int v20350;
char *v20351;
mrb_value v20358;
mrb_bool v20313;
mrb_int v20327;
char *v20341 = "Unknown token";
mrb_value v20343;
char *v20386 = "Unknown token";
mrb_value v20388;
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab) + 1 * sizeof(mrb_value *));
gctab->prev = prevgctab;
gctab->complex = NULL;
gctab->object = NULL;
gctab->size = 0;
gctab->csize = 0;
gctab->osize = 0;
gctab->ret_status = 0;
L1195:; 
 v20268 = self->v429;
v20362 = "null";
v20363 = mrb_nil_value();
v20365 = (mrb_str_new_cstr(mrb, ""));
v20366 = v20268;
L1202:; 
gctab->single[0] = &v20365;
gctab->size = 1;
v20373 = has_unext_q__Context__26(mrb, self, gctab);
if (v20373) goto L1196; else goto L1203;
L1196:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v20282 = next__Context__26(mrb, self, gctab);
v20287 = (mrb_str_index(mrb, (mrb_str_new_cstr(mrb, v20362)), v20282, strlen(v20282), 0) >= 0);
if (v20287) goto L1197; else goto L1198;
L1197:; 
v20346 = v20362;
v20347 = v20363;
v20349 = v20365;
v20350 = v20366;
v20351 = v20282;
L1201:; 
v20362 = v20346;
v20363 = v20347;
v20358 = mrb_str_cat_cstr(mrb, v20349, v20351);
v20365 = v20358;
v20366 = v20350;
goto L1202;
L1198:; 
v20313 = (!strcmp(RSTRING_PTR(v20365), v20362));
if (v20313) goto L1199; else goto L1200;
L1199:; 
gctab->size = 0;
v20327 = back__Context__26(mrb, self, gctab);
return v20363;
L1200:; 
self->v429 = v20366; /* mrb_int -> mrb_int */
gctab->size = 1;
v20343 = error__Context__29(mrb, self, "Unknown token", gctab);
v20346 = v20362;
v20347 = v20363;
v20349 = v20365;
v20350 = v20366;
v20351 = v20282;
goto L1201;
L1203:; 
gctab->size = 0;
v20388 = error__Context__29(mrb, self, "Unknown token", gctab);
return v20388;
}
static mrb_value error__Context__27(mrb_state *mrb, struct cls1_47 * self, char *v17553, struct gctab *prevgctab) {
struct env26 env;
struct REnv *venv = NULL;
char *v17568 = "";
mrb_value v17570;
char *v17571 = ": ";
mrb_value v17572;
char *v17573;
mrb_int v17574;
struct range_mrb_int *v17576;
char *v17578;
mrb_value v17579;
mrb_value v17581;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = prevgctab;
L1045:; 
v17570 = mrb_str_cat_cstr(mrb, (mrb_str_new_cstr(mrb, "")), "Invalid sequence");
v17572 = mrb_str_cat_cstr(mrb, v17570, ": ");
 v17573 = self->v427;
 v17574 = self->v429;
v17576 = alloca(sizeof(struct range_mrb_int));
v17576->first = v17574;
v17576->last = -1;
v17576->exclude_end = 1;
{ 
int last = ((v17576->last < 0) ? strlen(v17573) + v17576->last : v17576->last);
char *tmpstr = alloca(last - v17576->first + 1);
memcpy(tmpstr, v17573 + v17576->first, last - v17576->first);
tmpstr[last] = '\0';
v17578 = tmpstr;
};
v17579 = mrb_str_cat_cstr(mrb, v17572, v17578);
mrb_exc_raise(mrb, mrb_make_exception(mrb, 1, &v17579));
mrb_gc_arena_restore(mrb, ai);
return v17581;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value include_q__Array__5(mrb_state *mrb, char * *self, char *v10542, struct gctab *prevgctab) {
struct env16 env;
struct REnv *venv = NULL;
struct proc17 v10551;
mrb_value v10602;
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L630:; 
env.v10546 = v10542;/*enter */
v10551.id = 17;
v10551.self = self;
v10551.env = &env;
v10602 = each__Array__6(mrb, self, ((gproc)&v10551), gctab);
if (gctab->ret_status) return v10602;
return ((0) ? mrb_true_value() : mrb_false_value());
}
static char * next__Context__26(mrb_state *mrb, struct cls1_47 * self, struct gctab *prevgctab) {
struct env35 env;
struct REnv *venv = NULL;
char *v25733;
mrb_int v25734;
char *v25736;
mrb_int v25738;
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L1503:; 
 v25733 = self->v427;
 v25734 = self->v429;
{ char *tmpstr = prevgctab->caller_alloc; prevgctab->caller_alloc += ((0 + 1) * 4);
tmpstr[0] = v25733[v25734];
tmpstr[1] = '\0';
v25736 = tmpstr;
};
 v25738 = self->v429;
self->v429 = (v25738 + 1); /* mrb_int -> mrb_int */
return v25736;
}
static mrb_bool has_unext_q__Context__26(mrb_state *mrb, struct cls1_47 * self, struct gctab *prevgctab) {
struct env32 env;
struct REnv *venv = NULL;
mrb_int v23057;
mrb_int v23058;
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L1353:; 
 v23057 = self->v429;
 v23058 = self->v433;
return (v23057 < v23058);
}
static mrb_value error__Context__34(mrb_state *mrb, struct cls1_47 * self, char *v17553, struct gctab *prevgctab) {
struct env26 env;
struct REnv *venv = NULL;
char *v17568 = "";
mrb_value v17570;
char *v17571 = ": ";
mrb_value v17572;
char *v17573;
mrb_int v17574;
struct range_mrb_int *v17576;
char *v17578;
mrb_value v17579;
mrb_value v17581;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L1045:; 
v17570 = mrb_str_cat_str(mrb, (mrb_str_new_cstr(mrb, "")), (mrb_str_new_cstr(mrb, "Expected \"\\\"\" but not found")));
v17572 = mrb_str_cat_cstr(mrb, v17570, ": ");
 v17573 = self->v427;
 v17574 = self->v429;
v17576 = alloca(sizeof(struct range_mrb_int));
v17576->first = v17574;
v17576->last = -1;
v17576->exclude_end = 1;
{ 
int last = ((v17576->last < 0) ? strlen(v17573) + v17576->last : v17576->last);
char *tmpstr = alloca(last - v17576->first + 1);
memcpy(tmpstr, v17573 + v17576->first, last - v17576->first);
tmpstr[last] = '\0';
v17578 = tmpstr;
};
v17579 = mrb_str_cat_cstr(mrb, v17572, v17578);
mrb_exc_raise(mrb, mrb_make_exception(mrb, 1, &v17579));
mrb_gc_arena_restore(mrb, ai);
return v17581;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_int back__Context__26(mrb_state *mrb, struct cls1_47 * self, struct gctab *prevgctab) {
struct env38 env;
struct REnv *venv = NULL;
mrb_int v28408;
mrb_int v28409;/*snd*/
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L1653:; 
 v28408 = self->v429;
v28409 = (v28408 - 1);
self->v429 = v28409; /* mrb_int -> mrb_int */
return v28409;
}
static mrb_value error__Context__35(mrb_state *mrb, struct cls1_47 * self, char *v17553, struct gctab *prevgctab) {
struct env26 env;
struct REnv *venv = NULL;
char *v17568 = "";
mrb_value v17570;
char *v17571 = ": ";
mrb_value v17572;
char *v17573;
mrb_int v17574;
struct range_mrb_int *v17576;
char *v17578;
mrb_value v17579;
mrb_value v17581;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L1045:; 
v17570 = mrb_str_cat_str(mrb, (mrb_str_new_cstr(mrb, "")), (mrb_str_new_cstr(mrb, "Expected \":\" but not found")));
v17572 = mrb_str_cat_cstr(mrb, v17570, ": ");
 v17573 = self->v427;
 v17574 = self->v429;
v17576 = alloca(sizeof(struct range_mrb_int));
v17576->first = v17574;
v17576->last = -1;
v17576->exclude_end = 1;
{ 
int last = ((v17576->last < 0) ? strlen(v17573) + v17576->last : v17576->last);
char *tmpstr = alloca(last - v17576->first + 1);
memcpy(tmpstr, v17573 + v17576->first, last - v17576->first);
tmpstr[last] = '\0';
v17578 = tmpstr;
};
v17579 = mrb_str_cat_cstr(mrb, v17572, v17578);
mrb_exc_raise(mrb, mrb_make_exception(mrb, 1, &v17579));
mrb_gc_arena_restore(mrb, ai);
return v17581;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value error__Context__36(mrb_state *mrb, struct cls1_47 * self, char *v17553, struct gctab *prevgctab) {
struct env26 env;
struct REnv *venv = NULL;
char *v17568 = "";
mrb_value v17570;
char *v17571 = ": ";
mrb_value v17572;
char *v17573;
mrb_int v17574;
struct range_mrb_int *v17576;
char *v17578;
mrb_value v17579;
mrb_value v17581;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L1045:; 
v17570 = mrb_str_cat_str(mrb, (mrb_str_new_cstr(mrb, "")), (mrb_str_new_cstr(mrb, "Expected \",\" or \"}\" but not found")));
v17572 = mrb_str_cat_cstr(mrb, v17570, ": ");
 v17573 = self->v427;
 v17574 = self->v429;
v17576 = alloca(sizeof(struct range_mrb_int));
v17576->first = v17574;
v17576->last = -1;
v17576->exclude_end = 1;
{ 
int last = ((v17576->last < 0) ? strlen(v17573) + v17576->last : v17576->last);
char *tmpstr = alloca(last - v17576->first + 1);
memcpy(tmpstr, v17573 + v17576->first, last - v17576->first);
tmpstr[last] = '\0';
v17578 = tmpstr;
};
v17579 = mrb_str_cat_cstr(mrb, v17572, v17578);
mrb_exc_raise(mrb, mrb_make_exception(mrb, 1, &v17579));
mrb_gc_arena_restore(mrb, ai);
return v17581;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value error__Context__33(mrb_state *mrb, struct cls1_47 * self, char *v17553, struct gctab *prevgctab) {
struct env26 env;
struct REnv *venv = NULL;
char *v17568 = "";
mrb_value v17570;
char *v17571 = ": ";
mrb_value v17572;
char *v17573;
mrb_int v17574;
struct range_mrb_int *v17576;
char *v17578;
mrb_value v17579;
mrb_value v17581;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L1045:; 
v17570 = mrb_str_cat_str(mrb, (mrb_str_new_cstr(mrb, "")), (mrb_str_new_cstr(mrb, "Expected \",\" or \"]\" but not found")));
v17572 = mrb_str_cat_cstr(mrb, v17570, ": ");
 v17573 = self->v427;
 v17574 = self->v429;
v17576 = alloca(sizeof(struct range_mrb_int));
v17576->first = v17574;
v17576->last = -1;
v17576->exclude_end = 1;
{ 
int last = ((v17576->last < 0) ? strlen(v17573) + v17576->last : v17576->last);
char *tmpstr = alloca(last - v17576->first + 1);
memcpy(tmpstr, v17573 + v17576->first, last - v17576->first);
tmpstr[last] = '\0';
v17578 = tmpstr;
};
v17579 = mrb_str_cat_cstr(mrb, v17572, v17578);
mrb_exc_raise(mrb, mrb_make_exception(mrb, 1, &v17579));
mrb_gc_arena_restore(mrb, ai);
return v17581;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value error__Context__32(mrb_state *mrb, struct cls1_47 * self, char *v17553, struct gctab *prevgctab) {
struct env26 env;
struct REnv *venv = NULL;
char *v17568 = "";
mrb_value v17570;
char *v17571 = ": ";
mrb_value v17572;
char *v17573;
mrb_int v17574;
struct range_mrb_int *v17576;
char *v17578;
mrb_value v17579;
mrb_value v17581;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L1045:; 
v17570 = mrb_str_cat_str(mrb, (mrb_str_new_cstr(mrb, "")), (mrb_str_new_cstr(mrb, "Invalid string token")));
v17572 = mrb_str_cat_cstr(mrb, v17570, ": ");
 v17573 = self->v427;
 v17574 = self->v429;
v17576 = alloca(sizeof(struct range_mrb_int));
v17576->first = v17574;
v17576->last = -1;
v17576->exclude_end = 1;
{ 
int last = ((v17576->last < 0) ? strlen(v17573) + v17576->last : v17576->last);
char *tmpstr = alloca(last - v17576->first + 1);
memcpy(tmpstr, v17573 + v17576->first, last - v17576->first);
tmpstr[last] = '\0';
v17578 = tmpstr;
};
v17579 = mrb_str_cat_cstr(mrb, v17572, v17578);
mrb_exc_raise(mrb, mrb_make_exception(mrb, 1, &v17579));
mrb_gc_arena_restore(mrb, ai);
return v17581;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value error__Context__29(mrb_state *mrb, struct cls1_47 * self, char *v17553, struct gctab *prevgctab) {
struct env26 env;
struct REnv *venv = NULL;
char *v17568 = "";
mrb_value v17570;
char *v17571 = ": ";
mrb_value v17572;
char *v17573;
mrb_int v17574;
struct range_mrb_int *v17576;
char *v17578;
mrb_value v17579;
mrb_value v17581;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L1045:; 
v17570 = mrb_str_cat_str(mrb, (mrb_str_new_cstr(mrb, "")), (mrb_str_new_cstr(mrb, "Unknown token")));
v17572 = mrb_str_cat_cstr(mrb, v17570, ": ");
 v17573 = self->v427;
 v17574 = self->v429;
v17576 = alloca(sizeof(struct range_mrb_int));
v17576->first = v17574;
v17576->last = -1;
v17576->exclude_end = 1;
{ 
int last = ((v17576->last < 0) ? strlen(v17573) + v17576->last : v17576->last);
char *tmpstr = alloca(last - v17576->first + 1);
memcpy(tmpstr, v17573 + v17576->first, last - v17576->first);
tmpstr[last] = '\0';
v17578 = tmpstr;
};
v17579 = mrb_str_cat_cstr(mrb, v17572, v17578);
mrb_exc_raise(mrb, mrb_make_exception(mrb, 1, &v17579));
mrb_gc_arena_restore(mrb, ai);
return v17581;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value each__Array__6(mrb_state *mrb, char * *self, gproc v12130, struct gctab *prevgctab) {
struct env20 env;
struct REnv *venv = NULL;
gproc v12191;
mrb_int v12192;
mrb_int v12200;
char *v12183;
mrb_value v12185;
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L739:; 
L740:; 
L742:; 
v12191 = v12130;
v12192 = 0;
L744:; 
v12200 = 4;
if ((v12192 < v12200)) goto L743; else goto L745;
L743:; 
v12183 = self[v12192];
v12185 = (p17_Array_0_8(mrb, v12191, v12183, gctab));
if (gctab->ret_status) {
prevgctab->ret_status = 2;
return v12185;
}
v12191 = v12191;
v12192 = (v12192 + 1);
goto L744;
L745:; 
return mmc_boxing_array(self, 5, mrb_str_new_cstr);
}
static mrb_value p17_Array_0_8(mrb_state *mrb, gproc cgproc, char *v10555, struct gctab *prevgctab) {
struct proc17 *proc = (struct proc17 *)cgproc;
char * *self = proc->self;
struct env17 env;
struct REnv *venv = NULL;
char * *v10560;
char *v10567;
char *v10568;
mrb_bool v10570;
mrb_value v10598;
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
env.prev = proc->env;
L631:; 
v10560 = &v10555;
v10567 = v10560[0];
v10568 = proc->env->v10546;
v10570 = (!strcmp(v10567, v10568));
if (v10570) goto L632; else goto L634;
L632:; 
prevgctab->ret_status = 2;
return ((1) ? mrb_true_value() : mrb_false_value());
L634:; 
v10598 = mrb_nil_value();
L635:; 
return v10598;
}
/*
Class Object
 Instance variables

 methodes 
  top (Object e=false, NilClass e=false) -> Literal NilClass|Literal FalseClass|Literal TrueClass|Float e=false pos =false|Fixnum e=false pos =true|String e=true|Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true|[:undef] => Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true> e=true> e=true|Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true|[:undef] => <Hash ...> e=true> e=true> e=true 
  parse (Object e=false, String e=false, NilClass e=false) -> Literal NilClass|Literal FalseClass|Literal TrueClass|Float e=false pos =false|Fixnum e=false pos =true|String e=true|Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true|[:undef] => Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true> e=true> e=true|Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true|[:undef] => <Hash ...> e=true> e=true> e=true 
  p (Object e=false, Literal NilClass|Literal FalseClass|Literal TrueClass|Float e=false pos =false|Fixnum e=false pos =true|String e=true|Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true|[:undef] => Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true> e=true> e=true|[:undef] => Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true|[:undef] => <Hash ...> e=true> e=true> e=true> e=true|Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true|[:undef] => Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true> e=true> e=true> e=true, NilClass e=false) -> Literal NilClass|Literal FalseClass|Literal TrueClass|Float e=false pos =false|Fixnum e=false pos =true|String e=true|Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true|[:undef] => Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true> e=true> e=true|Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true|[:undef] => <Hash ...> e=true> e=true> e=true 

Class Context
 Instance variables
  @buf: String e=false
  @index: Fixnum e=false pos =true
  @length: Fixnum e=false pos =true

 methodes 
  initialize (Context e=false, String e=false, NilClass e=false) -> Fixnum e=false pos =true 
  parse_value (Context e=false, NilClass e=false) -> Literal NilClass|Literal FalseClass|Literal TrueClass|Float e=false pos =false|Fixnum e=false pos =true|String e=true|Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true|[:undef] => Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true> e=true> e=true|Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true|[:undef] => <Hash ...> e=true> e=true> e=true 
  skip_white (Context e=false, NilClass e=false) -> Literal NilClass 
  current (Context e=false, NilClass e=false) -> String e=false 
  error (Context e=false, String e=false, NilClass e=false) ->  (throws String e=true)
  parse_constant (Context e=false, String e=false, Literal NilClass, NilClass e=false) -> Literal NilClass 
  parse_constant (Context e=false, String e=false, Literal FalseClass, NilClass e=false) -> Literal FalseClass 
  parse_constant (Context e=false, String e=false, Literal TrueClass, NilClass e=false) -> Literal TrueClass 
  has_next? (Context e=false, NilClass e=false) -> Literal TrueClass|Literal FalseClass 
  next (Context e=false, NilClass e=false) -> String e=false 
  back (Context e=false, NilClass e=false) -> Fixnum e=false pos =true 
  parse_number (Context e=false, NilClass e=false) -> Float e=false pos =false|Fixnum e=false pos =true 
  parse_string (Context e=false, NilClass e=false) -> String e=true 
  parse_array (Context e=false, NilClass e=false) -> Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true|[:undef] => Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true> e=true> e=true 
  parse_object (Context e=false, NilClass e=false) -> Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true|[:undef] => <Hash ...> e=true> e=true> e=true 

Module Enumerable
 Instance variables

 methodes 

Class Array
 Instance variables

 methodes 
  include? (Array<[:undef] => String e=false|0 => String e=false|1 => String e=false|2 => String e=false|3 => String e=false> e=false, String e=false, NilClass e=false) -> Literal TrueClass|Array<[:undef] => String e=false|0 => String e=false|1 => String e=false|2 => String e=false|3 => String e=false> e=false|Literal NilClass|Literal FalseClass 
  each (Array<[:undef] => String e=false|0 => String e=false|1 => String e=false|2 => String e=false|3 => String e=false> e=false,  (Array<[:undef] => String e=false|0 => String e=false|1 => String e=false|2 => String e=false|3 => String e=false> e=false, String e=false, NilClass e=false) -> Literal NilClass ) -> Array<[:undef] => String e=false|0 => String e=false|1 => String e=false|2 => String e=false|3 => String e=false> e=false|Literal NilClass 
  inspect (Literal NilClass|Literal FalseClass|Literal TrueClass|Float e=false pos =false|Fixnum e=false pos =true|String e=true|Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true|[:undef] => Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true> e=true> e=true|[:undef] => Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true|[:undef] => <Hash ...> e=true> e=true> e=true> e=true|Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true|[:undef] => Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true> e=true> e=true> e=true, NilClass e=false) -> String e=false 

Module Kernel
 Instance variables

 methodes 

Class NilClass
 Instance variables

 methodes 
  _inspect (Literal NilClass, NilClass e=false) -> String e=false 

Class Hash
 Instance variables

 methodes 
  inspect (Literal NilClass|Literal FalseClass|Literal TrueClass|Float e=false pos =false|Fixnum e=false pos =true|String e=true|Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true|[:undef] => Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true> e=true> e=true|[:undef] => Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true|[:undef] => <Hash ...> e=true> e=true> e=true> e=true|Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => Array<[:undef] => Literal NilClass|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true|[:undef] => Hash<[:undef] => NilClass e=false|[:undef] => Literal FalseClass|[:undef] => Literal TrueClass|[:undef] => Float e=false pos =false|[:undef] => Fixnum e=false pos =true|[:undef] => String e=true|[:undef] => <Array ...> e=true> e=true> e=true> e=true, NilClass e=false) -> String e=false 

Class #<Class:Context>
 Instance variables

 methodes 

Class TrueClass
 Instance variables

 methodes 

Class FalseClass
 Instance variables

 methodes 

*/