pjson生成コード

#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 *v10285;
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 *v391; /* @buf */
mrb_int v393; /* @index */
mrb_int v397; /* @length */
};
struct cls1_47 {
char *v391; /* @buf */
mrb_int v393; /* @index */
mrb_int v397; /* @length */
};
struct cls8_44 {
};
struct cls9_44 {
};
struct cls10_44 {
};
struct cls3_44 {
};
struct cls5_44 {
};
struct cls11_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 *v259,struct gctab *);
struct cls7_44 * const0;
static mrb_value parse__Object__24(mrb_state *, mrb_value self, char *v259,struct gctab *);
static mrb_value parse__Object__38(mrb_state *, mrb_value self, char *v259,struct gctab *);
static mrb_value parse__Object__40(mrb_state *, mrb_value self, char *v259,struct gctab *);
static mrb_value parse__Object__42(mrb_state *, mrb_value self, char *v259,struct gctab *);
static mrb_int initialize__Context__46(mrb_state *, struct cls1_47 * self, char *v2861,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 *v2861,struct gctab *);
static mrb_int initialize__Context__39(mrb_state *, struct cls1_47 * self, char *v2861,struct gctab *);
static mrb_int initialize__Context__41(mrb_state *, struct cls1_47 * self, char *v2861,struct gctab *);
static mrb_int initialize__Context__43(mrb_state *, struct cls1_47 * self, char *v2861,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 *v19751, mrb_bool v19752,struct gctab *);
static mrb_bool parse_uconstant__Context__30(mrb_state *, struct cls1_47 * self, char *v19751, mrb_bool v19752,struct gctab *);
static mrb_value parse_uconstant__Context__28(mrb_state *, struct cls1_47 * self, char *v19751, mrb_value v19752,struct gctab *);
static mrb_value error__Context__27(mrb_state *, struct cls1_47 * self, char *v17134,struct gctab *);
static mrb_value include_q__Array__5(mrb_state *, char * *self, char *v10281,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 *v17134,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 *v17134,struct gctab *);
static mrb_value error__Context__36(mrb_state *, struct cls1_47 * self, char *v17134,struct gctab *);
static mrb_value error__Context__33(mrb_state *, struct cls1_47 * self, char *v17134,struct gctab *);
static mrb_value error__Context__32(mrb_state *, struct cls1_47 * self, char *v17134,struct gctab *);
static mrb_value error__Context__29(mrb_state *, struct cls1_47 * self, char *v17134,struct gctab *);
static mrb_value each__Array__6(mrb_state *, char * *self, gproc v11869,struct gctab *);
static mrb_value p17_Array_0_8(mrb_state *, gproc cgproc, char *v10294, 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 *v127 = "{\"foo\": \"bar\"}";
mrb_value v129;
mrb_value v131;
char *v134 = "{\"foo\": \"baz\", \"abc\": \"abaz\"}";
mrb_value v136;
mrb_value v138;
char *v141 = "[true, \"foo\"]";
mrb_value v143;
mrb_value v145;
char *v148 = "{\"label\":[true, \"foo\"]}";
mrb_value v150;
mrb_value v152;
char *v155 = "[true, {\"foo\" : \"bar\"}]";
mrb_value v157;
mrb_value v159;
struct gctab *gctab = prevgctab;
L5:; 
v129 = parse__Object__2(mrb, self, "{\"foo\": \"bar\"}", gctab);
mrb->ud = (void *)gctab;
mrb_p(mrb, v129);
v131 = v129;
v136 = parse__Object__24(mrb, self, "{\"foo\": \"baz\", \"abc\": \"abaz\"}", gctab);
mrb->ud = (void *)gctab;
mrb_p(mrb, v136);
v138 = v136;
v143 = parse__Object__38(mrb, self, "[true, \"foo\"]", gctab);
mrb->ud = (void *)gctab;
mrb_p(mrb, v143);
v145 = v143;
v150 = parse__Object__40(mrb, self, "{\"label\":[true, \"foo\"]}", gctab);
mrb->ud = (void *)gctab;
mrb_p(mrb, v150);
v152 = v150;
v157 = parse__Object__42(mrb, self, "[true, {\"foo\" : \"bar\"}]", gctab);
mrb->ud = (void *)gctab;
mrb_p(mrb, v157);
v159 = v157;
return v159;
}
static mrb_value parse__Object__2(mrb_state *mrb, mrb_value self, char *v259, struct gctab *prevgctab) {
struct env4 env;
struct REnv *venv = NULL;
struct cls1_45 * v272;
mrb_value v274;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = prevgctab;
L10:; 
v272 = alloca(sizeof(struct cls1_45));
v272->v391 = NULL;
initialize__Context__46(mrb, v272, "{\"foo\": \"bar\"}", gctab);
v274 = parse_uvalue__Context__26(mrb, v272, gctab);
mrb_gc_arena_restore(mrb, ai);
return v274;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value parse__Object__24(mrb_state *mrb, mrb_value self, char *v259, struct gctab *prevgctab) {
struct env4 env;
struct REnv *venv = NULL;
struct cls1_47 * v272;
mrb_value v274;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = prevgctab;
L10:; 
v272 = alloca(sizeof(struct cls1_47));
v272->v391 = NULL;
initialize__Context__37(mrb, v272, "{\"foo\": \"baz\", \"abc\": \"abaz\"}", gctab);
v274 = parse_uvalue__Context__26(mrb, v272, gctab);
mrb_gc_arena_restore(mrb, ai);
return v274;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value parse__Object__38(mrb_state *mrb, mrb_value self, char *v259, struct gctab *prevgctab) {
struct env4 env;
struct REnv *venv = NULL;
struct cls1_47 * v272;
mrb_value v274;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = prevgctab;
L10:; 
v272 = alloca(sizeof(struct cls1_47));
v272->v391 = NULL;
initialize__Context__39(mrb, v272, "[true, \"foo\"]", gctab);
v274 = parse_uvalue__Context__26(mrb, v272, gctab);
mrb_gc_arena_restore(mrb, ai);
return v274;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value parse__Object__40(mrb_state *mrb, mrb_value self, char *v259, struct gctab *prevgctab) {
struct env4 env;
struct REnv *venv = NULL;
struct cls1_47 * v272;
mrb_value v274;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = prevgctab;
L10:; 
v272 = alloca(sizeof(struct cls1_47));
v272->v391 = NULL;
initialize__Context__41(mrb, v272, "{\"label\":[true, \"foo\"]}", gctab);
v274 = parse_uvalue__Context__26(mrb, v272, gctab);
mrb_gc_arena_restore(mrb, ai);
return v274;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value parse__Object__42(mrb_state *mrb, mrb_value self, char *v259, struct gctab *prevgctab) {
struct env4 env;
struct REnv *venv = NULL;
struct cls1_47 * v272;
mrb_value v274;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = prevgctab;
L10:; 
v272 = alloca(sizeof(struct cls1_47));
v272->v391 = NULL;
initialize__Context__43(mrb, v272, "[true, {\"foo\" : \"bar\"}]", gctab);
v274 = parse_uvalue__Context__26(mrb, v272, gctab);
mrb_gc_arena_restore(mrb, ai);
return v274;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_int initialize__Context__46(mrb_state *mrb, struct cls1_47 * self, char *v2861, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int v2872;
struct gctab *gctab = prevgctab;
L158:; 
self->v391 = "{\"foo\": \"bar\"}"; /* [:char, "*", nil] -> [:char, "*", nil] */
self->v393 = 0; /* mrb_int -> mrb_int */
v2872 = 14;
self->v397 = v2872; /* mrb_int -> mrb_int */
return v2872;
}
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 v5470;
char *v5473;
char *v5475 = "{";
mrb_bool v5478;
mrb_value v5499;
char *v5518 = "[";
mrb_bool v5521;
mrb_value v5542;
char *v5561 = "\"";
mrb_bool v5564;
mrb_value v5585;
char *v5604 = "0";
mrb_bool v5607;
mrb_value v5758;
char *v5617 = "1";
mrb_bool v5620;
char *v5630 = "2";
mrb_bool v5633;
char *v5643 = "3";
mrb_bool v5646;
char *v5656 = "4";
mrb_bool v5659;
char *v5669 = "5";
mrb_bool v5672;
char *v5682 = "6";
mrb_bool v5685;
char *v5695 = "7";
mrb_bool v5698;
char *v5708 = "8";
mrb_bool v5711;
char *v5721 = "9";
mrb_bool v5724;
char *v5734 = "-";
mrb_bool v5737;
char *v5777 = "t";
mrb_bool v5780;
char *v5800 = "true";
mrb_bool v5803;
char *v5822 = "f";
mrb_bool v5825;
char *v5845 = "false";
mrb_bool v5848;
char *v5867 = "n";
mrb_bool v5870;
char *v5890 = "null";
mrb_value v5893;
char *v5913 = "Invalid sequence";
mrb_value v5915;
mrb_value v5931;
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;
L306:; 
v5470 = skip_uwhite__Context__26(mrb, self, gctab);
gctab->caller_alloc = alloca(sizeof(char) * 4);
v5473 = current__Context__26(mrb, self, gctab);
v5478 = (!strcmp("{", v5473));
if (v5478) goto L308; else goto L307;
L308:; 
v5499 = parse_uobject__Context__26(mrb, self, gctab);
return v5499;
L307:; 
L310:; 
v5521 = (!strcmp("[", v5473));
if (v5521) goto L312; else goto L311;
L312:; 
v5542 = parse_uarray__Context__26(mrb, self, gctab);
return v5542;
L311:; 
L314:; 
v5564 = (!strcmp("\"", v5473));
if (v5564) goto L316; else goto L315;
L316:; 
v5585 = parse_ustring__Context__26(mrb, self, gctab);
return v5585;
L315:; 
L318:; 
v5607 = (!strcmp("0", v5473));
if (v5607) goto L330; else goto L319;
L330:; 
v5758 = parse_unumber__Context__26(mrb, self, gctab);
return v5758;
L319:; 
v5620 = (!strcmp("1", v5473));
if (v5620) goto L330; else goto L320;
L320:; 
v5633 = (!strcmp("2", v5473));
if (v5633) goto L330; else goto L321;
L321:; 
v5646 = (!strcmp("3", v5473));
if (v5646) goto L330; else goto L322;
L322:; 
v5659 = (!strcmp("4", v5473));
if (v5659) goto L330; else goto L323;
L323:; 
v5672 = (!strcmp("5", v5473));
if (v5672) goto L330; else goto L324;
L324:; 
v5685 = (!strcmp("6", v5473));
if (v5685) goto L330; else goto L325;
L325:; 
v5698 = (!strcmp("7", v5473));
if (v5698) goto L330; else goto L326;
L326:; 
v5711 = (!strcmp("8", v5473));
if (v5711) goto L330; else goto L327;
L327:; 
v5724 = (!strcmp("9", v5473));
if (v5724) goto L330; else goto L328;
L328:; 
v5737 = (!strcmp("-", v5473));
if (v5737) goto L330; else goto L329;
L329:; 
L332:; 
v5780 = (!strcmp("t", v5473));
if (v5780) goto L334; else goto L333;
L334:; 
v5803 = parse_uconstant__Context__31(mrb, self, "true", 1, gctab);
return ((v5803) ? mrb_true_value() : mrb_false_value());
L333:; 
L336:; 
v5825 = (!strcmp("f", v5473));
if (v5825) goto L338; else goto L337;
L338:; 
v5848 = parse_uconstant__Context__30(mrb, self, "false", 0, gctab);
return ((v5848) ? mrb_true_value() : mrb_false_value());
L337:; 
L340:; 
v5870 = (!strcmp("n", v5473));
if (v5870) goto L342; else goto L341;
L342:; 
v5893 = parse_uconstant__Context__28(mrb, self, "null", mrb_nil_value(), gctab);
return v5893;
L341:; 
L344:; 
v5915 = error__Context__27(mrb, self, "Invalid sequence", gctab);
v5931 = v5915;
L346:; 
return v5931;
}
static mrb_int initialize__Context__37(mrb_state *mrb, struct cls1_47 * self, char *v2861, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int v2872;
struct gctab *gctab = prevgctab;
L158:; 
self->v391 = "{\"foo\": \"baz\", \"abc\": \"abaz\"}"; /* [:char, "*", nil] -> [:char, "*", nil] */
self->v393 = 0; /* mrb_int -> mrb_int */
v2872 = 29;
self->v397 = v2872; /* mrb_int -> mrb_int */
return v2872;
}
static mrb_int initialize__Context__39(mrb_state *mrb, struct cls1_47 * self, char *v2861, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int v2872;
struct gctab *gctab = prevgctab;
L158:; 
self->v391 = "[true, \"foo\"]"; /* [:char, "*", nil] -> [:char, "*", nil] */
self->v393 = 0; /* mrb_int -> mrb_int */
v2872 = 13;
self->v397 = v2872; /* mrb_int -> mrb_int */
return v2872;
}
static mrb_int initialize__Context__41(mrb_state *mrb, struct cls1_47 * self, char *v2861, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int v2872;
struct gctab *gctab = prevgctab;
L158:; 
self->v391 = "{\"label\":[true, \"foo\"]}"; /* [:char, "*", nil] -> [:char, "*", nil] */
self->v393 = 0; /* mrb_int -> mrb_int */
v2872 = 23;
self->v397 = v2872; /* mrb_int -> mrb_int */
return v2872;
}
static mrb_int initialize__Context__43(mrb_state *mrb, struct cls1_47 * self, char *v2861, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int v2872;
struct gctab *gctab = prevgctab;
L158:; 
self->v391 = "[true, {\"foo\" : \"bar\"}]"; /* [:char, "*", nil] -> [:char, "*", nil] */
self->v393 = 0; /* mrb_int -> mrb_int */
v2872 = 23;
self->v397 = v2872; /* mrb_int -> mrb_int */
return v2872;
}
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 *v8542 = " ";
char *v8543 = "\t";
char *v8544 = "\r";
char *v8545 = "\n";
char *v8547;
mrb_int v8548;
char *v8550;
mrb_value v8552;
mrb_int v8533;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = prevgctab;
L494:; 
L496:; 
char * v8546[6] = {
" ", "\t", "\r", "\n"};
 v8547 = self->v391;
 v8548 = self->v393;
{ char *tmpstr = alloca(2);
tmpstr[0] = v8547[v8548];
tmpstr[1] = '\0';
v8550 = tmpstr;
};
v8552 = include_q__Array__5(mrb, v8546, v8550, gctab);
if ((mrb_test(v8552))) goto L495; else goto L497;
L495:; 
 v8533 = self->v393;
self->v393 = (v8533 + 1); /* mrb_int -> mrb_int */
goto L496;
L497:; 
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 *v14549;
mrb_int v14550;
char *v14552;
struct gctab *gctab = prevgctab;
L885:; 
 v14549 = self->v391;
 v14550 = self->v393;
{ char *tmpstr = prevgctab->caller_alloc; prevgctab->caller_alloc += ((0 + 1) * 4);
tmpstr[0] = v14549[v14550];
tmpstr[1] = '\0';
v14552 = tmpstr;
};
return v14552;
}
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 *v39403;
mrb_value v39404;
mrb_value v39618;
mrb_bool v39629;
mrb_value v39633;
mrb_value v39419;
char *v39422;
char *v39424 = "}";
mrb_bool v39426;
char *v39441;
char *v39455 = "\"";
mrb_bool v39457;
mrb_value v39477;
char *v39471 = "Expected \"\\\"\" but not found";
mrb_value v39473;
mrb_int v39488;
mrb_value v39491;
mrb_value v39495;
char *v39498;
char *v39500 = ":";
mrb_bool v39502;
mrb_value v39522;
mrb_value v39524;
char *v39516 = "Expected \":\" but not found";
mrb_value v39518;
mrb_value v39533;
mrb_value v39536;
mrb_value v39545;
char *v39548;
char *v39550 = "}";
mrb_bool v39552;
char *v39567;
char *v39581 = ",";
mrb_bool v39583;
mrb_value v39603;
char *v39597 = "Expected \",\" or \"}\" but not found";
mrb_value v39599;
char *v39614;
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;
L2290:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v39403 = next__Context__26(mrb, self, gctab);
v39404 = mrb_hash_new(mrb);
v39618 = v39404;
L2302:; 
gctab->single[0] = &v39618;
gctab->size = 1;
v39629 = has_unext_q__Context__26(mrb, self, gctab);
v39633 = v39618;
if (v39629) goto L2291; else goto L2303;
L2291:; 
v39419 = skip_uwhite__Context__26(mrb, self, gctab);
gctab->caller_alloc = alloca(sizeof(char) * 4);
v39422 = next__Context__26(mrb, self, gctab);
v39426 = (!strcmp(v39422, "}"));
if (v39426) goto L2292; else goto L2293;
L2292:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v39441 = next__Context__26(mrb, self, gctab);
v39633 = v39618;
L2303:; 
mrb_gc_arena_restore(mrb, ai);
return v39633;
L2293:; 
v39457 = (!strcmp(v39422, "\""));
v39457 = (!(v39457));
v39477 = v39618;
if (v39457) goto L2294; else goto L2295;
L2294:; 
v39473 = error__Context__34(mrb, self, "Expected \"\\\"\" but not found", gctab);
v39477 = v39618;
L2295:; 
gctab->single[0] = &v39477;
v39488 = back__Context__26(mrb, self, gctab);
v39491 = parse_ustring__Context__26(mrb, self, gctab);
gctab->single[1] = &v39491;
gctab->size = 2;
v39495 = skip_uwhite__Context__26(mrb, self, gctab);
gctab->caller_alloc = alloca(sizeof(char) * 4);
v39498 = next__Context__26(mrb, self, gctab);
v39502 = (!strcmp(v39498, ":"));
v39502 = (!(v39502));
v39522 = v39477;
v39524 = v39491;
if (v39502) goto L2296; else goto L2297;
L2296:; 
v39518 = error__Context__35(mrb, self, "Expected \":\" but not found", gctab);
v39522 = v39477;
v39524 = v39491;
L2297:; 
gctab->single[0] = &v39522;
gctab->single[1] = &v39524;
v39533 = skip_uwhite__Context__26(mrb, self, gctab);
v39536 = parse_uvalue__Context__26(mrb, self, gctab);
mrb_hash_set(mrb, v39522, v39524, v39536)
;gctab->single[2] = &v39536;
gctab->size = 3;
v39545 = skip_uwhite__Context__26(mrb, self, gctab);
gctab->caller_alloc = alloca(sizeof(char) * 4);
v39548 = current__Context__26(mrb, self, gctab);
v39552 = (!strcmp(v39548, "}"));
if (v39552) goto L2298; else goto L2299;
L2298:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
gctab->size = 1;
v39567 = next__Context__26(mrb, self, gctab);
v39633 = v39522;
goto L2303;
L2299:; 
v39583 = (!strcmp(v39548, ","));
v39583 = (!(v39583));
v39603 = v39522;
if (v39583) goto L2300; else goto L2301;
L2300:; 
v39599 = error__Context__36(mrb, self, "Expected \",\" or \"}\" but not found", gctab);
v39603 = v39522;
L2301:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
gctab->single[0] = &v39603;
v39614 = next__Context__26(mrb, self, gctab);
v39618 = v39603;
goto L2302;
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 *v36685;
mrb_value v36686;
mrb_value v36780;
mrb_bool v36788;
mrb_value v36792;
mrb_value v36698;
char *v36701;
char *v36702 = "]";
mrb_bool v36704;
mrb_value v36725;
mrb_value v36729;
char *v36732;
mrb_value v36737;
char *v36739 = "]";
mrb_bool v36741;
char *v36761 = ",";
mrb_bool v36763;
char *v36774 = "Expected \",\" or \"]\" but not found";
mrb_value v36776;
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;
L2134:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v36685 = next__Context__26(mrb, self, gctab);
{
mrb_value tmpele[] = {

};
mrb->ud = (void *)gctab;
v36686 = mrb_ary_new_from_values(mrb, 0, tmpele);
ARY_SET_LEN(mrb_ary_ptr(v36686), 0);
}
v36780 = v36686;
L2141:; 
gctab->single[0] = &v36780;
gctab->size = 1;
v36788 = has_unext_q__Context__26(mrb, self, gctab);
v36792 = v36780;
if (v36788) goto L2135; else goto L2142;
L2135:; 
v36698 = skip_uwhite__Context__26(mrb, self, gctab);
gctab->caller_alloc = alloca(sizeof(char) * 4);
v36701 = current__Context__26(mrb, self, gctab);
v36704 = (!strcmp(v36701, "]"));
if (v36704) goto L2136; else goto L2137;
L2136:; 
v36792 = v36780;
L2142:; 
mrb_gc_arena_restore(mrb, ai);
return v36792;
L2137:; 
v36725 = parse_uvalue__Context__26(mrb, self, gctab);
gctab->single[1] = &v36725;
gctab->size = 2;
v36729 = skip_uwhite__Context__26(mrb, self, gctab);
gctab->caller_alloc = alloca(sizeof(char) * 4);
v36732 = next__Context__26(mrb, self, gctab);
mrb_ary_push(mrb, v36780, v36725);
v36737 = v36780;
v36741 = (!strcmp(v36732, "]"));
if (v36741) goto L2138; else goto L2139;
L2138:; 
v36792 = v36780;
goto L2142;
L2139:; 
v36763 = (!strcmp(v36732, ","));
v36763 = (!(v36763));
v36780 = v36780;
if (v36763) goto L2140; else goto L2141;
L2140:; 
gctab->size = 1;
v36776 = error__Context__33(mrb, self, "Expected \",\" or \"]\" but not found", gctab);
v36780 = v36780;
goto L2141;
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 *v32972;
char *v32973 = "";
mrb_value v34054;
mrb_bool v34067;
char *v32990;
char *v32992 = "\\";
mrb_bool v32995;
char *v33026;
char *v33028 = "\\";
mrb_bool v33031;
mrb_value v33067;
char *v33068;
mrb_value v33960;
mrb_value v33081;
char *v33046 = "/";
mrb_bool v33049;
char *v33097 = "b";
mrb_bool v33100;
char *v33130 = "\b";
mrb_value v33132;
char *v33148 = "f";
mrb_bool v33151;
char *v33181 = "\f";
mrb_value v33183;
char *v33199 = "n";
mrb_bool v33202;
char *v33232 = "\n";
mrb_value v33234;
char *v33250 = "r";
mrb_bool v33253;
char *v33283 = "\r";
mrb_value v33285;
char *v33301 = "t";
mrb_bool v33304;
char *v33334 = "\t";
mrb_value v33336;
char *v33352 = "u";
mrb_bool v33355;
mrb_value v33455;
mrb_int v33457;
mrb_bool v33468;
mrb_value v33472;
mrb_int v33474;
char *v33401;
char *v33403 = "0123456789abcdef";
mrb_value v33406;
mrb_value v33408;
mrb_bool v33412;
mrb_int v33429;
mrb_value v33504;
mrb_value v33928;
mrb_value v33506;
mrb_value v33549;
mrb_value v33551;
mrb_value v33561;
mrb_value v33563;
mrb_value v33606;
mrb_value v33608;
mrb_value v33621;
mrb_value v33623;
mrb_value v33633;
mrb_value v33635;
mrb_value v33678;
mrb_value v33680;
mrb_value v33693;
mrb_value v33695;
mrb_value v33708;
mrb_value v33710;
mrb_value v33720;
mrb_value v33722;
mrb_value v33765;
mrb_value v33767;
mrb_value v33780;
mrb_value v33782;
mrb_value v33795;
mrb_value v33797;
mrb_value v33810;
mrb_value v33812;
mrb_value v33822;
mrb_value v33824;
mrb_value v33849;
mrb_value v33851;
mrb_value v33864;
mrb_value v33866;
mrb_value v33879;
mrb_value v33881;
mrb_value v33894;
mrb_value v33896;
mrb_value v33909;
mrb_value v33911;
mrb_value v33921;
mrb_value v33923;
char *v33954 = "Invalid string token";
mrb_value v33956;
char *v33985 = "\"";
mrb_bool v33988;
mrb_value v34049;
char *v34083 = "Invalid string token";
mrb_value v34085;
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;
L1937:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v32972 = next__Context__26(mrb, self, gctab);
v34054 = (mrb_str_new_cstr(mrb, ""));
L1985:; 
gctab->single[0] = &v34054;
gctab->size = 1;
v34067 = has_unext_q__Context__26(mrb, self, gctab);
if (v34067) goto L1938; else goto L1986;
L1938:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v32990 = next__Context__26(mrb, self, gctab);
v32995 = (!strcmp("\\", v32990));
if (v32995) goto L1940; else goto L1939;
L1940:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v33026 = next__Context__26(mrb, self, gctab);
v33031 = (!strcmp("\\", v33026));
v33067 = v34054;
v33068 = v33026;
if (v33031) goto L1943; else goto L1941;
L1943:; 
v33081 = mrb_str_cat_cstr(mrb, v33067, v33068);
v33960 = v33081;
L1979:; 
v34054 = v33960;
goto L1985;
L1941:; 
v33049 = (!strcmp("/", v33026));
v33067 = v34054;
v33068 = v33026;
if (v33049) goto L1943; else goto L1942;
L1942:; 
L1944:; 
v33100 = (!strcmp("b", v33026));
if (v33100) goto L1946; else goto L1945;
L1946:; 
v33132 = mrb_str_cat_cstr(mrb, v34054, "\b");
v33960 = v33132;
goto L1979;
L1945:; 
L1947:; 
v33151 = (!strcmp("f", v33026));
if (v33151) goto L1949; else goto L1948;
L1949:; 
v33183 = mrb_str_cat_cstr(mrb, v34054, "\f");
v33960 = v33183;
goto L1979;
L1948:; 
L1950:; 
v33202 = (!strcmp("n", v33026));
if (v33202) goto L1952; else goto L1951;
L1952:; 
v33234 = mrb_str_cat_cstr(mrb, v34054, "\n");
v33960 = v33234;
goto L1979;
L1951:; 
L1953:; 
v33253 = (!strcmp("r", v33026));
if (v33253) goto L1955; else goto L1954;
L1955:; 
v33285 = mrb_str_cat_cstr(mrb, v34054, "\r");
v33960 = v33285;
goto L1979;
L1954:; 
L1956:; 
v33304 = (!strcmp("t", v33026));
if (v33304) goto L1958; else goto L1957;
L1958:; 
v33336 = mrb_str_cat_cstr(mrb, v34054, "\t");
v33960 = v33336;
goto L1979;
L1957:; 
L1959:; 
v33355 = (!strcmp("u", v33026));
if (v33355) goto L1961; else goto L1960;
L1961:; 
v33455 = v34054;
v33457 = 0;
L1965:; 
gctab->single[0] = &v33455;
v33468 = has_unext_q__Context__26(mrb, self, gctab);
v33472 = v33455;
v33474 = v33457;
if (v33468) goto L1962; else goto L1966;
L1962:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v33401 = next__Context__26(mrb, self, gctab);
v33406 = (mrb_str_new_cstr(mrb, v33401));
v33408 = mrb_fixnum_value(mrb_str_index(mrb, (mrb_str_new_cstr(mrb, "0123456789abcdef")), RSTRING_PTR(v33406),strlen(RSTRING_PTR(v33406)), 0));
if (!mrb_nil_p(v33408)) {
}
else {
v33412 = mrb_nil_p(mrb_nil_value());
}
if (v33412) goto L1963; else goto L1964;
L1963:; 
v33429 = back__Context__26(mrb, self, gctab);
v33472 = v33455;
v33474 = v33457;
L1966:; 
if ((v33474 < 128)) goto L1967; else goto L1968;
L1967:; 
{ char *tmpstr = alloca(2);
tmpstr[0] = v33474;
tmpstr[1] = '\0';
gctab->single[0] = &v33472;
gctab->single[1] = &v33472;
gctab->size = 2;
mrb->ud = (void *)gctab;
v33504 = mrb_str_new_cstr(mrb, tmpstr);
}
v33506 = mrb_str_cat_str(mrb, v33472, v33504);
v33928 = v33506;
L1977:; 
v33960 = v33928;
goto L1979;
L1968:; 
if ((v33474 < 2048)) goto L1969; else goto L1970;
L1969:; 
{ char *tmpstr = alloca(2);
tmpstr[0] = (192 | (v33474 >> 6));
tmpstr[1] = '\0';
mrb->ud = (void *)gctab;
v33549 = mrb_str_new_cstr(mrb, tmpstr);
}
v33551 = mrb_str_cat_str(mrb, v33472, v33549);
v33551 = v33551;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 + (v33474 & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v33551;
gctab->size = 1;
mrb->ud = (void *)gctab;
v33561 = mrb_str_new_cstr(mrb, tmpstr);
}
v33563 = mrb_str_cat_str(mrb, v33551, v33561);
v33928 = v33563;
goto L1977;
L1970:; 
if ((v33474 < 65536)) goto L1971; else goto L1972;
L1971:; 
{ char *tmpstr = alloca(2);
tmpstr[0] = (224 | (v33474 >> 12));
tmpstr[1] = '\0';
gctab->single[0] = &v33472;
gctab->size = 2;
mrb->ud = (void *)gctab;
v33606 = mrb_str_new_cstr(mrb, tmpstr);
}
v33608 = mrb_str_cat_str(mrb, v33472, v33606);
v33608 = v33608;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v33474 >> 6) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v33608;
gctab->size = 1;
mrb->ud = (void *)gctab;
v33621 = mrb_str_new_cstr(mrb, tmpstr);
}
v33623 = mrb_str_cat_str(mrb, v33608, v33621);
v33623 = v33623;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | (v33474 & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v33623;
mrb->ud = (void *)gctab;
v33633 = mrb_str_new_cstr(mrb, tmpstr);
}
v33635 = mrb_str_cat_str(mrb, v33623, v33633);
v33928 = v33635;
goto L1977;
L1972:; 
if ((v33474 < 2097152)) goto L1973; else goto L1974;
L1973:; 
{ char *tmpstr = alloca(2);
tmpstr[0] = (240 | (v33474 >> 18));
tmpstr[1] = '\0';
gctab->single[0] = &v33472;
gctab->size = 2;
mrb->ud = (void *)gctab;
v33678 = mrb_str_new_cstr(mrb, tmpstr);
}
v33680 = mrb_str_cat_str(mrb, v33472, v33678);
v33680 = v33680;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v33474 >> 12) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v33680;
gctab->size = 1;
mrb->ud = (void *)gctab;
v33693 = mrb_str_new_cstr(mrb, tmpstr);
}
v33695 = mrb_str_cat_str(mrb, v33680, v33693);
v33695 = v33695;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v33474 >> 6) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v33695;
mrb->ud = (void *)gctab;
v33708 = mrb_str_new_cstr(mrb, tmpstr);
}
v33710 = mrb_str_cat_str(mrb, v33695, v33708);
v33710 = v33710;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | (v33474 & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v33710;
mrb->ud = (void *)gctab;
v33720 = mrb_str_new_cstr(mrb, tmpstr);
}
v33722 = mrb_str_cat_str(mrb, v33710, v33720);
v33928 = v33722;
goto L1977;
L1974:; 
if ((v33474 < 67108864)) goto L1975; else goto L1976;
L1975:; 
{ char *tmpstr = alloca(2);
tmpstr[0] = (248 | (v33474 >> 24));
tmpstr[1] = '\0';
gctab->single[0] = &v33472;
gctab->size = 2;
mrb->ud = (void *)gctab;
v33765 = mrb_str_new_cstr(mrb, tmpstr);
}
v33767 = mrb_str_cat_str(mrb, v33472, v33765);
v33767 = v33767;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v33474 >> 18) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v33767;
gctab->size = 1;
mrb->ud = (void *)gctab;
v33780 = mrb_str_new_cstr(mrb, tmpstr);
}
v33782 = mrb_str_cat_str(mrb, v33767, v33780);
v33782 = v33782;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v33474 >> 12) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v33782;
mrb->ud = (void *)gctab;
v33795 = mrb_str_new_cstr(mrb, tmpstr);
}
v33797 = mrb_str_cat_str(mrb, v33782, v33795);
v33797 = v33797;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v33474 >> 6) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v33797;
mrb->ud = (void *)gctab;
v33810 = mrb_str_new_cstr(mrb, tmpstr);
}
v33812 = mrb_str_cat_str(mrb, v33797, v33810);
v33812 = v33812;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | (v33474 & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v33812;
mrb->ud = (void *)gctab;
v33822 = mrb_str_new_cstr(mrb, tmpstr);
}
v33824 = mrb_str_cat_str(mrb, v33812, v33822);
v33928 = v33824;
goto L1977;
L1976:; 
{ char *tmpstr = alloca(2);
tmpstr[0] = (252 | (v33474 >> 30));
tmpstr[1] = '\0';
gctab->single[0] = &v33472;
gctab->size = 2;
mrb->ud = (void *)gctab;
v33849 = mrb_str_new_cstr(mrb, tmpstr);
}
v33851 = mrb_str_cat_str(mrb, v33472, v33849);
v33851 = v33851;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v33474 >> 24) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v33851;
gctab->size = 1;
mrb->ud = (void *)gctab;
v33864 = mrb_str_new_cstr(mrb, tmpstr);
}
v33866 = mrb_str_cat_str(mrb, v33851, v33864);
v33866 = v33866;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v33474 >> 18) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v33866;
mrb->ud = (void *)gctab;
v33879 = mrb_str_new_cstr(mrb, tmpstr);
}
v33881 = mrb_str_cat_str(mrb, v33866, v33879);
v33881 = v33881;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v33474 >> 12) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v33881;
mrb->ud = (void *)gctab;
v33894 = mrb_str_new_cstr(mrb, tmpstr);
}
v33896 = mrb_str_cat_str(mrb, v33881, v33894);
v33896 = v33896;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | ((v33474 >> 6) & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v33896;
mrb->ud = (void *)gctab;
v33909 = mrb_str_new_cstr(mrb, tmpstr);
}
v33911 = mrb_str_cat_str(mrb, v33896, v33909);
v33911 = v33911;
{ char *tmpstr = alloca(2);
tmpstr[0] = (128 | (v33474 & 63));
tmpstr[1] = '\0';
gctab->single[0] = &v33911;
mrb->ud = (void *)gctab;
v33921 = mrb_str_new_cstr(mrb, tmpstr);
}
v33923 = mrb_str_cat_str(mrb, v33911, v33921);
v33928 = v33923;
goto L1977;
L1964:; 
v33455 = v33455;
goto L1965;
L1960:; 
L1978:; 
gctab->single[0] = &v34054;
v33956 = error__Context__32(mrb, self, "Invalid string token", gctab);
v33960 = v34054;
goto L1979;
L1939:; 
L1980:; 
v33988 = (!strcmp("\"", v32990));
if (v33988) goto L1982; else goto L1981;
L1982:; 
return v34054;
L1981:; 
L1984:; 
v34049 = mrb_str_cat_cstr(mrb, v34054, v32990);
v34054 = v34049;
goto L1985;
L1986:; 
gctab->size = 0;
v34085 = error__Context__32(mrb, self, "Invalid string token", gctab);
return v34085;
}
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 *v30270;
char *v30323;
mrb_bool v30330;
char *v30334;
char *v30282;
char *v30284 = "0123456789+-.eE";
mrb_bool v30287;
mrb_value v30318;
mrb_int v30306;
char *v30340 = ".";
mrb_bool v30342;
mrb_float2 v30353;
mrb_int v30364;
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;
L1781:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v30270 = next__Context__26(mrb, self, gctab);
v30323 = v30270;
L1786:; 
v30330 = has_unext_q__Context__26(mrb, self, gctab);
v30334 = v30323;
if (v30330) goto L1782; else goto L1787;
L1782:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v30282 = next__Context__26(mrb, self, gctab);
v30287 = (mrb_str_index(mrb, (mrb_str_new_cstr(mrb, "0123456789+-.eE")), v30282, strlen(v30282), 0) >= 0);
if (v30287) goto L1783; else goto L1784;
L1783:; 
L1785:; 
v30318 = mrb_str_cat_cstr(mrb, (mrb_str_new_cstr(mrb, v30323)), v30282);
v30323 = RSTRING_PTR(v30318);
goto L1786;
L1784:; 
v30306 = back__Context__26(mrb, self, gctab);
v30334 = v30323;
L1787:; 
v30342 = (mrb_str_index(mrb, (mrb_str_new_cstr(mrb, v30334)), ".", strlen("."), 0) >= 0);
if (v30342) goto L1788; else goto L1789;
L1788:; 
v30353 = ({mrb_float2 res; sscanf(v30334, "%g", &res); res;});
return (mrb_float_value2(v30353));
L1789:; 
v30364 = ({mrb_int res; sscanf(v30334, "%d", &res); res;});
return (mrb_fixnum_value(v30364));
}
static mrb_bool parse_uconstant__Context__31(mrb_state *mrb, struct cls1_47 * self, char *v19751, mrb_bool v19752, struct gctab *prevgctab) {
struct env29 env;
struct REnv *venv = NULL;
char *v19769 = "";
mrb_int v19770;
char *v19864;
mrb_bool v19865;
mrb_value v19867;
mrb_int v19868;
mrb_bool v19875;
char *v19784;
mrb_bool v19789;
char *v19848;
mrb_bool v19849;
mrb_value v19851;
mrb_int v19852;
char *v19853;
mrb_value v19860;
mrb_bool v19815;
mrb_int v19829;
char *v19843 = "Unknown token";
mrb_value v19845;
char *v19888 = "Unknown token";
mrb_value v19890;
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;
L1181:; 
 v19770 = self->v393;
v19864 = "true";
v19865 = 1;
v19867 = (mrb_str_new_cstr(mrb, ""));
v19868 = v19770;
L1188:; 
gctab->single[0] = &v19867;
gctab->size = 1;
v19875 = has_unext_q__Context__26(mrb, self, gctab);
if (v19875) goto L1182; else goto L1189;
L1182:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v19784 = next__Context__26(mrb, self, gctab);
v19789 = (mrb_str_index(mrb, (mrb_str_new_cstr(mrb, v19864)), v19784, strlen(v19784), 0) >= 0);
if (v19789) goto L1183; else goto L1184;
L1183:; 
v19848 = v19864;
v19849 = v19865;
v19851 = v19867;
v19852 = v19868;
v19853 = v19784;
L1187:; 
v19864 = v19848;
v19865 = v19849;
v19860 = mrb_str_cat_cstr(mrb, v19851, v19853);
v19867 = v19860;
v19868 = v19852;
goto L1188;
L1184:; 
v19815 = (!strcmp(RSTRING_PTR(v19867), v19864));
if (v19815) goto L1185; else goto L1186;
L1185:; 
gctab->size = 0;
v19829 = back__Context__26(mrb, self, gctab);
return v19865;
L1186:; 
self->v393 = v19868; /* mrb_int -> mrb_int */
gctab->size = 1;
v19845 = error__Context__29(mrb, self, "Unknown token", gctab);
v19848 = v19864;
v19849 = v19865;
v19851 = v19867;
v19852 = v19868;
v19853 = v19784;
goto L1187;
L1189:; 
gctab->size = 0;
v19890 = error__Context__29(mrb, self, "Unknown token", gctab);
return (mrb_test(v19890));
}
static mrb_bool parse_uconstant__Context__30(mrb_state *mrb, struct cls1_47 * self, char *v19751, mrb_bool v19752, struct gctab *prevgctab) {
struct env29 env;
struct REnv *venv = NULL;
char *v19769 = "";
mrb_int v19770;
char *v19864;
mrb_bool v19865;
mrb_value v19867;
mrb_int v19868;
mrb_bool v19875;
char *v19784;
mrb_bool v19789;
char *v19848;
mrb_bool v19849;
mrb_value v19851;
mrb_int v19852;
char *v19853;
mrb_value v19860;
mrb_bool v19815;
mrb_int v19829;
char *v19843 = "Unknown token";
mrb_value v19845;
char *v19888 = "Unknown token";
mrb_value v19890;
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;
L1181:; 
 v19770 = self->v393;
v19864 = "false";
v19865 = 0;
v19867 = (mrb_str_new_cstr(mrb, ""));
v19868 = v19770;
L1188:; 
gctab->single[0] = &v19867;
gctab->size = 1;
v19875 = has_unext_q__Context__26(mrb, self, gctab);
if (v19875) goto L1182; else goto L1189;
L1182:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v19784 = next__Context__26(mrb, self, gctab);
v19789 = (mrb_str_index(mrb, (mrb_str_new_cstr(mrb, v19864)), v19784, strlen(v19784), 0) >= 0);
if (v19789) goto L1183; else goto L1184;
L1183:; 
v19848 = v19864;
v19849 = v19865;
v19851 = v19867;
v19852 = v19868;
v19853 = v19784;
L1187:; 
v19864 = v19848;
v19865 = v19849;
v19860 = mrb_str_cat_cstr(mrb, v19851, v19853);
v19867 = v19860;
v19868 = v19852;
goto L1188;
L1184:; 
v19815 = (!strcmp(RSTRING_PTR(v19867), v19864));
if (v19815) goto L1185; else goto L1186;
L1185:; 
gctab->size = 0;
v19829 = back__Context__26(mrb, self, gctab);
return v19865;
L1186:; 
self->v393 = v19868; /* mrb_int -> mrb_int */
gctab->size = 1;
v19845 = error__Context__29(mrb, self, "Unknown token", gctab);
v19848 = v19864;
v19849 = v19865;
v19851 = v19867;
v19852 = v19868;
v19853 = v19784;
goto L1187;
L1189:; 
gctab->size = 0;
v19890 = error__Context__29(mrb, self, "Unknown token", gctab);
return (mrb_test(v19890));
}
static mrb_value parse_uconstant__Context__28(mrb_state *mrb, struct cls1_47 * self, char *v19751, mrb_value v19752, struct gctab *prevgctab) {
struct env29 env;
struct REnv *venv = NULL;
char *v19769 = "";
mrb_int v19770;
char *v19864;
mrb_value v19865;
mrb_value v19867;
mrb_int v19868;
mrb_bool v19875;
char *v19784;
mrb_bool v19789;
char *v19848;
mrb_value v19849;
mrb_value v19851;
mrb_int v19852;
char *v19853;
mrb_value v19860;
mrb_bool v19815;
mrb_int v19829;
char *v19843 = "Unknown token";
mrb_value v19845;
char *v19888 = "Unknown token";
mrb_value v19890;
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;
L1181:; 
 v19770 = self->v393;
v19864 = "null";
v19865 = mrb_nil_value();
v19867 = (mrb_str_new_cstr(mrb, ""));
v19868 = v19770;
L1188:; 
gctab->single[0] = &v19867;
gctab->size = 1;
v19875 = has_unext_q__Context__26(mrb, self, gctab);
if (v19875) goto L1182; else goto L1189;
L1182:; 
gctab->caller_alloc = alloca(sizeof(char) * 4);
v19784 = next__Context__26(mrb, self, gctab);
v19789 = (mrb_str_index(mrb, (mrb_str_new_cstr(mrb, v19864)), v19784, strlen(v19784), 0) >= 0);
if (v19789) goto L1183; else goto L1184;
L1183:; 
v19848 = v19864;
v19849 = v19865;
v19851 = v19867;
v19852 = v19868;
v19853 = v19784;
L1187:; 
v19864 = v19848;
v19865 = v19849;
v19860 = mrb_str_cat_cstr(mrb, v19851, v19853);
v19867 = v19860;
v19868 = v19852;
goto L1188;
L1184:; 
v19815 = (!strcmp(RSTRING_PTR(v19867), v19864));
if (v19815) goto L1185; else goto L1186;
L1185:; 
gctab->size = 0;
v19829 = back__Context__26(mrb, self, gctab);
return v19865;
L1186:; 
self->v393 = v19868; /* mrb_int -> mrb_int */
gctab->size = 1;
v19845 = error__Context__29(mrb, self, "Unknown token", gctab);
v19848 = v19864;
v19849 = v19865;
v19851 = v19867;
v19852 = v19868;
v19853 = v19784;
goto L1187;
L1189:; 
gctab->size = 0;
v19890 = error__Context__29(mrb, self, "Unknown token", gctab);
return v19890;
}
static mrb_value error__Context__27(mrb_state *mrb, struct cls1_47 * self, char *v17134, struct gctab *prevgctab) {
struct env26 env;
struct REnv *venv = NULL;
char *v17149 = "";
mrb_value v17151;
char *v17152 = ": ";
mrb_value v17153;
char *v17154;
mrb_int v17155;
struct range_mrb_int *v17157;
char *v17159;
mrb_value v17160;
mrb_value v17162;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = prevgctab;
L1033:; 
v17151 = mrb_str_cat_cstr(mrb, (mrb_str_new_cstr(mrb, "")), "Invalid sequence");
v17153 = mrb_str_cat_cstr(mrb, v17151, ": ");
 v17154 = self->v391;
 v17155 = self->v393;
v17157 = alloca(sizeof(struct range_mrb_int));
v17157->first = v17155;
v17157->last = -1;
v17157->exclude_end = 1;
{ 
int last = ((v17157->last < 0) ? strlen(v17154) + v17157->last : v17157->last);
char *tmpstr = alloca(last - v17157->first + 1);
memcpy(tmpstr, v17154 + v17157->first, last - v17157->first);
tmpstr[last] = '\0';
v17159 = tmpstr;
};
v17160 = mrb_str_cat_cstr(mrb, v17153, v17159);
mrb_exc_raise(mrb, mrb_make_exception(mrb, 1, &v17160));
mrb_gc_arena_restore(mrb, ai);
return v17162;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value include_q__Array__5(mrb_state *mrb, char * *self, char *v10281, struct gctab *prevgctab) {
struct env16 env;
struct REnv *venv = NULL;
struct proc17 v10290;
mrb_value v10341;
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L622:; 
env.v10285 = v10281;/*enter */
v10290.id = 17;
v10290.self = self;
v10290.env = &env;
v10341 = each__Array__6(mrb, self, ((gproc)&v10290), gctab);
if (gctab->ret_status) return v10341;
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 *v25077;
mrb_int v25078;
char *v25080;
mrb_int v25082;
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L1485:; 
 v25077 = self->v391;
 v25078 = self->v393;
{ char *tmpstr = prevgctab->caller_alloc; prevgctab->caller_alloc += ((0 + 1) * 4);
tmpstr[0] = v25077[v25078];
tmpstr[1] = '\0';
v25080 = tmpstr;
};
 v25082 = self->v393;
self->v393 = (v25082 + 1); /* mrb_int -> mrb_int */
return v25080;
}
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 v22480;
mrb_int v22481;
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L1337:; 
 v22480 = self->v393;
 v22481 = self->v397;
return (v22480 < v22481);
}
static mrb_value error__Context__34(mrb_state *mrb, struct cls1_47 * self, char *v17134, struct gctab *prevgctab) {
struct env26 env;
struct REnv *venv = NULL;
char *v17149 = "";
mrb_value v17151;
char *v17152 = ": ";
mrb_value v17153;
char *v17154;
mrb_int v17155;
struct range_mrb_int *v17157;
char *v17159;
mrb_value v17160;
mrb_value v17162;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L1033:; 
v17151 = mrb_str_cat_str(mrb, (mrb_str_new_cstr(mrb, "")), (mrb_str_new_cstr(mrb, "Expected \"\\\"\" but not found")));
v17153 = mrb_str_cat_cstr(mrb, v17151, ": ");
 v17154 = self->v391;
 v17155 = self->v393;
v17157 = alloca(sizeof(struct range_mrb_int));
v17157->first = v17155;
v17157->last = -1;
v17157->exclude_end = 1;
{ 
int last = ((v17157->last < 0) ? strlen(v17154) + v17157->last : v17157->last);
char *tmpstr = alloca(last - v17157->first + 1);
memcpy(tmpstr, v17154 + v17157->first, last - v17157->first);
tmpstr[last] = '\0';
v17159 = tmpstr;
};
v17160 = mrb_str_cat_cstr(mrb, v17153, v17159);
mrb_exc_raise(mrb, mrb_make_exception(mrb, 1, &v17160));
mrb_gc_arena_restore(mrb, ai);
return v17162;
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 v27673;
mrb_int v27674;/*snd*/
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L1633:; 
 v27673 = self->v393;
v27674 = (v27673 - 1);
self->v393 = v27674; /* mrb_int -> mrb_int */
return v27674;
}
static mrb_value error__Context__35(mrb_state *mrb, struct cls1_47 * self, char *v17134, struct gctab *prevgctab) {
struct env26 env;
struct REnv *venv = NULL;
char *v17149 = "";
mrb_value v17151;
char *v17152 = ": ";
mrb_value v17153;
char *v17154;
mrb_int v17155;
struct range_mrb_int *v17157;
char *v17159;
mrb_value v17160;
mrb_value v17162;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L1033:; 
v17151 = mrb_str_cat_str(mrb, (mrb_str_new_cstr(mrb, "")), (mrb_str_new_cstr(mrb, "Expected \":\" but not found")));
v17153 = mrb_str_cat_cstr(mrb, v17151, ": ");
 v17154 = self->v391;
 v17155 = self->v393;
v17157 = alloca(sizeof(struct range_mrb_int));
v17157->first = v17155;
v17157->last = -1;
v17157->exclude_end = 1;
{ 
int last = ((v17157->last < 0) ? strlen(v17154) + v17157->last : v17157->last);
char *tmpstr = alloca(last - v17157->first + 1);
memcpy(tmpstr, v17154 + v17157->first, last - v17157->first);
tmpstr[last] = '\0';
v17159 = tmpstr;
};
v17160 = mrb_str_cat_cstr(mrb, v17153, v17159);
mrb_exc_raise(mrb, mrb_make_exception(mrb, 1, &v17160));
mrb_gc_arena_restore(mrb, ai);
return v17162;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value error__Context__36(mrb_state *mrb, struct cls1_47 * self, char *v17134, struct gctab *prevgctab) {
struct env26 env;
struct REnv *venv = NULL;
char *v17149 = "";
mrb_value v17151;
char *v17152 = ": ";
mrb_value v17153;
char *v17154;
mrb_int v17155;
struct range_mrb_int *v17157;
char *v17159;
mrb_value v17160;
mrb_value v17162;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L1033:; 
v17151 = mrb_str_cat_str(mrb, (mrb_str_new_cstr(mrb, "")), (mrb_str_new_cstr(mrb, "Expected \",\" or \"}\" but not found")));
v17153 = mrb_str_cat_cstr(mrb, v17151, ": ");
 v17154 = self->v391;
 v17155 = self->v393;
v17157 = alloca(sizeof(struct range_mrb_int));
v17157->first = v17155;
v17157->last = -1;
v17157->exclude_end = 1;
{ 
int last = ((v17157->last < 0) ? strlen(v17154) + v17157->last : v17157->last);
char *tmpstr = alloca(last - v17157->first + 1);
memcpy(tmpstr, v17154 + v17157->first, last - v17157->first);
tmpstr[last] = '\0';
v17159 = tmpstr;
};
v17160 = mrb_str_cat_cstr(mrb, v17153, v17159);
mrb_exc_raise(mrb, mrb_make_exception(mrb, 1, &v17160));
mrb_gc_arena_restore(mrb, ai);
return v17162;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value error__Context__33(mrb_state *mrb, struct cls1_47 * self, char *v17134, struct gctab *prevgctab) {
struct env26 env;
struct REnv *venv = NULL;
char *v17149 = "";
mrb_value v17151;
char *v17152 = ": ";
mrb_value v17153;
char *v17154;
mrb_int v17155;
struct range_mrb_int *v17157;
char *v17159;
mrb_value v17160;
mrb_value v17162;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L1033:; 
v17151 = mrb_str_cat_str(mrb, (mrb_str_new_cstr(mrb, "")), (mrb_str_new_cstr(mrb, "Expected \",\" or \"]\" but not found")));
v17153 = mrb_str_cat_cstr(mrb, v17151, ": ");
 v17154 = self->v391;
 v17155 = self->v393;
v17157 = alloca(sizeof(struct range_mrb_int));
v17157->first = v17155;
v17157->last = -1;
v17157->exclude_end = 1;
{ 
int last = ((v17157->last < 0) ? strlen(v17154) + v17157->last : v17157->last);
char *tmpstr = alloca(last - v17157->first + 1);
memcpy(tmpstr, v17154 + v17157->first, last - v17157->first);
tmpstr[last] = '\0';
v17159 = tmpstr;
};
v17160 = mrb_str_cat_cstr(mrb, v17153, v17159);
mrb_exc_raise(mrb, mrb_make_exception(mrb, 1, &v17160));
mrb_gc_arena_restore(mrb, ai);
return v17162;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value error__Context__32(mrb_state *mrb, struct cls1_47 * self, char *v17134, struct gctab *prevgctab) {
struct env26 env;
struct REnv *venv = NULL;
char *v17149 = "";
mrb_value v17151;
char *v17152 = ": ";
mrb_value v17153;
char *v17154;
mrb_int v17155;
struct range_mrb_int *v17157;
char *v17159;
mrb_value v17160;
mrb_value v17162;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L1033:; 
v17151 = mrb_str_cat_str(mrb, (mrb_str_new_cstr(mrb, "")), (mrb_str_new_cstr(mrb, "Invalid string token")));
v17153 = mrb_str_cat_cstr(mrb, v17151, ": ");
 v17154 = self->v391;
 v17155 = self->v393;
v17157 = alloca(sizeof(struct range_mrb_int));
v17157->first = v17155;
v17157->last = -1;
v17157->exclude_end = 1;
{ 
int last = ((v17157->last < 0) ? strlen(v17154) + v17157->last : v17157->last);
char *tmpstr = alloca(last - v17157->first + 1);
memcpy(tmpstr, v17154 + v17157->first, last - v17157->first);
tmpstr[last] = '\0';
v17159 = tmpstr;
};
v17160 = mrb_str_cat_cstr(mrb, v17153, v17159);
mrb_exc_raise(mrb, mrb_make_exception(mrb, 1, &v17160));
mrb_gc_arena_restore(mrb, ai);
return v17162;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value error__Context__29(mrb_state *mrb, struct cls1_47 * self, char *v17134, struct gctab *prevgctab) {
struct env26 env;
struct REnv *venv = NULL;
char *v17149 = "";
mrb_value v17151;
char *v17152 = ": ";
mrb_value v17153;
char *v17154;
mrb_int v17155;
struct range_mrb_int *v17157;
char *v17159;
mrb_value v17160;
mrb_value v17162;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L1033:; 
v17151 = mrb_str_cat_str(mrb, (mrb_str_new_cstr(mrb, "")), (mrb_str_new_cstr(mrb, "Unknown token")));
v17153 = mrb_str_cat_cstr(mrb, v17151, ": ");
 v17154 = self->v391;
 v17155 = self->v393;
v17157 = alloca(sizeof(struct range_mrb_int));
v17157->first = v17155;
v17157->last = -1;
v17157->exclude_end = 1;
{ 
int last = ((v17157->last < 0) ? strlen(v17154) + v17157->last : v17157->last);
char *tmpstr = alloca(last - v17157->first + 1);
memcpy(tmpstr, v17154 + v17157->first, last - v17157->first);
tmpstr[last] = '\0';
v17159 = tmpstr;
};
v17160 = mrb_str_cat_cstr(mrb, v17153, v17159);
mrb_exc_raise(mrb, mrb_make_exception(mrb, 1, &v17160));
mrb_gc_arena_restore(mrb, ai);
return v17162;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value each__Array__6(mrb_state *mrb, char * *self, gproc v11869, struct gctab *prevgctab) {
struct env20 env;
struct REnv *venv = NULL;
gproc v11930;
mrb_int v11931;
mrb_int v11939;
char *v11922;
mrb_value v11924;
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
L731:; 
L732:; 
L734:; 
v11930 = v11869;
v11931 = 0;
L736:; 
v11939 = 4;
if ((v11931 < v11939)) goto L735; else goto L737;
L735:; 
v11922 = self[v11931];
v11924 = (p17_Array_0_8(mrb, v11930, v11922, gctab));
if (gctab->ret_status) {
prevgctab->ret_status = 2;
return v11924;
}
v11930 = v11930;
v11931 = (v11931 + 1);
goto L736;
L737:; 
return mmc_boxing_array(self, 5, mrb_str_new_cstr);
}
static mrb_value p17_Array_0_8(mrb_state *mrb, gproc cgproc, char *v10294, struct gctab *prevgctab) {
struct proc17 *proc = (struct proc17 *)cgproc;
char * *self = proc->self;
struct env17 env;
struct REnv *venv = NULL;
char * *v10299;
char *v10306;
char *v10307;
mrb_bool v10309;
mrb_value v10337;
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
gctab->ret_status = 0;
env.prev = proc->env;
L623:; 
v10299 = &v10294;
v10306 = v10299[0];
v10307 = proc->env->v10285;
v10309 = (!strcmp(v10306, v10307));
if (v10309) goto L624; else goto L626;
L624:; 
prevgctab->ret_status = 2;
return ((1) ? mrb_true_value() : mrb_false_value());
L626:; 
v10337 = mrb_nil_value();
L627:; 
return v10337;
}
/*
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 Float
 Instance variables

 methodes 

Class Fixnum
 Instance variables

 methodes 

Class TrueClass
 Instance variables

 methodes 

Class FalseClass
 Instance variables

 methodes 

*/