mono_class_get_methods_by_name (struct MonoClass * klass, const char * name, guint32 bflags, gboolean ignore_case, gboolean allow_ctors, struct MonoException * * ex)
{
  int (*<T43a0>) (const char *, const char *) iftmp.0;
  unsigned char D.27790;
  unsigned char D.27791;
  int D.24422;
  int iftmp.1;
  int D.24421;
  const char[7] * D.27799;
  unsigned char D.27800;
  int D.27801;
  unsigned char D.27802;
  int D.27803;
  _Bool D.27804;
  _Bool D.27805;
  _Bool D.27806;
  const unsigned char * D.27809;
  unsigned char D.27810;
  int D.27811;
  const unsigned char * D.27812;
  unsigned char D.27813;
  int D.27814;
  _Bool D.27815;
  _Bool D.27816;
  const unsigned char * D.27819;
  unsigned char D.27820;
  int D.27821;
  const unsigned char * D.27822;
  unsigned char D.27823;
  int D.27824;
  _Bool D.27825;
  _Bool D.27826;
  const unsigned char * D.27829;
  unsigned char D.27830;
  int D.27831;
  const unsigned char * D.27832;
  unsigned char D.27833;
  int D.27834;
  struct MonoLoaderError * D.27840;
  struct GPtrArray * D.27842;
  unsigned char D.27843;
  struct MonoLoaderError * D.27845;
  struct MonoType * D.27847;
  unsigned char D.27848;
  struct MonoClass * D.27851;
  int iftmp.2;
  unsigned int D.27857;
  unsigned int D.27858;
  unsigned char D.27860;
  unsigned int nslots.3;
  int D.27865;
  int D.27866;
  unsigned int D.27867;
  unsigned int D.27868;
  struct MonoLoaderError * D.27871;
  short int D.27873;
  int D.27876;
  _Bool D.27877;
  long int D.27878;
  long int D.27879;
  short int D.27882;
  unsigned int D.27883;
  unsigned int D.27884;
  guint32 * D.27885;
  unsigned int D.27886;
  unsigned short D.27887;
  int D.27888;
  int D.27889;
  int D.27890;
  unsigned int D.27891;
  unsigned int D.27892;
  short unsigned int D.27895;
  int D.27896;
  int D.27897;
  unsigned int D.27900;
  const char * D.27905;
  char D.27906;
  int D.24434;
  int iftmp.4;
  int D.24433;
  const char[6] * D.27912;
  unsigned char D.27913;
  int D.27914;
  unsigned char D.27915;
  int D.27916;
  _Bool D.27917;
  _Bool D.27918;
  _Bool D.27919;
  const unsigned char * D.27922;
  unsigned char D.27923;
  int D.27924;
  const unsigned char * D.27925;
  unsigned char D.27926;
  int D.27927;
  _Bool D.27928;
  _Bool D.27929;
  const unsigned char * D.27932;
  unsigned char D.27933;
  int D.27934;
  const unsigned char * D.27935;
  unsigned char D.27936;
  int D.27937;
  _Bool D.27938;
  _Bool D.27939;
  const unsigned char * D.27942;
  unsigned char D.27943;
  int D.27944;
  const unsigned char * D.27945;
  unsigned char D.27946;
  int D.27947;
  int D.24443;
  int iftmp.5;
  int D.24442;
  const char[7] * D.27953;
  unsigned char D.27954;
  int D.27955;
  unsigned char D.27956;
  int D.27957;
  _Bool D.27958;
  _Bool D.27959;
  _Bool D.27960;
  const unsigned char * D.27963;
  unsigned char D.27964;
  int D.27965;
  const unsigned char * D.27966;
  unsigned char D.27967;
  int D.27968;
  _Bool D.27969;
  _Bool D.27970;
  const unsigned char * D.27973;
  unsigned char D.27974;
  int D.27975;
  const unsigned char * D.27976;
  unsigned char D.27977;
  int D.27978;
  _Bool D.27979;
  _Bool D.27980;
  const unsigned char * D.27983;
  unsigned char D.27984;
  int D.27985;
  const unsigned char * D.27986;
  unsigned char D.27987;
  int D.27988;
  int D.27990;
  unsigned int D.27993;
  unsigned int D.27997;
  _Bool D.28000;
  int D.28001;
  int D.28002;
  int D.28007;
  unsigned int D.28010;
  unsigned int D.28015;
  unsigned int D.28018;
  int D.28025;
  unsigned int D.28028;
  struct MonoException * D.28038;
  struct MonoLoaderError * D.28040;
  struct MonoException * D.28041;
  struct GPtrArray * array;
  struct MonoClass * startklass;
  struct MonoMethod * method;
  void * iter;
  int len;
  int match;
  int nslots;
  guint32 method_slots_default[8];
  guint32 * method_slots;
  int (*<T43a0>) (const char *, const char *) compare_func;
  void loader_error = <<< error >>>;
  void handle_parent = <<< error >>>;

  try
    {
      method_slots = 0B;
      compare_func = 0B;
      array = monoeg_g_ptr_array_new ();
      startklass = klass;
      *ex = 0B;
      len = 0;
      if (name != 0B) goto <D.27784>; else goto <D.27785>;
      <D.27784>:
      if (ignore_case != 0) goto <D.27787>; else goto <D.27788>;
      <D.27787>:
      iftmp.0 = monoeg_ascii_strcasecmp;
      goto <D.27789>;
      <D.27788>:
      iftmp.0 = strcmp;
      <D.27789>:
      compare_func = iftmp.0;
      <D.27785>:
      D.27790 = BIT_FIELD_REF <*klass, 8, 184>;
      D.27791 = D.27790 & 1;
      if (D.27791 != 0) goto <D.27792>; else goto <D.27793>;
      <D.27792>:
      if (name != 0B) goto <D.27794>; else goto <D.27795>;
      <D.27794>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 6;
        if (__s2_len <= 3) goto <D.27797>; else goto <D.27798>;
        <D.27797>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = name;
          D.27799 = "Invoke";
          D.27800 = MEM[(const unsigned char *)D.27799];
          D.27801 = (int) D.27800;
          D.27802 = *__s2;
          D.27803 = (int) D.27802;
          __result = D.27801 - D.27803;
          {
            D.27804 = __s2_len != 0;
            D.27805 = __result == 0;
            D.27806 = D.27804 & D.27805;
            if (D.27806 != 0) goto <D.27807>; else goto <D.27808>;
            <D.27807>:
            D.27809 = &MEM[(void *)"Invoke" + 1B];
            D.27810 = *D.27809;
            D.27811 = (int) D.27810;
            D.27812 = __s2 + 1;
            D.27813 = *D.27812;
            D.27814 = (int) D.27813;
            __result = D.27811 - D.27814;
            D.27815 = __s2_len > 1;
            D.27805 = __result == 0;
            D.27816 = D.27815 & D.27805;
            if (D.27816 != 0) goto <D.27817>; else goto <D.27818>;
            <D.27817>:
            D.27819 = &MEM[(void *)"Invoke" + 2B];
            D.27820 = *D.27819;
            D.27821 = (int) D.27820;
            D.27822 = __s2 + 2;
            D.27823 = *D.27822;
            D.27824 = (int) D.27823;
            __result = D.27821 - D.27824;
            D.27825 = __s2_len > 2;
            D.27805 = __result == 0;
            D.27826 = D.27825 & D.27805;
            if (D.27826 != 0) goto <D.27827>; else goto <D.27828>;
            <D.27827>:
            D.27829 = &MEM[(void *)"Invoke" + 3B];
            D.27830 = *D.27829;
            D.27831 = (int) D.27830;
            D.27832 = __s2 + 3;
            D.27833 = *D.27832;
            D.27834 = (int) D.27833;
            __result = D.27831 - D.27834;
            <D.27828>:
            <D.27818>:
            <D.27808>:
          }
          D.24421 = __result;
        }
        iftmp.1 = -D.24421;
        goto <D.27835>;
        <D.27798>:
        iftmp.1 = __builtin_strcmp (name, "Invoke");
        <D.27835>:
        D.24422 = iftmp.1;
      }
      if (D.24422 == 0) goto <D.27836>; else goto <D.27837>;
      <D.27836>:
      if (bflags == 28) goto <D.27838>; else goto <D.27839>;
      <D.27838>:
      method = mono_get_delegate_invoke (klass);
      D.27840 = mono_loader_get_last_error ();
      if (D.27840 != 0B) goto loader_error; else goto <D.27841>;
      <D.27841>:
      monoeg_g_ptr_array_add (array, method);
      D.27842 = array;
      return D.27842;
      <D.27839>:
      <D.27837>:
      <D.27795>:
      <D.27793>:
      mono_class_setup_vtable (klass);
      D.27843 = klass->exception_type;
      if (D.27843 != 0) goto loader_error; else goto <D.27844>;
      <D.27844>:
      D.27845 = mono_loader_get_last_error ();
      if (D.27845 != 0B) goto loader_error; else goto <D.27846>;
      <D.27846>:
      D.27847 = &klass->byval_arg;
      D.27848 = is_generic_parameter (D.27847);
      if (D.27848 != 0) goto <D.27849>; else goto <D.27850>;
      <D.27849>:
      D.27851 = klass->parent;
      nslots = mono_class_get_vtable_size (D.27851);
      goto <D.27852>;
      <D.27850>:
      D.27857 = klass->flags;
      D.27858 = D.27857 & 32;
      if (D.27858 != 0) goto <D.27854>; else goto <D.27859>;
      <D.27859>:
      D.27860 = klass->byval_arg.type;
      if (D.27860 == 19) goto <D.27854>; else goto <D.27861>;
      <D.27861>:
      D.27860 = klass->byval_arg.type;
      if (D.27860 == 30) goto <D.27854>; else goto <D.27855>;
      <D.27854>:
      iftmp.2 = mono_class_num_methods (klass);
      goto <D.27856>;
      <D.27855>:
      iftmp.2 = mono_class_get_vtable_size (klass);
      <D.27856>:
      nslots = iftmp.2;
      <D.27852>:
      nslots.3 = (unsigned int) nslots;
      if (nslots.3 > 255) goto <D.27863>; else goto <D.27864>;
      <D.27863>:
      D.27865 = nslots / 32;
      D.27866 = D.27865 + 1;
      D.27867 = (unsigned int) D.27866;
      D.27868 = D.27867 * 4;
      method_slots = monoeg_malloc0 (D.27868);
      goto <D.27869>;
      <D.27864>:
      method_slots = &method_slots_default;
      memset (method_slots, 0, 32);
      <D.27869>:
      handle_parent:
      mono_class_setup_vtable (klass);
      D.27843 = klass->exception_type;
      if (D.27843 != 0) goto loader_error; else goto <D.27870>;
      <D.27870>:
      D.27871 = mono_loader_get_last_error ();
      if (D.27871 != 0B) goto loader_error; else goto <D.27872>;
      <D.27872>:
      iter = 0B;
      goto <D.24425>;
      <D.24444>:
      match = 0;
      D.27873 = method->slot;
      if (D.27873 != -1) goto <D.27874>; else goto <D.27875>;
      <D.27874>:
      D.27873 = method->slot;
      D.27876 = (int) D.27873;
      D.27877 = D.27876 >= nslots;
      D.27878 = (long int) D.27877;
      D.27879 = __builtin_expect (D.27878, 0);
      if (D.27879 != 0) goto <D.27880>; else goto <D.27881>;
      <D.27880>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3493, "method->slot < nslots");
      <D.27881>:
      D.27873 = method->slot;
      D.27882 = D.27873 >> 5;
      D.27883 = (unsigned int) D.27882;
      D.27884 = D.27883 * 4;
      D.27885 = method_slots + D.27884;
      D.27886 = *D.27885;
      D.27873 = method->slot;
      D.27887 = (unsigned short) D.27873;
      D.27888 = (int) D.27887;
      D.27889 = D.27888 & 31;
      D.27890 = 1 << D.27889;
      D.27891 = (unsigned int) D.27890;
      D.27892 = D.27886 & D.27891;
      if (D.27892 != 0) goto <D.27893>; else goto <D.27894>;
      <D.27893>:
      // predicted unlikely by continue predictor.
      goto <D.24425>;
      <D.27894>:
      D.27895 = method->flags;
      D.27896 = (int) D.27895;
      D.27897 = D.27896 & 256;
      if (D.27897 == 0) goto <D.27898>; else goto <D.27899>;
      <D.27898>:
      D.27873 = method->slot;
      D.27882 = D.27873 >> 5;
      D.27883 = (unsigned int) D.27882;
      D.27884 = D.27883 * 4;
      D.27885 = method_slots + D.27884;
      D.27873 = method->slot;
      D.27882 = D.27873 >> 5;
      D.27883 = (unsigned int) D.27882;
      D.27884 = D.27883 * 4;
      D.27885 = method_slots + D.27884;
      D.27886 = *D.27885;
      D.27873 = method->slot;
      D.27887 = (unsigned short) D.27873;
      D.27888 = (int) D.27887;
      D.27889 = D.27888 & 31;
      D.27890 = 1 << D.27889;
      D.27891 = (unsigned int) D.27890;
      D.27900 = D.27886 | D.27891;
      *D.27885 = D.27900;
      <D.27899>:
      <D.27875>:
      if (allow_ctors == 0) goto <D.27903>; else goto <D.27904>;
      <D.27903>:
      D.27905 = method->name;
      D.27906 = *D.27905;
      if (D.27906 == 46) goto <D.27907>; else goto <D.27908>;
      <D.27907>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 5;
        if (__s2_len <= 3) goto <D.27910>; else goto <D.27911>;
        <D.27910>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = method->name;
          D.27912 = ".ctor";
          D.27913 = MEM[(const unsigned char *)D.27912];
          D.27914 = (int) D.27913;
          D.27915 = *__s2;
          D.27916 = (int) D.27915;
          __result = D.27914 - D.27916;
          {
            D.27917 = __s2_len != 0;
            D.27918 = __result == 0;
            D.27919 = D.27917 & D.27918;
            if (D.27919 != 0) goto <D.27920>; else goto <D.27921>;
            <D.27920>:
            D.27922 = &MEM[(void *)".ctor" + 1B];
            D.27923 = *D.27922;
            D.27924 = (int) D.27923;
            D.27925 = __s2 + 1;
            D.27926 = *D.27925;
            D.27927 = (int) D.27926;
            __result = D.27924 - D.27927;
            D.27928 = __s2_len > 1;
            D.27918 = __result == 0;
            D.27929 = D.27928 & D.27918;
            if (D.27929 != 0) goto <D.27930>; else goto <D.27931>;
            <D.27930>:
            D.27932 = &MEM[(void *)".ctor" + 2B];
            D.27933 = *D.27932;
            D.27934 = (int) D.27933;
            D.27935 = __s2 + 2;
            D.27936 = *D.27935;
            D.27937 = (int) D.27936;
            __result = D.27934 - D.27937;
            D.27938 = __s2_len > 2;
            D.27918 = __result == 0;
            D.27939 = D.27938 & D.27918;
            if (D.27939 != 0) goto <D.27940>; else goto <D.27941>;
            <D.27940>:
            D.27942 = &MEM[(void *)".ctor" + 3B];
            D.27943 = *D.27942;
            D.27944 = (int) D.27943;
            D.27945 = __s2 + 3;
            D.27946 = *D.27945;
            D.27947 = (int) D.27946;
            __result = D.27944 - D.27947;
            <D.27941>:
            <D.27931>:
            <D.27921>:
          }
          D.24433 = __result;
        }
        iftmp.4 = -D.24433;
        goto <D.27948>;
        <D.27911>:
        D.27905 = method->name;
        iftmp.4 = __builtin_strcmp (D.27905, ".ctor");
        <D.27948>:
        D.24434 = iftmp.4;
      }
      if (D.24434 == 0) goto <D.27901>; else goto <D.27949>;
      <D.27949>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 6;
        if (__s2_len <= 3) goto <D.27951>; else goto <D.27952>;
        <D.27951>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = method->name;
          D.27953 = ".cctor";
          D.27954 = MEM[(const unsigned char *)D.27953];
          D.27955 = (int) D.27954;
          D.27956 = *__s2;
          D.27957 = (int) D.27956;
          __result = D.27955 - D.27957;
          {
            D.27958 = __s2_len != 0;
            D.27959 = __result == 0;
            D.27960 = D.27958 & D.27959;
            if (D.27960 != 0) goto <D.27961>; else goto <D.27962>;
            <D.27961>:
            D.27963 = &MEM[(void *)".cctor" + 1B];
            D.27964 = *D.27963;
            D.27965 = (int) D.27964;
            D.27966 = __s2 + 1;
            D.27967 = *D.27966;
            D.27968 = (int) D.27967;
            __result = D.27965 - D.27968;
            D.27969 = __s2_len > 1;
            D.27959 = __result == 0;
            D.27970 = D.27969 & D.27959;
            if (D.27970 != 0) goto <D.27971>; else goto <D.27972>;
            <D.27971>:
            D.27973 = &MEM[(void *)".cctor" + 2B];
            D.27974 = *D.27973;
            D.27975 = (int) D.27974;
            D.27976 = __s2 + 2;
            D.27977 = *D.27976;
            D.27978 = (int) D.27977;
            __result = D.27975 - D.27978;
            D.27979 = __s2_len > 2;
            D.27959 = __result == 0;
            D.27980 = D.27979 & D.27959;
            if (D.27980 != 0) goto <D.27981>; else goto <D.27982>;
            <D.27981>:
            D.27983 = &MEM[(void *)".cctor" + 3B];
            D.27984 = *D.27983;
            D.27985 = (int) D.27984;
            D.27986 = __s2 + 3;
            D.27987 = *D.27986;
            D.27988 = (int) D.27987;
            __result = D.27985 - D.27988;
            <D.27982>:
            <D.27972>:
            <D.27962>:
          }
          D.24442 = __result;
        }
        iftmp.5 = -D.24442;
        goto <D.27989>;
        <D.27952>:
        D.27905 = method->name;
        iftmp.5 = __builtin_strcmp (D.27905, ".cctor");
        <D.27989>:
        D.24443 = iftmp.5;
      }
      if (D.24443 == 0) goto <D.27901>; else goto <D.27902>;
      <D.27901>:
      // predicted unlikely by continue predictor.
      goto <D.24425>;
      <D.27902>:
      <D.27908>:
      <D.27904>:
      D.27895 = method->flags;
      D.27896 = (int) D.27895;
      D.27990 = D.27896 & 7;
      if (D.27990 == 6) goto <D.27991>; else goto <D.27992>;
      <D.27991>:
      D.27993 = bflags & 16;
      if (D.27993 != 0) goto <D.27994>; else goto <D.27995>;
      <D.27994>:
      match = match + 1;
      <D.27995>:
      goto <D.27996>;
      <D.27992>:
      D.27997 = bflags & 32;
      if (D.27997 != 0) goto <D.27998>; else goto <D.27999>;
      <D.27998>:
      D.28000 = klass == startklass;
      D.28001 = (int) D.28000;
      D.28002 = method_nonpublic (method, D.28001);
      if (D.28002 != 0) goto <D.28003>; else goto <D.28004>;
      <D.28003>:
      match = match + 1;
      <D.28004>:
      <D.27999>:
      <D.27996>:
      if (match == 0) goto <D.28005>; else goto <D.28006>;
      <D.28005>:
      // predicted unlikely by continue predictor.
      goto <D.24425>;
      <D.28006>:
      match = 0;
      D.27895 = method->flags;
      D.27896 = (int) D.27895;
      D.28007 = D.27896 & 16;
      if (D.28007 != 0) goto <D.28008>; else goto <D.28009>;
      <D.28008>:
      D.28010 = bflags & 8;
      if (D.28010 != 0) goto <D.28011>; else goto <D.28012>;
      <D.28011>:
      D.28015 = bflags & 64;
      if (D.28015 != 0) goto <D.28013>; else goto <D.28016>;
      <D.28016>:
      if (klass == startklass) goto <D.28013>; else goto <D.28014>;
      <D.28013>:
      match = match + 1;
      <D.28014>:
      <D.28012>:
      goto <D.28017>;
      <D.28009>:
      D.28018 = bflags & 4;
      if (D.28018 != 0) goto <D.28019>; else goto <D.28020>;
      <D.28019>:
      match = match + 1;
      <D.28020>:
      <D.28017>:
      if (match == 0) goto <D.28021>; else goto <D.28022>;
      <D.28021>:
      // predicted unlikely by continue predictor.
      goto <D.24425>;
      <D.28022>:
      if (name != 0B) goto <D.28023>; else goto <D.28024>;
      <D.28023>:
      D.27905 = method->name;
      D.28025 = compare_func (name, D.27905);
      if (D.28025 != 0) goto <D.28026>; else goto <D.28027>;
      <D.28026>:
      // predicted unlikely by continue predictor.
      goto <D.24425>;
      <D.28027>:
      <D.28024>:
      match = 0;
      monoeg_g_ptr_array_add (array, method);
      <D.24425>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.24444>; else goto <D.24445>;
      <D.24445>:
      D.28028 = bflags & 2;
      if (D.28028 == 0) goto <D.28029>; else goto <D.28030>;
      <D.28029>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.28031>;
      <D.28031>:
      <D.28030>:
      if (&method_slots_default != method_slots) goto <D.28032>; else goto <D.28033>;
      <D.28032>:
      monoeg_g_free (method_slots);
      <D.28033>:
      D.27842 = array;
      return D.27842;
      loader_error:
      if (&method_slots_default != method_slots) goto <D.28034>; else goto <D.28035>;
      <D.28034>:
      monoeg_g_free (method_slots);
      <D.28035>:
      monoeg_g_ptr_array_free (array, 1);
      D.27843 = klass->exception_type;
      if (D.27843 != 0) goto <D.28036>; else goto <D.28037>;
      <D.28036>:
      D.28038 = mono_class_get_exception_for_failure (klass);
      *ex = D.28038;
      goto <D.28039>;
      <D.28037>:
      D.28040 = mono_loader_get_last_error ();
      D.28041 = mono_loader_error_prepare_exception (D.28040);
      *ex = D.28041;
      mono_loader_clear_error ();
      <D.28039>:
      D.27842 = 0B;
      return D.27842;
    }
  finally
    {
      iter = {CLOBBER};
      method_slots_default = {CLOBBER};
    }
}


is_generic_parameter (struct MonoType * type)
{
  MonoBoolean D.28044;
  int iftmp.6;
  unsigned char D.28048;
  unsigned char D.28049;
  unsigned char D.28051;
  _Bool D.28052;
  _Bool D.28053;
  _Bool D.28054;

  D.28048 = BIT_FIELD_REF <*type, 8, 56>;
  D.28049 = D.28048 & 64;
  if (D.28049 == 0) goto <D.28050>; else goto <D.28046>;
  <D.28050>:
  D.28051 = type->type;
  D.28052 = D.28051 == 19;
  D.28053 = D.28051 == 30;
  D.28054 = D.28052 | D.28053;
  if (D.28054 != 0) goto <D.28055>; else goto <D.28046>;
  <D.28055>:
  iftmp.6 = 1;
  goto <D.28047>;
  <D.28046>:
  iftmp.6 = 0;
  <D.28047>:
  D.28044 = (MonoBoolean) iftmp.6;
  return D.28044;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.28059;
  int D.28064;
  void * D.28066;
  unsigned int D.28067;

  D.28059 = __builtin_constant_p (__len);
  if (D.28059 != 0) goto <D.28060>; else goto <D.28061>;
  <D.28060>:
  if (__len == 0) goto <D.28062>; else goto <D.28063>;
  <D.28062>:
  D.28064 = __builtin_constant_p (__ch);
  if (D.28064 == 0) goto <D.28057>; else goto <D.28065>;
  <D.28065>:
  if (__ch != 0) goto <D.28057>; else goto <D.28058>;
  <D.28057>:
  __warn_memset_zero_len ();
  D.28066 = __dest;
  return D.28066;
  <D.28058>:
  <D.28063>:
  <D.28061>:
  D.28067 = __builtin_object_size (__dest, 0);
  D.28066 = __builtin___memset_chk (__dest, __ch, __len, D.28067);
  return D.28066;
}


method_nonpublic (struct MonoMethod * method, gboolean start_klass)
{
  short unsigned int D.28069;
  int D.28070;
  int D.28071;
  gboolean D.28072;
  int iftmp.7;
  struct MonoClass * D.28078;

  D.28069 = method->flags;
  D.28070 = (int) D.28069;
  D.28071 = D.28070 & 7;
  switch (D.28071) <default: <D.24393>, case 1: <D.24391>, case 3: <D.24390>, case 6: <D.24392>>
  <D.24390>:
  if (start_klass != 0) goto <D.28074>; else goto <D.28077>;
  <D.28077>:
  D.28078 = mono_defaults.generic_ilist_class;
  if (D.28078 != 0B) goto <D.28074>; else goto <D.28075>;
  <D.28074>:
  iftmp.7 = 1;
  goto <D.28076>;
  <D.28075>:
  iftmp.7 = 0;
  <D.28076>:
  D.28072 = iftmp.7;
  return D.28072;
  <D.24391>:
  D.28072 = start_klass;
  return D.28072;
  <D.24392>:
  D.28072 = 0;
  return D.28072;
  <D.24393>:
  D.28072 = 1;
  return D.28072;
}


ves_icall_System_Environment_get_UserName ()
{
  struct MonoString * D.28080;
  struct MonoDomain * D.28081;
  const gchar * D.28082;

  D.28081 = mono_domain_get ();
  D.28082 = monoeg_g_get_user_name ();
  D.28080 = mono_string_new (D.28081, D.28082);
  return D.28080;
}


mono_icall_init ()
{
  int D.27475;
  short unsigned int D.28088;
  sizetype D.28089;
  const char * D.28090;
  const struct IcallTypeDesc * D.28093;
  short unsigned int D.28094;
  int D.28095;
  short unsigned int D.28096;
  int D.28097;
  int D.28098;
  short unsigned int D.28099;
  sizetype D.28100;
  int D.27485;
  struct GHashTable * icall_hash.8;
  int i;

  i = 0;
  if (1 != 0) goto <D.28084>; else goto <D.28085>;
  <D.28084>:
  {
    int j;
    const char * prev_class;
    const char * prev_method;

    prev_class = 0B;
    i = 0;
    goto <D.27490>;
    <D.27489>:
    {
      const struct IcallTypeDesc * desc;
      int num_icalls;

      prev_method = 0B;
      if (prev_class != 0B) goto <D.28086>; else goto <D.28087>;
      <D.28086>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.28088 = icall_type_names_idx[i];
        D.28089 = (sizetype) D.28088;
        D.28090 = &icall_type_names_str + D.28089;
        D.27475 = __builtin_strcmp (prev_class, D.28090);
      }
      if (D.27475 >= 0) goto <D.28091>; else goto <D.28092>;
      <D.28091>:
      D.28088 = icall_type_names_idx[i];
      D.28089 = (sizetype) D.28088;
      D.28090 = &icall_type_names_str + D.28089;
      monoeg_g_print ("class %s should come before class %s\n", D.28090, prev_class);
      <D.28092>:
      <D.28087>:
      D.28088 = icall_type_names_idx[i];
      D.28089 = (sizetype) D.28088;
      prev_class = &icall_type_names_str + D.28089;
      desc = &icall_type_descs[i];
      D.28093 = desc + 2;
      D.28094 = D.28093->first_icall;
      D.28095 = (int) D.28094;
      D.28096 = desc->first_icall;
      D.28097 = (int) D.28096;
      num_icalls = D.28095 - D.28097;
      j = 0;
      goto <D.27487>;
      <D.27486>:
      {
        const char * methodn;

        D.28096 = desc->first_icall;
        D.28097 = (int) D.28096;
        D.28098 = D.28097 + j;
        D.28099 = icall_names_idx[D.28098];
        D.28100 = (sizetype) D.28099;
        methodn = &icall_names_str + D.28100;
        if (prev_method != 0B) goto <D.28101>; else goto <D.28102>;
        <D.28101>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.27485 = __builtin_strcmp (prev_method, methodn);
        }
        if (D.27485 >= 0) goto <D.28103>; else goto <D.28104>;
        <D.28103>:
        monoeg_g_print ("method %s should come before method %s\n", methodn, prev_method);
        <D.28104>:
        <D.28102>:
        prev_method = methodn;
      }
      j = j + 1;
      <D.27487>:
      if (j < num_icalls) goto <D.27486>; else goto <D.27488>;
      <D.27488>:
    }
    i = i + 1;
    <D.27490>:
    if (i <= 107) goto <D.27489>; else goto <D.27491>;
    <D.27491>:
  }
  <D.28085>:
  icall_hash.8 = monoeg_g_hash_table_new_full (monoeg_g_str_hash, monoeg_g_str_equal, monoeg_g_free, 0B);
  icall_hash = icall_hash.8;
  pthread_mutex_init (&icall_mutex, 0B);
}


mono_icall_cleanup ()
{
  struct GHashTable * icall_hash.9;
  struct GHashTable * jit_icall_hash_name.10;
  struct GHashTable * jit_icall_hash_addr.11;

  icall_hash.9 = icall_hash;
  monoeg_g_hash_table_destroy (icall_hash.9);
  jit_icall_hash_name.10 = jit_icall_hash_name;
  monoeg_g_hash_table_destroy (jit_icall_hash_name.10);
  jit_icall_hash_addr.11 = jit_icall_hash_addr;
  monoeg_g_hash_table_destroy (jit_icall_hash_addr.11);
  pthread_mutex_destroy (&icall_mutex);
}


mono_add_internal_call (const char * name, const void * method)
{
  struct GHashTable * icall_hash.12;
  gchar * D.28110;

  mono_icall_lock ();
  icall_hash.12 = icall_hash;
  D.28110 = monoeg_strdup (name);
  monoeg_g_hash_table_insert_replace (icall_hash.12, D.28110, method, 0);
  mono_icall_unlock ();
}


mono_icall_lock ()
{
  pthread_mutex_lock (&icall_mutex);
}


monoeg_strdup (const gchar * str)
{
  gchar * D.28113;

  if (str != 0B) goto <D.28111>; else goto <D.28112>;
  <D.28111>:
  D.28113 = __strdup (str);
  return D.28113;
  <D.28112>:
  D.28113 = 0B;
  return D.28113;
}


mono_icall_unlock ()
{
  pthread_mutex_unlock (&icall_mutex);
}


mono_lookup_internal_call (struct MonoMethod * method)
{
  _Bool D.28115;
  long int D.28116;
  long int D.28117;
  unsigned char D.28120;
  unsigned char D.28121;
  struct MonoClass * D.28124;
  struct MonoClass * D.28125;
  void * D.28130;
  int pos.13;
  sizetype pos.14;
  char * D.28133;
  unsigned int pos.15;
  unsigned int D.28135;
  int D.28136;
  int D.28142;
  const char * D.28143;
  unsigned int D.28144;
  sizetype typelen.16;
  sizetype D.28146;
  char * D.28147;
  unsigned int mlen.17;
  sizetype mlen.18;
  sizetype D.28150;
  sizetype D.28151;
  struct MonoMethodSignature * D.28152;
  unsigned int D.28153;
  int D.28154;
  int D.28155;
  int D.28156;
  unsigned int D.28157;
  char * D.28160;
  unsigned int siglen.19;
  sizetype siglen.20;
  sizetype D.28163;
  char * D.28164;
  sizetype D.28165;
  char * D.28166;
  struct GHashTable * icall_hash.21;
  sizetype D.28174;
  char * D.28175;
  struct MonoImage * D.28180;
  char * D.28181;
  char * sigstart;
  char * tmpsig;
  char mname[2048];
  int typelen;
  int mlen;
  int siglen;
  void * res;
  const struct IcallTypeDesc * imap;

  try
    {
      typelen = 0;
      imap = 0B;
      D.28115 = method == 0B;
      D.28116 = (long int) D.28115;
      D.28117 = __builtin_expect (D.28116, 0);
      if (D.28117 != 0) goto <D.28118>; else goto <D.28119>;
      <D.28118>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8049, "method != NULL");
      <D.28119>:
      D.28120 = BIT_FIELD_REF <*method, 8, 168>;
      D.28121 = D.28120 & 16;
      if (D.28121 != 0) goto <D.28122>; else goto <D.28123>;
      <D.28122>:
      method = MEM[(struct MonoMethodInflated *)method].declaring;
      <D.28123>:
      D.28124 = method->klass;
      D.28125 = D.28124->nested_in;
      if (D.28125 != 0B) goto <D.28126>; else goto <D.28127>;
      <D.28126>:
      {
        int pos;

        D.28124 = method->klass;
        D.28125 = D.28124->nested_in;
        pos = concat_class_name (&mname, 2046, D.28125);
        if (pos == 0) goto <D.28128>; else goto <D.28129>;
        <D.28128>:
        D.28130 = 0B;
        return D.28130;
        <D.28129>:
        pos.13 = pos;
        pos = pos.13 + 1;
        mname[pos.13] = 47;
        mname[pos] = 0;
        pos.14 = (sizetype) pos;
        D.28133 = &mname + pos.14;
        pos.15 = (unsigned int) pos;
        D.28135 = 2047 - pos.15;
        D.28136 = (int) D.28135;
        D.28124 = method->klass;
        typelen = concat_class_name (D.28133, D.28136, D.28124);
        if (typelen == 0) goto <D.28137>; else goto <D.28138>;
        <D.28137>:
        D.28130 = 0B;
        return D.28130;
        <D.28138>:
        typelen = typelen + pos;
      }
      goto <D.28139>;
      <D.28127>:
      D.28124 = method->klass;
      typelen = concat_class_name (&mname, 2048, D.28124);
      if (typelen == 0) goto <D.28140>; else goto <D.28141>;
      <D.28140>:
      D.28130 = 0B;
      return D.28130;
      <D.28141>:
      <D.28139>:
      imap = find_class_icalls (&mname);
      mname[typelen] = 58;
      D.28142 = typelen + 1;
      mname[D.28142] = 58;
      D.28143 = method->name;
      D.28144 = strlen (D.28143);
      mlen = (int) D.28144;
      typelen.16 = (sizetype) typelen;
      D.28146 = typelen.16 + 2;
      D.28147 = &mname + D.28146;
      D.28143 = method->name;
      mlen.17 = (unsigned int) mlen;
      memcpy (D.28147, D.28143, mlen.17);
      typelen.16 = (sizetype) typelen;
      mlen.18 = (sizetype) mlen;
      D.28150 = typelen.16 + mlen.18;
      D.28151 = D.28150 + 2;
      sigstart = &mname + D.28151;
      *sigstart = 0;
      D.28152 = mono_method_signature (method);
      tmpsig = mono_signature_get_desc (D.28152, 1);
      D.28153 = strlen (tmpsig);
      siglen = (int) D.28153;
      D.28154 = typelen + mlen;
      D.28155 = D.28154 + siglen;
      D.28156 = D.28155 + 6;
      D.28157 = (unsigned int) D.28156;
      if (D.28157 > 2048) goto <D.28158>; else goto <D.28159>;
      <D.28158>:
      D.28130 = 0B;
      return D.28130;
      <D.28159>:
      *sigstart = 40;
      D.28160 = sigstart + 1;
      siglen.19 = (unsigned int) siglen;
      memcpy (D.28160, tmpsig, siglen.19);
      siglen.20 = (sizetype) siglen;
      D.28163 = siglen.20 + 1;
      D.28164 = sigstart + D.28163;
      *D.28164 = 41;
      siglen.20 = (sizetype) siglen;
      D.28165 = siglen.20 + 2;
      D.28166 = sigstart + D.28165;
      *D.28166 = 0;
      monoeg_g_free (tmpsig);
      mono_icall_lock ();
      icall_hash.21 = icall_hash;
      res = monoeg_g_hash_table_lookup (icall_hash.21, &mname);
      if (res != 0B) goto <D.28168>; else goto <D.28169>;
      <D.28168>:
      mono_icall_unlock ();
      D.28130 = res;
      return D.28130;
      <D.28169>:
      *sigstart = 0;
      icall_hash.21 = icall_hash;
      res = monoeg_g_hash_table_lookup (icall_hash.21, &mname);
      if (res != 0B) goto <D.28170>; else goto <D.28171>;
      <D.28170>:
      mono_icall_unlock ();
      D.28130 = res;
      return D.28130;
      <D.28171>:
      if (imap == 0B) goto <D.28172>; else goto <D.28173>;
      <D.28172>:
      mono_icall_unlock ();
      D.28130 = 0B;
      return D.28130;
      <D.28173>:
      mlen.18 = (sizetype) mlen;
      D.28174 = -mlen.18;
      D.28175 = sigstart + D.28174;
      res = find_method_icall (imap, D.28175);
      if (res != 0B) goto <D.28176>; else goto <D.28177>;
      <D.28176>:
      mono_icall_unlock ();
      D.28130 = res;
      return D.28130;
      <D.28177>:
      *sigstart = 40;
      mlen.18 = (sizetype) mlen;
      D.28174 = -mlen.18;
      D.28175 = sigstart + D.28174;
      res = find_method_icall (imap, D.28175);
      if (res != 0B) goto <D.28178>; else goto <D.28179>;
      <D.28178>:
      mono_icall_unlock ();
      D.28130 = res;
      return D.28130;
      <D.28179>:
      monoeg_g_log (0B, 16, "cant resolve internal call to \"%s\" (tested without signature also)", &mname);
      monoeg_g_print ("\nYour mono runtime and class libraries are out of sync.\n");
      D.28124 = method->klass;
      D.28180 = D.28124->image;
      D.28181 = D.28180->name;
      monoeg_g_print ("The out of sync library is: %s\n", D.28181);
      monoeg_g_print ("\nWhen you update one from svn you need to update, compile and install\nthe other too.\n");
      monoeg_g_print ("Do not report this as a bug unless you\'re sure you have updated correctly:\nyou probably have a broken mono install.\n");
      monoeg_g_print ("If you see other errors or faults after this message they are probably related\n");
      monoeg_g_print ("and you need to fix your mono install first.\n");
      mono_icall_unlock ();
      D.28130 = 0B;
      return D.28130;
    }
  finally
    {
      mname = {CLOBBER};
    }
}


concat_class_name (char * buf, int bufsize, struct MonoClass * klass)
{
  const char * D.28184;
  unsigned int D.28185;
  const char * D.28186;
  unsigned int D.28187;
  int D.28188;
  int D.28189;
  int D.28192;
  unsigned int nspacelen.22;
  int nspacelen.23;
  sizetype nspacelen.24;
  char * D.28198;
  sizetype nspacelen.25;
  char * D.28200;
  unsigned int cnamelen.26;
  sizetype D.28202;
  char * D.28203;
  int nspacelen;
  int cnamelen;

  D.28184 = klass->name_space;
  D.28185 = strlen (D.28184);
  nspacelen = (int) D.28185;
  D.28186 = klass->name;
  D.28187 = strlen (D.28186);
  cnamelen = (int) D.28187;
  D.28188 = nspacelen + cnamelen;
  D.28189 = D.28188 + 1;
  if (D.28189 >= bufsize) goto <D.28190>; else goto <D.28191>;
  <D.28190>:
  D.28192 = 0;
  return D.28192;
  <D.28191>:
  if (nspacelen != 0) goto <D.28193>; else goto <D.28194>;
  <D.28193>:
  D.28184 = klass->name_space;
  nspacelen.22 = (unsigned int) nspacelen;
  memcpy (buf, D.28184, nspacelen.22);
  nspacelen.23 = nspacelen;
  nspacelen = nspacelen.23 + 1;
  nspacelen.24 = (sizetype) nspacelen.23;
  D.28198 = buf + nspacelen.24;
  *D.28198 = 46;
  <D.28194>:
  nspacelen.25 = (sizetype) nspacelen;
  D.28200 = buf + nspacelen.25;
  D.28186 = klass->name;
  cnamelen.26 = (unsigned int) cnamelen;
  memcpy (D.28200, D.28186, cnamelen.26);
  D.28188 = nspacelen + cnamelen;
  D.28202 = (sizetype) D.28188;
  D.28203 = buf + D.28202;
  *D.28203 = 0;
  D.28192 = nspacelen + cnamelen;
  return D.28192;
}


find_class_icalls (const char * name)
{
  const struct IcallTypeDesc * D.28207;
  int nameslot.27;
  int D.28209;
  int D.28210;
  int D.28211;
  const guint16 * nameslot;

  nameslot = mono_binary_search (name, &icall_type_names_idx, 108, 2, compare_class_imap);
  if (nameslot == 0B) goto <D.28205>; else goto <D.28206>;
  <D.28205>:
  D.28207 = 0B;
  return D.28207;
  <D.28206>:
  nameslot.27 = (int) nameslot;
  D.28209 = (int) &icall_type_names_idx[0];
  D.28210 = nameslot.27 - D.28209;
  D.28211 = D.28210 /[ex] 2;
  D.28207 = &icall_type_descs[D.28211];
  return D.28207;
}


compare_class_imap (const void * key, const void * elem)
{
  short unsigned int D.28213;
  sizetype D.28214;
  int D.28215;
  int D.27537;
  const char * class_name;

  D.28213 = MEM[(guint16 *)elem];
  D.28214 = (sizetype) D.28213;
  class_name = &icall_type_names_str + D.28214;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.27537 = __builtin_strcmp (key, class_name);
  }
  D.28215 = D.27537;
  return D.28215;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.28217;
  unsigned int D.28218;

  D.28218 = __builtin_object_size (__dest, 0);
  D.28217 = __builtin___memcpy_chk (__dest, __src, __len, D.28218);
  return D.28217;
}


find_method_icall (const struct IcallTypeDesc * imap, const char * name)
{
  short unsigned int D.28220;
  unsigned int D.28221;
  unsigned int D.28222;
  const void * D.28223;
  const struct IcallTypeDesc * D.28224;
  short unsigned int D.28225;
  int D.28226;
  int D.28227;
  int D.28228;
  unsigned int D.28229;
  void * D.28232;
  int nameslot.28;
  int D.28234;
  int D.28235;
  int D.28236;
  const guint16 * nameslot;

  D.28220 = imap->first_icall;
  D.28221 = (unsigned int) D.28220;
  D.28222 = D.28221 * 2;
  D.28223 = &icall_names_idx + D.28222;
  D.28224 = imap + 2;
  D.28225 = D.28224->first_icall;
  D.28226 = (int) D.28225;
  D.28220 = imap->first_icall;
  D.28227 = (int) D.28220;
  D.28228 = D.28226 - D.28227;
  D.28229 = (unsigned int) D.28228;
  nameslot = mono_binary_search (name, D.28223, D.28229, 2, compare_method_imap);
  if (nameslot == 0B) goto <D.28230>; else goto <D.28231>;
  <D.28230>:
  D.28232 = 0B;
  return D.28232;
  <D.28231>:
  nameslot.28 = (int) nameslot;
  D.28234 = (int) &icall_names_idx[0];
  D.28235 = nameslot.28 - D.28234;
  D.28236 = D.28235 /[ex] 2;
  D.28232 = icall_functions[D.28236];
  return D.28232;
}


ves_icall_get_resources_ptr (struct MonoReflectionAssembly * assembly, void * * result, gint32 * size)
{
  _Bool D.28240;
  _Bool D.28241;
  _Bool D.28242;
  gboolean D.28244;
  struct MonoAssembly * D.28245;
  unsigned int D.28248;
  char * D.28249;
  void * D.28250;
  unsigned int D.28253;
  int D.28254;
  struct MonoPEResourceDataEntry * entry;
  struct MonoImage * image;

  D.28240 = assembly == 0B;
  D.28241 = result == 0B;
  D.28242 = D.28240 | D.28241;
  if (D.28242 != 0) goto <D.28238>; else goto <D.28243>;
  <D.28243>:
  if (size == 0B) goto <D.28238>; else goto <D.28239>;
  <D.28238>:
  D.28244 = 0;
  return D.28244;
  <D.28239>:
  *result = 0B;
  *size = 0;
  D.28245 = assembly->assembly;
  image = D.28245->image;
  entry = mono_image_lookup_resource (image, 101, 0, 0B);
  if (entry == 0B) goto <D.28246>; else goto <D.28247>;
  <D.28246>:
  D.28244 = 0;
  return D.28244;
  <D.28247>:
  D.28248 = entry->rde_data_offset;
  D.28249 = mono_image_rva_map (image, D.28248);
  *result = D.28249;
  D.28250 = *result;
  if (D.28250 == 0B) goto <D.28251>; else goto <D.28252>;
  <D.28251>:
  monoeg_g_free (entry);
  D.28244 = 0;
  return D.28244;
  <D.28252>:
  D.28253 = entry->rde_size;
  D.28254 = (int) D.28253;
  *size = D.28254;
  monoeg_g_free (entry);
  D.28244 = 1;
  return D.28244;
}


ves_icall_System_Web_Util_ICalls_get_machine_install_dir ()
{
  const char * D.28256;
  struct MonoDomain * D.28257;
  struct MonoString * D.28258;
  struct MonoString * ipath;
  gchar * path;

  D.28256 = mono_get_config_dir ();
  path = monoeg_g_path_get_dirname (D.28256);
  D.28257 = mono_domain_get ();
  ipath = mono_string_new (D.28257, path);
  monoeg_g_free (path);
  D.28258 = ipath;
  return D.28258;
}


ves_icall_System_ValueType_InternalGetHashCode (struct MonoObject * this, struct MonoArray * * fields)
{
  struct MonoVTable * D.28260;
  int D.28261;
  gint32 D.28264;
  struct MonoType * D.28265;
  short unsigned int D.28266;
  int D.28267;
  int D.28268;
  int D.28271;
  int D.23285;
  int iftmp.29;
  int D.23284;
  const char[9] * D.28277;
  unsigned char D.28278;
  int D.28279;
  unsigned char D.28280;
  int D.28281;
  _Bool D.28282;
  _Bool D.28283;
  _Bool D.28284;
  const unsigned char * D.28287;
  unsigned char D.28288;
  int D.28289;
  const unsigned char * D.28290;
  unsigned char D.28291;
  int D.28292;
  _Bool D.28293;
  _Bool D.28294;
  const unsigned char * D.28297;
  unsigned char D.28298;
  int D.28299;
  const unsigned char * D.28300;
  unsigned char D.28301;
  int D.28302;
  _Bool D.28303;
  _Bool D.28304;
  const unsigned char * D.28307;
  unsigned char D.28308;
  int D.28309;
  const unsigned char * D.28310;
  unsigned char D.28311;
  int D.28312;
  const char * D.28314;
  unsigned char D.28317;
  int D.28318;
  int D.28319;
  sizetype D.28320;
  gint32 * D.28321;
  int D.28322;
  struct MonoString * * D.28323;
  unsigned int D.28326;
  unsigned int result.30;
  unsigned int D.28328;
  int D.28331;
  unsigned int D.28332;
  unsigned int D.28333;
  struct MonoDomain * D.28334;
  int count.31;
  unsigned int count.32;
  unsigned int D.28337;
  struct MonoObject * * D.28338;
  struct MonoDomain * D.28341;
  struct MonoClass * D.28342;
  unsigned int count.33;
  struct MonoArray * D.28344;
  struct MonoArray * D.28345;
  unsigned int i.34;
  unsigned int i.35;
  unsigned int D.28348;
  struct MonoObject * * D.28349;
  struct MonoObject * D.28350;
  struct MonoClass * klass;
  struct MonoObject * * values;
  struct MonoObject * o;
  int count;
  gint32 result;
  struct MonoClassField * field;
  void * iter;

  try
    {
      values = 0B;
      count = 0;
      result = 0;
      D.28260 = this->vtable;
      klass = D.28260->klass;
      D.28261 = mono_class_num_fields (klass);
      if (D.28261 == 0) goto <D.28262>; else goto <D.28263>;
      <D.28262>:
      D.28264 = mono_object_hash (this);
      return D.28264;
      <D.28263>:
      iter = 0B;
      goto <D.23276>;
      <D.23291>:
      D.28265 = field->type;
      D.28266 = D.28265->attrs;
      D.28267 = (int) D.28266;
      D.28268 = D.28267 & 16;
      if (D.28268 != 0) goto <D.28269>; else goto <D.28270>;
      <D.28269>:
      // predicted unlikely by continue predictor.
      goto <D.23276>;
      <D.28270>:
      D.28265 = field->type;
      D.28266 = D.28265->attrs;
      D.28267 = (int) D.28266;
      D.28271 = D.28267 & 1536;
      if (D.28271 != 0) goto <D.28272>; else goto <D.28273>;
      <D.28272>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 8;
        if (__s2_len <= 3) goto <D.28275>; else goto <D.28276>;
        <D.28275>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = mono_field_get_name (field);
          D.28277 = "_Deleted";
          D.28278 = MEM[(const unsigned char *)D.28277];
          D.28279 = (int) D.28278;
          D.28280 = *__s2;
          D.28281 = (int) D.28280;
          __result = D.28279 - D.28281;
          {
            D.28282 = __s2_len != 0;
            D.28283 = __result == 0;
            D.28284 = D.28282 & D.28283;
            if (D.28284 != 0) goto <D.28285>; else goto <D.28286>;
            <D.28285>:
            D.28287 = &MEM[(void *)"_Deleted" + 1B];
            D.28288 = *D.28287;
            D.28289 = (int) D.28288;
            D.28290 = __s2 + 1;
            D.28291 = *D.28290;
            D.28292 = (int) D.28291;
            __result = D.28289 - D.28292;
            D.28293 = __s2_len > 1;
            D.28283 = __result == 0;
            D.28294 = D.28293 & D.28283;
            if (D.28294 != 0) goto <D.28295>; else goto <D.28296>;
            <D.28295>:
            D.28297 = &MEM[(void *)"_Deleted" + 2B];
            D.28298 = *D.28297;
            D.28299 = (int) D.28298;
            D.28300 = __s2 + 2;
            D.28301 = *D.28300;
            D.28302 = (int) D.28301;
            __result = D.28299 - D.28302;
            D.28303 = __s2_len > 2;
            D.28283 = __result == 0;
            D.28304 = D.28303 & D.28283;
            if (D.28304 != 0) goto <D.28305>; else goto <D.28306>;
            <D.28305>:
            D.28307 = &MEM[(void *)"_Deleted" + 3B];
            D.28308 = *D.28307;
            D.28309 = (int) D.28308;
            D.28310 = __s2 + 3;
            D.28311 = *D.28310;
            D.28312 = (int) D.28311;
            __result = D.28309 - D.28312;
            <D.28306>:
            <D.28296>:
            <D.28286>:
          }
          D.23284 = __result;
        }
        iftmp.29 = -D.23284;
        goto <D.28313>;
        <D.28276>:
        D.28314 = mono_field_get_name (field);
        iftmp.29 = __builtin_strcmp (D.28314, "_Deleted");
        <D.28313>:
        D.23285 = iftmp.29;
      }
      if (D.23285 == 0) goto <D.28315>; else goto <D.28316>;
      <D.28315>:
      // predicted unlikely by continue predictor.
      goto <D.23276>;
      <D.28316>:
      <D.28273>:
      D.28265 = field->type;
      D.28317 = D.28265->type;
      D.28318 = (int) D.28317;
      switch (D.28318) <default: <D.23290>, case 8: <D.23286>, case 14: <D.23288>>
      <D.23286>:
      D.28319 = field->offset;
      D.28320 = (sizetype) D.28319;
      D.28321 = this + D.28320;
      D.28322 = *D.28321;
      result = D.28322 ^ result;
      goto <D.23287>;
      <D.23288>:
      {
        struct MonoString * s;

        D.28319 = field->offset;
        D.28320 = (sizetype) D.28319;
        D.28323 = this + D.28320;
        s = *D.28323;
        if (s != 0B) goto <D.28324>; else goto <D.28325>;
        <D.28324>:
        D.28326 = mono_string_hash (s);
        result.30 = (unsigned int) result;
        D.28328 = D.28326 ^ result.30;
        result = (gint32) D.28328;
        <D.28325>:
        goto <D.23287>;
      }
      <D.23290>:
      if (values == 0B) goto <D.28329>; else goto <D.28330>;
      <D.28329>:
      D.28331 = mono_class_num_fields (klass);
      D.28332 = (unsigned int) D.28331;
      D.28333 = D.28332 * 4;
      values = __builtin_alloca (D.28333);
      <D.28330>:
      D.28260 = this->vtable;
      D.28334 = D.28260->domain;
      o = mono_field_get_value_object (D.28334, field, this);
      count.31 = count;
      count = count.31 + 1;
      count.32 = (unsigned int) count.31;
      D.28337 = count.32 * 4;
      D.28338 = values + D.28337;
      *D.28338 = o;
      <D.23287>:
      <D.23276>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.23291>; else goto <D.23292>;
      <D.23292>:
      if (values != 0B) goto <D.28339>; else goto <D.28340>;
      <D.28339>:
      {
        int i;

        D.28341 = mono_domain_get ();
        D.28342 = mono_defaults.object_class;
        count.33 = (unsigned int) count;
        D.28344 = mono_array_new (D.28341, D.28342, count.33);
        mono_gc_wbarrier_generic_store (fields, D.28344);
        i = 0;
        goto <D.23296>;
        <D.23295>:
        {
          void * * __p;

          D.28345 = *fields;
          i.34 = (unsigned int) i;
          __p = mono_array_addr_with_size (D.28345, 4, i.34);
          D.28345 = *fields;
          i.35 = (unsigned int) i;
          D.28348 = i.35 * 4;
          D.28349 = values + D.28348;
          D.28350 = *D.28349;
          mono_gc_wbarrier_set_arrayref (D.28345, __p, D.28350);
        }
        i = i + 1;
        <D.23296>:
        if (i < count) goto <D.23295>; else goto <D.23297>;
        <D.23297>:
      }
      goto <D.28351>;
      <D.28340>:
      *fields = 0B;
      <D.28351>:
      D.28264 = result;
      return D.28264;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_System_ValueType_Equals (struct MonoObject * this, struct MonoObject * that, struct MonoArray * * fields)
{
  _Bool D.28354;
  long int D.28355;
  long int D.28356;
  struct MonoVTable * D.28361;
  struct MonoVTable * D.28362;
  MonoBoolean D.28365;
  unsigned char D.28366;
  unsigned char D.28367;
  struct MonoType * D.28370;
  struct MonoType * D.28373;
  unsigned char D.28374;
  gint32 * D.28377;
  int D.28378;
  gint32 * D.28379;
  int D.28380;
  _Bool D.28381;
  struct MonoType * D.28382;
  short unsigned int D.28383;
  int D.28384;
  int D.28385;
  int D.28388;
  int D.23319;
  int iftmp.36;
  int D.23318;
  const char[9] * D.28394;
  unsigned char D.28395;
  int D.28396;
  unsigned char D.28397;
  int D.28398;
  _Bool D.28399;
  _Bool D.28400;
  _Bool D.28401;
  const unsigned char * D.28404;
  unsigned char D.28405;
  int D.28406;
  const unsigned char * D.28407;
  unsigned char D.28408;
  int D.28409;
  _Bool D.28410;
  _Bool D.28411;
  const unsigned char * D.28414;
  unsigned char D.28415;
  int D.28416;
  const unsigned char * D.28417;
  unsigned char D.28418;
  int D.28419;
  _Bool D.28420;
  _Bool D.28421;
  const unsigned char * D.28424;
  unsigned char D.28425;
  int D.28426;
  const unsigned char * D.28427;
  unsigned char D.28428;
  int D.28429;
  const char * D.28431;
  unsigned char D.28434;
  int D.28435;
  int D.28436;
  sizetype D.28437;
  guint8 * D.28438;
  unsigned char D.28439;
  guint8 * D.28440;
  unsigned char D.28441;
  gint16 * D.28444;
  short int D.28445;
  gint16 * D.28446;
  short int D.28447;
  gint32 * D.28450;
  int D.28451;
  gint32 * D.28452;
  int D.28453;
  gint64 * D.28456;
  long long int D.28457;
  gint64 * D.28458;
  long long int D.28459;
  float * D.28462;
  float D.28463;
  float * D.28464;
  float D.28465;
  double * D.28468;
  double D.28469;
  double * D.28470;
  double D.28471;
  struct MonoString * * D.28474;
  struct MonoString * * D.28475;
  _Bool D.28477;
  _Bool D.28478;
  _Bool D.28479;
  int D.28482;
  int D.28483;
  mono_unichar2 * D.28486;
  mono_unichar2 * D.28487;
  unsigned int D.28488;
  int D.28489;
  int D.28494;
  unsigned int D.28495;
  unsigned int D.28496;
  struct MonoDomain * D.28497;
  int count.37;
  unsigned int count.38;
  unsigned int D.28500;
  struct MonoObject * * D.28501;
  int count.39;
  unsigned int count.40;
  unsigned int D.28504;
  struct MonoObject * * D.28505;
  struct MonoDomain * D.28509;
  struct MonoClass * D.28510;
  unsigned int count.41;
  struct MonoArray * D.28512;
  struct MonoArray * D.28513;
  double[0:] * D.28514;
  unsigned int i.42;
  unsigned int D.28516;
  struct MonoObject * * D.28517;
  struct MonoObject * D.28518;
  struct MonoClass * klass;
  struct MonoObject * * values;
  struct MonoObject * o;
  struct MonoClassField * field;
  void * iter;
  int count;

  try
    {
      values = 0B;
      count = 0;
      D.28354 = that == 0B;
      D.28355 = (long int) D.28354;
      D.28356 = __builtin_expect (D.28355, 0);
      if (D.28356 != 0) goto <D.28357>; else goto <D.28358>;
      <D.28357>:
      {
        struct MonoException * ex;

        if (that != 0B) goto <D.28359>; else goto <D.28360>;
        <D.28359>:
        <D.28360>:
        ex = mono_get_exception_argument_null ("that");
        mono_raise_exception (ex);
      }
      <D.28358>:
      D.28361 = this->vtable;
      D.28362 = that->vtable;
      if (D.28361 != D.28362) goto <D.28363>; else goto <D.28364>;
      <D.28363>:
      D.28365 = 0;
      return D.28365;
      <D.28364>:
      D.28361 = this->vtable;
      klass = D.28361->klass;
      D.28366 = BIT_FIELD_REF <*klass, 8, 160>;
      D.28367 = D.28366 & 16;
      if (D.28367 != 0) goto <D.28368>; else goto <D.28369>;
      <D.28368>:
      D.28370 = mono_class_enum_basetype (klass);
      if (D.28370 != 0B) goto <D.28371>; else goto <D.28372>;
      <D.28371>:
      D.28373 = mono_class_enum_basetype (klass);
      D.28374 = D.28373->type;
      if (D.28374 == 8) goto <D.28375>; else goto <D.28376>;
      <D.28375>:
      D.28377 = this + 8;
      D.28378 = *D.28377;
      D.28379 = that + 8;
      D.28380 = *D.28379;
      D.28381 = D.28378 == D.28380;
      D.28365 = (MonoBoolean) D.28381;
      return D.28365;
      <D.28376>:
      <D.28372>:
      <D.28369>:
      *fields = 0B;
      iter = 0B;
      goto <D.23310>;
      <D.23340>:
      D.28382 = field->type;
      D.28383 = D.28382->attrs;
      D.28384 = (int) D.28383;
      D.28385 = D.28384 & 16;
      if (D.28385 != 0) goto <D.28386>; else goto <D.28387>;
      <D.28386>:
      // predicted unlikely by continue predictor.
      goto <D.23310>;
      <D.28387>:
      D.28382 = field->type;
      D.28383 = D.28382->attrs;
      D.28384 = (int) D.28383;
      D.28388 = D.28384 & 1536;
      if (D.28388 != 0) goto <D.28389>; else goto <D.28390>;
      <D.28389>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 8;
        if (__s2_len <= 3) goto <D.28392>; else goto <D.28393>;
        <D.28392>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = mono_field_get_name (field);
          D.28394 = "_Deleted";
          D.28395 = MEM[(const unsigned char *)D.28394];
          D.28396 = (int) D.28395;
          D.28397 = *__s2;
          D.28398 = (int) D.28397;
          __result = D.28396 - D.28398;
          {
            D.28399 = __s2_len != 0;
            D.28400 = __result == 0;
            D.28401 = D.28399 & D.28400;
            if (D.28401 != 0) goto <D.28402>; else goto <D.28403>;
            <D.28402>:
            D.28404 = &MEM[(void *)"_Deleted" + 1B];
            D.28405 = *D.28404;
            D.28406 = (int) D.28405;
            D.28407 = __s2 + 1;
            D.28408 = *D.28407;
            D.28409 = (int) D.28408;
            __result = D.28406 - D.28409;
            D.28410 = __s2_len > 1;
            D.28400 = __result == 0;
            D.28411 = D.28410 & D.28400;
            if (D.28411 != 0) goto <D.28412>; else goto <D.28413>;
            <D.28412>:
            D.28414 = &MEM[(void *)"_Deleted" + 2B];
            D.28415 = *D.28414;
            D.28416 = (int) D.28415;
            D.28417 = __s2 + 2;
            D.28418 = *D.28417;
            D.28419 = (int) D.28418;
            __result = D.28416 - D.28419;
            D.28420 = __s2_len > 2;
            D.28400 = __result == 0;
            D.28421 = D.28420 & D.28400;
            if (D.28421 != 0) goto <D.28422>; else goto <D.28423>;
            <D.28422>:
            D.28424 = &MEM[(void *)"_Deleted" + 3B];
            D.28425 = *D.28424;
            D.28426 = (int) D.28425;
            D.28427 = __s2 + 3;
            D.28428 = *D.28427;
            D.28429 = (int) D.28428;
            __result = D.28426 - D.28429;
            <D.28423>:
            <D.28413>:
            <D.28403>:
          }
          D.23318 = __result;
        }
        iftmp.36 = -D.23318;
        goto <D.28430>;
        <D.28393>:
        D.28431 = mono_field_get_name (field);
        iftmp.36 = __builtin_strcmp (D.28431, "_Deleted");
        <D.28430>:
        D.23319 = iftmp.36;
      }
      if (D.23319 == 0) goto <D.28432>; else goto <D.28433>;
      <D.28432>:
      // predicted unlikely by continue predictor.
      goto <D.23310>;
      <D.28433>:
      <D.28390>:
      D.28382 = field->type;
      D.28434 = D.28382->type;
      D.28435 = (int) D.28434;
      switch (D.28435) <default: <D.23338>, case 2: <D.23322>, case 3: <D.23326>, case 4: <D.23321>, case 5: <D.23320>, case 6: <D.23325>, case 7: <D.23324>, case 8: <D.23328>, case 9: <D.23327>, case 10: <D.23330>, case 11: <D.23329>, case 12: <D.23331>, case 13: <D.23332>, case 14: <D.23333>>
      <D.23320>:
      <D.23321>:
      <D.23322>:
      D.28436 = field->offset;
      D.28437 = (sizetype) D.28436;
      D.28438 = this + D.28437;
      D.28439 = *D.28438;
      D.28436 = field->offset;
      D.28437 = (sizetype) D.28436;
      D.28440 = that + D.28437;
      D.28441 = *D.28440;
      if (D.28439 != D.28441) goto <D.28442>; else goto <D.28443>;
      <D.28442>:
      D.28365 = 0;
      return D.28365;
      <D.28443>:
      goto <D.23323>;
      <D.23324>:
      <D.23325>:
      <D.23326>:
      D.28436 = field->offset;
      D.28437 = (sizetype) D.28436;
      D.28444 = this + D.28437;
      D.28445 = *D.28444;
      D.28436 = field->offset;
      D.28437 = (sizetype) D.28436;
      D.28446 = that + D.28437;
      D.28447 = *D.28446;
      if (D.28445 != D.28447) goto <D.28448>; else goto <D.28449>;
      <D.28448>:
      D.28365 = 0;
      return D.28365;
      <D.28449>:
      goto <D.23323>;
      <D.23327>:
      <D.23328>:
      D.28436 = field->offset;
      D.28437 = (sizetype) D.28436;
      D.28450 = this + D.28437;
      D.28451 = *D.28450;
      D.28436 = field->offset;
      D.28437 = (sizetype) D.28436;
      D.28452 = that + D.28437;
      D.28453 = *D.28452;
      if (D.28451 != D.28453) goto <D.28454>; else goto <D.28455>;
      <D.28454>:
      D.28365 = 0;
      return D.28365;
      <D.28455>:
      goto <D.23323>;
      <D.23329>:
      <D.23330>:
      D.28436 = field->offset;
      D.28437 = (sizetype) D.28436;
      D.28456 = this + D.28437;
      D.28457 = *D.28456;
      D.28436 = field->offset;
      D.28437 = (sizetype) D.28436;
      D.28458 = that + D.28437;
      D.28459 = *D.28458;
      if (D.28457 != D.28459) goto <D.28460>; else goto <D.28461>;
      <D.28460>:
      D.28365 = 0;
      return D.28365;
      <D.28461>:
      goto <D.23323>;
      <D.23331>:
      D.28436 = field->offset;
      D.28437 = (sizetype) D.28436;
      D.28462 = this + D.28437;
      D.28463 = *D.28462;
      D.28436 = field->offset;
      D.28437 = (sizetype) D.28436;
      D.28464 = that + D.28437;
      D.28465 = *D.28464;
      if (D.28463 != D.28465) goto <D.28466>; else goto <D.28467>;
      <D.28466>:
      D.28365 = 0;
      return D.28365;
      <D.28467>:
      goto <D.23323>;
      <D.23332>:
      D.28436 = field->offset;
      D.28437 = (sizetype) D.28436;
      D.28468 = this + D.28437;
      D.28469 = *D.28468;
      D.28436 = field->offset;
      D.28437 = (sizetype) D.28436;
      D.28470 = that + D.28437;
      D.28471 = *D.28470;
      if (D.28469 != D.28471) goto <D.28472>; else goto <D.28473>;
      <D.28472>:
      D.28365 = 0;
      return D.28365;
      <D.28473>:
      goto <D.23323>;
      <D.23333>:
      {
        struct MonoString * s1;
        struct MonoString * s2;
        guint32 s1len;
        guint32 s2len;

        D.28436 = field->offset;
        D.28437 = (sizetype) D.28436;
        D.28474 = this + D.28437;
        s1 = *D.28474;
        D.28436 = field->offset;
        D.28437 = (sizetype) D.28436;
        D.28475 = that + D.28437;
        s2 = *D.28475;
        if (s1 == s2) goto <D.23323>; else goto <D.28476>;
        <D.28476>:
        D.28477 = s1 == 0B;
        D.28478 = s2 == 0B;
        D.28479 = D.28477 | D.28478;
        if (D.28479 != 0) goto <D.28480>; else goto <D.28481>;
        <D.28480>:
        D.28365 = 0;
        return D.28365;
        <D.28481>:
        D.28482 = mono_string_length (s1);
        s1len = (guint32) D.28482;
        D.28483 = mono_string_length (s2);
        s2len = (guint32) D.28483;
        if (s1len != s2len) goto <D.28484>; else goto <D.28485>;
        <D.28484>:
        D.28365 = 0;
        return D.28365;
        <D.28485>:
        D.28486 = mono_string_chars (s1);
        D.28487 = mono_string_chars (s2);
        D.28488 = s1len * 2;
        D.28489 = memcmp (D.28486, D.28487, D.28488);
        if (D.28489 != 0) goto <D.28490>; else goto <D.28491>;
        <D.28490>:
        D.28365 = 0;
        return D.28365;
        <D.28491>:
        goto <D.23323>;
      }
      <D.23338>:
      if (values == 0B) goto <D.28492>; else goto <D.28493>;
      <D.28492>:
      D.28494 = mono_class_num_fields (klass);
      D.28495 = (unsigned int) D.28494;
      D.28496 = D.28495 * 8;
      values = __builtin_alloca (D.28496);
      <D.28493>:
      D.28361 = this->vtable;
      D.28497 = D.28361->domain;
      o = mono_field_get_value_object (D.28497, field, this);
      count.37 = count;
      count = count.37 + 1;
      count.38 = (unsigned int) count.37;
      D.28500 = count.38 * 4;
      D.28501 = values + D.28500;
      *D.28501 = o;
      D.28361 = this->vtable;
      D.28497 = D.28361->domain;
      o = mono_field_get_value_object (D.28497, field, that);
      count.39 = count;
      count = count.39 + 1;
      count.40 = (unsigned int) count.39;
      D.28504 = count.40 * 4;
      D.28505 = values + D.28504;
      *D.28505 = o;
      <D.23323>:
      D.28366 = BIT_FIELD_REF <*klass, 8, 160>;
      D.28367 = D.28366 & 16;
      if (D.28367 != 0) goto <D.23339>; else goto <D.28506>;
      <D.28506>:
      <D.23310>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.23340>; else goto <D.23339>;
      <D.23339>:
      if (values != 0B) goto <D.28507>; else goto <D.28508>;
      <D.28507>:
      {
        int i;

        D.28509 = mono_domain_get ();
        D.28510 = mono_defaults.object_class;
        count.41 = (unsigned int) count;
        D.28512 = mono_array_new (D.28509, D.28510, count.41);
        mono_gc_wbarrier_generic_store (fields, D.28512);
        i = 0;
        goto <D.23344>;
        <D.23343>:
        {
          void * * __p;

          D.28513 = *fields;
          D.28514 = &D.28513->vector;
          i.42 = (unsigned int) i;
          D.28516 = i.42 * 4;
          __p = D.28514 + D.28516;
          D.28513 = *fields;
          i.42 = (unsigned int) i;
          D.28516 = i.42 * 4;
          D.28517 = values + D.28516;
          D.28518 = *D.28517;
          mono_gc_wbarrier_set_arrayref (D.28513, __p, D.28518);
        }
        i = i + 1;
        <D.23344>:
        if (i < count) goto <D.23343>; else goto <D.23345>;
        <D.23345>:
        D.28365 = 0;
        return D.28365;
      }
      <D.28508>:
      D.28365 = 1;
      return D.28365;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


mono_TypedReference_ToObjectInternal (struct MonoType * type, void * value, struct MonoClass * klass)
{
  int D.28521;
  struct MonoObject * D.28524;
  struct MonoDomain * D.28525;

  D.28521 = mono_type_is_reference (type);
  if (D.28521 != 0) goto <D.28522>; else goto <D.28523>;
  <D.28522>:
  {
    struct MonoObject * * objp;

    objp = value;
    D.28524 = *objp;
    return D.28524;
  }
  <D.28523>:
  D.28525 = mono_domain_get ();
  D.28524 = mono_value_box (D.28525, klass, value);
  return D.28524;
}


mono_TypedReference_ToObject (struct MonoTypedRef tref)
{
  struct MonoType * D.28527;
  int D.28528;
  struct MonoObject * D.28531;
  struct MonoDomain * D.28532;
  struct MonoClass * D.28533;
  void * D.28534;

  D.28527 = tref.type;
  D.28528 = mono_type_is_reference (D.28527);
  if (D.28528 != 0) goto <D.28529>; else goto <D.28530>;
  <D.28529>:
  {
    struct MonoObject * * objp;

    objp = tref.value;
    D.28531 = *objp;
    return D.28531;
  }
  <D.28530>:
  D.28532 = mono_domain_get ();
  D.28533 = tref.klass;
  D.28534 = tref.value;
  D.28531 = mono_value_box (D.28532, D.28533, D.28534);
  return D.28531;
}


ves_icall_type_is_subtype_of (struct MonoReflectionType * type, struct MonoReflectionType * c, MonoBoolean check_interfaces)
{
  _Bool D.28536;
  long int D.28537;
  long int D.28538;
  struct MonoVTable * D.28541;
  guint32 D.28544;
  struct MonoType * D.28545;
  struct MonoType * D.28546;
  struct MonoClass * * D.28552;
  struct MonoClass * * D.28554;
  unsigned char D.28555;
  unsigned char D.28556;
  struct MonoClass * D.28559;
  _Bool D.28560;
  int D.28561;
  int D.28562;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoClass * klassc;

  D.28536 = type == 0B;
  D.28537 = (long int) D.28536;
  D.28538 = __builtin_expect (D.28537, 0);
  if (D.28538 != 0) goto <D.28539>; else goto <D.28540>;
  <D.28539>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1502, "type != NULL");
  <D.28540>:
  D.28541 = MEM[(struct MonoObject *)type].vtable;
  domain = D.28541->domain;
  if (c == 0B) goto <D.28542>; else goto <D.28543>;
  <D.28542>:
  D.28544 = 0;
  return D.28544;
  <D.28543>:
  D.28545 = type->type;
  klass = mono_class_from_mono_type (D.28545);
  D.28546 = c->type;
  klassc = mono_class_from_mono_type (D.28546);
  if (check_interfaces != 0) goto <D.28547>; else goto <D.28548>;
  <D.28547>:
  mono_class_init_or_throw (klass);
  mono_class_init_or_throw (klassc);
  goto <D.28549>;
  <D.28548>:
  D.28552 = klass->supertypes;
  if (D.28552 == 0B) goto <D.28550>; else goto <D.28553>;
  <D.28553>:
  D.28554 = klassc->supertypes;
  if (D.28554 == 0B) goto <D.28550>; else goto <D.28551>;
  <D.28550>:
  mono_class_setup_supertypes (klass);
  mono_class_setup_supertypes (klassc);
  <D.28551>:
  <D.28549>:
  D.28545 = type->type;
  D.28555 = BIT_FIELD_REF <*D.28545, 8, 56>;
  D.28556 = D.28555 & 64;
  if (D.28556 != 0) goto <D.28557>; else goto <D.28558>;
  <D.28557>:
  D.28559 = mono_defaults.object_class;
  D.28560 = D.28559 == klassc;
  D.28544 = (guint32) D.28560;
  return D.28544;
  <D.28558>:
  D.28561 = (int) check_interfaces;
  D.28562 = mono_class_is_subclass_of (klass, klassc, D.28561);
  D.28544 = (guint32) D.28562;
  return D.28544;
}


mono_class_init_or_throw (struct MonoClass * klass)
{
  int D.28564;
  struct MonoException * D.28567;

  D.28564 = mono_class_init (klass);
  if (D.28564 == 0) goto <D.28565>; else goto <D.28566>;
  <D.28565>:
  D.28567 = mono_class_get_exception_for_failure (klass);
  mono_raise_exception (D.28567);
  <D.28566>:
}


ves_icall_type_is_assignable_from (struct MonoReflectionType * type, struct MonoReflectionType * c)
{
  _Bool D.28568;
  long int D.28569;
  long int D.28570;
  struct MonoVTable * D.28573;
  struct MonoType * D.28574;
  struct MonoType * D.28575;
  unsigned char D.28576;
  unsigned char D.28577;
  unsigned char D.28578;
  unsigned char D.28579;
  guint32 D.28582;
  unsigned char D.28583;
  int D.28586;
  int iftmp.43;
  int D.28592;
  int D.28594;
  int D.28595;
  unsigned char D.28597;
  _Bool D.28598;
  _Bool D.28599;
  _Bool D.28600;
  int iftmp.44;
  unsigned char D.28606;
  unsigned char D.28607;
  struct MonoGenericParam * D.28609;
  short unsigned int D.28610;
  struct MonoGenericParam * D.28611;
  short unsigned int D.28612;
  unsigned char D.28614;
  _Bool D.28615;
  _Bool D.28616;
  _Bool D.28617;
  _Bool D.28620;
  unsigned char D.28621;
  _Bool D.28622;
  _Bool D.28623;
  _Bool D.28624;
  unsigned char D.28627;
  unsigned char D.28628;
  _Bool D.28631;
  unsigned char D.28632;
  unsigned char D.28633;
  unsigned char D.28634;
  _Bool D.28635;
  int D.28636;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoClass * klassc;

  D.28568 = type == 0B;
  D.28569 = (long int) D.28568;
  D.28570 = __builtin_expect (D.28569, 0);
  if (D.28570 != 0) goto <D.28571>; else goto <D.28572>;
  <D.28571>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1555, "type != NULL");
  <D.28572>:
  D.28573 = MEM[(struct MonoObject *)type].vtable;
  domain = D.28573->domain;
  D.28574 = type->type;
  klass = mono_class_from_mono_type (D.28574);
  D.28575 = c->type;
  klassc = mono_class_from_mono_type (D.28575);
  D.28574 = type->type;
  D.28576 = BIT_FIELD_REF <*D.28574, 8, 56>;
  D.28575 = c->type;
  D.28577 = BIT_FIELD_REF <*D.28575, 8, 56>;
  D.28578 = D.28576 ^ D.28577;
  D.28579 = D.28578 & 64;
  if (D.28579 != 0) goto <D.28580>; else goto <D.28581>;
  <D.28580>:
  D.28582 = 0;
  return D.28582;
  <D.28581>:
  D.28574 = type->type;
  D.28576 = BIT_FIELD_REF <*D.28574, 8, 56>;
  D.28583 = D.28576 & 64;
  if (D.28583 != 0) goto <D.28584>; else goto <D.28585>;
  <D.28584>:
  {
    struct MonoType * t;
    struct MonoType * ot;

    D.28574 = type->type;
    t = mono_type_get_underlying_type_ignore_byref (D.28574);
    D.28575 = c->type;
    ot = mono_type_get_underlying_type_ignore_byref (D.28575);
    klass = mono_class_from_mono_type (t);
    klassc = mono_class_from_mono_type (ot);
    D.28586 = mono_type_is_primitive (t);
    if (D.28586 != 0) goto <D.28587>; else goto <D.28588>;
    <D.28587>:
    D.28592 = mono_type_is_primitive (ot);
    if (D.28592 != 0) goto <D.28593>; else goto <D.28590>;
    <D.28593>:
    D.28594 = klass->instance_size;
    D.28595 = klassc->instance_size;
    if (D.28594 == D.28595) goto <D.28596>; else goto <D.28590>;
    <D.28596>:
    iftmp.43 = 1;
    goto <D.28591>;
    <D.28590>:
    iftmp.43 = 0;
    <D.28591>:
    D.28582 = (guint32) iftmp.43;
    return D.28582;
    <D.28588>:
    D.28597 = t->type;
    D.28598 = D.28597 == 19;
    D.28599 = D.28597 == 30;
    D.28600 = D.28598 | D.28599;
    if (D.28600 != 0) goto <D.28601>; else goto <D.28602>;
    <D.28601>:
    D.28606 = t->type;
    D.28607 = ot->type;
    if (D.28606 == D.28607) goto <D.28608>; else goto <D.28604>;
    <D.28608>:
    D.28609 = t->data.generic_param;
    D.28610 = D.28609->num;
    D.28611 = ot->data.generic_param;
    D.28612 = D.28611->num;
    if (D.28610 == D.28612) goto <D.28613>; else goto <D.28604>;
    <D.28613>:
    iftmp.44 = 1;
    goto <D.28605>;
    <D.28604>:
    iftmp.44 = 0;
    <D.28605>:
    D.28582 = (guint32) iftmp.44;
    return D.28582;
    <D.28602>:
    D.28614 = t->type;
    D.28615 = D.28614 == 15;
    D.28616 = D.28614 == 27;
    D.28617 = D.28615 | D.28616;
    if (D.28617 != 0) goto <D.28618>; else goto <D.28619>;
    <D.28618>:
    D.28606 = t->type;
    D.28607 = ot->type;
    D.28620 = D.28606 == D.28607;
    D.28582 = (guint32) D.28620;
    return D.28582;
    <D.28619>:
    D.28621 = ot->type;
    D.28622 = D.28621 == 19;
    D.28623 = D.28621 == 30;
    D.28624 = D.28622 | D.28623;
    if (D.28624 != 0) goto <D.28625>; else goto <D.28626>;
    <D.28625>:
    D.28582 = 0;
    return D.28582;
    <D.28626>:
    D.28627 = BIT_FIELD_REF <*klass, 8, 160>;
    D.28628 = D.28627 & 8;
    if (D.28628 != 0) goto <D.28629>; else goto <D.28630>;
    <D.28629>:
    D.28631 = klass == klassc;
    D.28582 = (guint32) D.28631;
    return D.28582;
    <D.28630>:
    D.28627 = BIT_FIELD_REF <*klass, 8, 160>;
    D.28632 = BIT_FIELD_REF <*klassc, 8, 160>;
    D.28633 = D.28627 ^ D.28632;
    D.28634 = D.28633 & 8;
    D.28635 = D.28634 == 0;
    D.28582 = (guint32) D.28635;
    return D.28582;
  }
  <D.28585>:
  D.28636 = mono_class_is_assignable_from (klass, klassc);
  D.28582 = (guint32) D.28636;
  return D.28582;
}


mono_type_get_underlying_type_ignore_byref (struct MonoType * type)
{
  unsigned char D.28638;
  struct MonoClass * D.28641;
  unsigned char D.28642;
  unsigned char D.28643;
  struct MonoType * D.28646;
  struct MonoGenericClass * D.28649;
  struct MonoClass * D.28650;
  unsigned char D.28651;
  unsigned char D.28652;

  D.28638 = type->type;
  if (D.28638 == 17) goto <D.28639>; else goto <D.28640>;
  <D.28639>:
  D.28641 = type->data.klass;
  D.28642 = BIT_FIELD_REF <*D.28641, 8, 160>;
  D.28643 = D.28642 & 16;
  if (D.28643 != 0) goto <D.28644>; else goto <D.28645>;
  <D.28644>:
  D.28641 = type->data.klass;
  D.28646 = mono_class_enum_basetype (D.28641);
  return D.28646;
  <D.28645>:
  <D.28640>:
  D.28638 = type->type;
  if (D.28638 == 21) goto <D.28647>; else goto <D.28648>;
  <D.28647>:
  D.28649 = type->data.generic_class;
  D.28650 = D.28649->container_class;
  D.28651 = BIT_FIELD_REF <*D.28650, 8, 160>;
  D.28652 = D.28651 & 16;
  if (D.28652 != 0) goto <D.28653>; else goto <D.28654>;
  <D.28653>:
  D.28649 = type->data.generic_class;
  D.28650 = D.28649->container_class;
  D.28646 = mono_class_enum_basetype (D.28650);
  return D.28646;
  <D.28654>:
  <D.28648>:
  D.28646 = type;
  return D.28646;
}


mono_type_is_primitive (struct MonoType * type)
{
  gboolean D.28656;
  int iftmp.45;
  unsigned char D.28661;
  unsigned char D.28662;
  _Bool D.28663;
  _Bool D.28664;
  _Bool D.28665;
  unsigned char D.28667;

  D.28661 = type->type;
  D.28662 = D.28661 + 254;
  D.28663 = D.28662 <= 11;
  D.28664 = D.28661 == 24;
  D.28665 = D.28663 | D.28664;
  if (D.28665 != 0) goto <D.28658>; else goto <D.28666>;
  <D.28666>:
  D.28667 = type->type;
  if (D.28667 == 25) goto <D.28658>; else goto <D.28659>;
  <D.28658>:
  iftmp.45 = 1;
  goto <D.28660>;
  <D.28659>:
  iftmp.45 = 0;
  <D.28660>:
  D.28656 = iftmp.45;
  return D.28656;
}


ves_icall_Type_make_byref_type (struct MonoReflectionType * type)
{
  struct MonoType * D.28669;
  struct MonoReflectionType * D.28670;
  struct MonoVTable * D.28671;
  struct MonoDomain * D.28672;
  struct MonoType * D.28673;
  struct MonoClass * klass;

  D.28669 = type->type;
  klass = mono_class_from_mono_type (D.28669);
  mono_class_init_or_throw (klass);
  check_for_invalid_type (klass);
  D.28671 = MEM[(struct MonoObject *)type].vtable;
  D.28672 = D.28671->domain;
  D.28673 = &klass->this_arg;
  D.28670 = mono_type_get_object (D.28672, D.28673);
  return D.28670;
}


check_for_invalid_type (struct MonoClass * klass)
{
  unsigned char D.28675;
  struct MonoDomain * D.28678;
  struct MonoException * D.28679;
  char * name;
  struct MonoString * str;

  D.28675 = klass->byval_arg.type;
  if (D.28675 != 22) goto <D.28676>; else goto <D.28677>;
  <D.28676>:
  return;
  <D.28677>:
  name = mono_type_get_full_name (klass);
  D.28678 = mono_domain_get ();
  str = mono_string_new (D.28678, name);
  monoeg_g_free (name);
  D.28679 = mono_get_exception_type_load (str, 0B);
  mono_raise_exception (D.28679);
}


ves_icall_Type_make_array_type (struct MonoReflectionType * type, int rank)
{
  struct MonoType * D.28681;
  unsigned int rank.46;
  struct MonoReflectionType * D.28686;
  struct MonoVTable * D.28687;
  struct MonoDomain * D.28688;
  struct MonoType * D.28689;
  struct MonoClass * klass;
  struct MonoClass * aklass;

  D.28681 = type->type;
  klass = mono_class_from_mono_type (D.28681);
  check_for_invalid_type (klass);
  if (rank == 0) goto <D.28682>; else goto <D.28683>;
  <D.28682>:
  aklass = mono_array_class_get (klass, 1);
  goto <D.28684>;
  <D.28683>:
  rank.46 = (unsigned int) rank;
  aklass = mono_bounded_array_class_get (klass, rank.46, 1);
  <D.28684>:
  D.28687 = MEM[(struct MonoObject *)type].vtable;
  D.28688 = D.28687->domain;
  D.28689 = &aklass->byval_arg;
  D.28686 = mono_type_get_object (D.28688, D.28689);
  return D.28686;
}


ves_icall_type_from_name (struct MonoString * name, MonoBoolean throwOnError, MonoBoolean ignoreCase)
{
  struct MonoReflectionType * D.28697;
  char * str;
  struct MonoReflectionType * type;

  str = mono_string_to_utf8 (name);
  type = type_from_name (str, ignoreCase);
  monoeg_g_free (str);
  if (type == 0B) goto <D.28691>; else goto <D.28692>;
  <D.28691>:
  {
    struct MonoException * e;

    e = 0B;
    if (throwOnError != 0) goto <D.28693>; else goto <D.28694>;
    <D.28693>:
    e = mono_get_exception_type_load (name, 0B);
    <D.28694>:
    mono_loader_clear_error ();
    if (e != 0B) goto <D.28695>; else goto <D.28696>;
    <D.28695>:
    mono_raise_exception (e);
    <D.28696>:
  }
  <D.28692>:
  D.28697 = type;
  return D.28697;
}


type_from_name (const char * str, MonoBoolean ignoreCase)
{
  int D.28699;
  struct MonoReflectionType * D.28702;
  const char * D.28703;
  struct MonoMethod * dest.47;
  struct MonoClass * D.28712;
  struct MonoImage * D.28713;
  struct MonoImage * D.28717;
  int D.28718;
  _Bool D.28723;
  _Bool D.28724;
  _Bool D.28725;
  int type_resolve.48;
  struct MonoDomain * D.28733;
  struct MonoType * type;
  struct MonoAssembly * assembly;
  struct MonoTypeNameParse info;
  char * temp_str;
  gboolean type_resolve;

  try
    {
      type = 0B;
      assembly = 0B;
      temp_str = monoeg_strdup (str);
      type_resolve = 0;
      D.28699 = mono_reflection_parse_type (temp_str, &info);
      if (D.28699 == 0) goto <D.28700>; else goto <D.28701>;
      <D.28700>:
      mono_reflection_free_type_info (&info);
      monoeg_g_free (temp_str);
      D.28702 = 0B;
      return D.28702;
      <D.28701>:
      D.28703 = info.assembly.name;
      if (D.28703 != 0B) goto <D.28704>; else goto <D.28705>;
      <D.28704>:
      assembly = mono_assembly_load (&info.assembly, 0B, 0B);
      goto <D.28706>;
      <D.28705>:
      {
        struct MonoMethod * m;
        struct MonoMethod * dest;

        try
          {
            m = mono_method_get_last_managed ();
            dest = m;
            mono_stack_walk_no_il (get_caller_no_reflection, &dest);
            dest.47 = dest;
            if (dest.47 == 0B) goto <D.28708>; else goto <D.28709>;
            <D.28708>:
            dest = m;
            <D.28709>:
            dest.47 = dest;
            if (dest.47 != 0B) goto <D.28710>; else goto <D.28711>;
            <D.28710>:
            dest.47 = dest;
            D.28712 = dest.47->klass;
            D.28713 = D.28712->image;
            assembly = D.28713->assembly;
            type_resolve = 1;
            goto <D.28714>;
            <D.28711>:
            monoeg_g_log (0B, 16, "icall.c:1303:");
            <D.28714>:
          }
        finally
          {
            dest = {CLOBBER};
          }
      }
      <D.28706>:
      if (assembly != 0B) goto <D.28715>; else goto <D.28716>;
      <D.28715>:
      D.28717 = assembly->image;
      D.28718 = (int) ignoreCase;
      type = mono_reflection_get_type (D.28717, &info, D.28718, &type_resolve);
      <D.28716>:
      D.28703 = info.assembly.name;
      if (D.28703 == 0B) goto <D.28719>; else goto <D.28720>;
      <D.28719>:
      if (type == 0B) goto <D.28721>; else goto <D.28722>;
      <D.28721>:
      D.28718 = (int) ignoreCase;
      type = mono_reflection_get_type (0B, &info, D.28718, &type_resolve);
      <D.28722>:
      <D.28720>:
      D.28723 = assembly != 0B;
      D.28724 = type == 0B;
      D.28725 = D.28723 & D.28724;
      if (D.28725 != 0) goto <D.28726>; else goto <D.28727>;
      <D.28726>:
      type_resolve.48 = type_resolve;
      if (type_resolve.48 != 0) goto <D.28729>; else goto <D.28730>;
      <D.28729>:
      type_resolve = 0;
      D.28717 = assembly->image;
      D.28718 = (int) ignoreCase;
      type = mono_reflection_get_type (D.28717, &info, D.28718, &type_resolve);
      <D.28730>:
      <D.28727>:
      mono_reflection_free_type_info (&info);
      monoeg_g_free (temp_str);
      if (type == 0B) goto <D.28731>; else goto <D.28732>;
      <D.28731>:
      D.28702 = 0B;
      return D.28702;
      <D.28732>:
      D.28733 = mono_domain_get ();
      D.28702 = mono_type_get_object (D.28733, type);
      return D.28702;
    }
  finally
    {
      info = {CLOBBER};
      type_resolve = {CLOBBER};
    }
}


get_caller_no_reflection (struct MonoMethod * m, gint32 no, gint32 ilo, gboolean managed, void * data)
{
  gboolean D.28738;
  unsigned char D.28739;
  unsigned char D.28740;
  struct MonoClass * D.28743;
  struct MonoImage * D.28744;
  struct MonoImage * D.28745;
  int D.23418;
  int iftmp.49;
  int D.23417;
  const char[18] * D.28751;
  unsigned char D.28752;
  int D.28753;
  unsigned char D.28754;
  int D.28755;
  _Bool D.28756;
  _Bool D.28757;
  _Bool D.28758;
  const unsigned char * D.28761;
  unsigned char D.28762;
  int D.28763;
  const unsigned char * D.28764;
  unsigned char D.28765;
  int D.28766;
  _Bool D.28767;
  _Bool D.28768;
  const unsigned char * D.28771;
  unsigned char D.28772;
  int D.28773;
  const unsigned char * D.28774;
  unsigned char D.28775;
  int D.28776;
  _Bool D.28777;
  _Bool D.28778;
  const unsigned char * D.28781;
  unsigned char D.28782;
  int D.28783;
  const unsigned char * D.28784;
  unsigned char D.28785;
  int D.28786;
  const char * D.28788;
  struct MonoMethod * D.28791;
  struct MonoMethod * * dest;

  dest = data;
  if (managed == 0) goto <D.28736>; else goto <D.28737>;
  <D.28736>:
  D.28738 = 0;
  return D.28738;
  <D.28737>:
  D.28739 = BIT_FIELD_REF <*m, 8, 160>;
  D.28740 = D.28739 & 124;
  if (D.28740 != 0) goto <D.28741>; else goto <D.28742>;
  <D.28741>:
  D.28738 = 0;
  return D.28738;
  <D.28742>:
  D.28743 = m->klass;
  D.28744 = D.28743->image;
  D.28745 = mono_defaults.corlib;
  if (D.28744 == D.28745) goto <D.28746>; else goto <D.28747>;
  <D.28746>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 17;
    if (__s2_len <= 3) goto <D.28749>; else goto <D.28750>;
    <D.28749>:
    {
      const unsigned char * __s2;
      int __result;

      D.28743 = m->klass;
      __s2 = D.28743->name_space;
      D.28751 = "System.Reflection";
      D.28752 = MEM[(const unsigned char *)D.28751];
      D.28753 = (int) D.28752;
      D.28754 = *__s2;
      D.28755 = (int) D.28754;
      __result = D.28753 - D.28755;
      {
        D.28756 = __s2_len != 0;
        D.28757 = __result == 0;
        D.28758 = D.28756 & D.28757;
        if (D.28758 != 0) goto <D.28759>; else goto <D.28760>;
        <D.28759>:
        D.28761 = &MEM[(void *)"System.Reflection" + 1B];
        D.28762 = *D.28761;
        D.28763 = (int) D.28762;
        D.28764 = __s2 + 1;
        D.28765 = *D.28764;
        D.28766 = (int) D.28765;
        __result = D.28763 - D.28766;
        D.28767 = __s2_len > 1;
        D.28757 = __result == 0;
        D.28768 = D.28767 & D.28757;
        if (D.28768 != 0) goto <D.28769>; else goto <D.28770>;
        <D.28769>:
        D.28771 = &MEM[(void *)"System.Reflection" + 2B];
        D.28772 = *D.28771;
        D.28773 = (int) D.28772;
        D.28774 = __s2 + 2;
        D.28775 = *D.28774;
        D.28776 = (int) D.28775;
        __result = D.28773 - D.28776;
        D.28777 = __s2_len > 2;
        D.28757 = __result == 0;
        D.28778 = D.28777 & D.28757;
        if (D.28778 != 0) goto <D.28779>; else goto <D.28780>;
        <D.28779>:
        D.28781 = &MEM[(void *)"System.Reflection" + 3B];
        D.28782 = *D.28781;
        D.28783 = (int) D.28782;
        D.28784 = __s2 + 3;
        D.28785 = *D.28784;
        D.28786 = (int) D.28785;
        __result = D.28783 - D.28786;
        <D.28780>:
        <D.28770>:
        <D.28760>:
      }
      D.23417 = __result;
    }
    iftmp.49 = -D.23417;
    goto <D.28787>;
    <D.28750>:
    D.28743 = m->klass;
    D.28788 = D.28743->name_space;
    iftmp.49 = __builtin_strcmp (D.28788, "System.Reflection");
    <D.28787>:
    D.23418 = iftmp.49;
  }
  if (D.23418 == 0) goto <D.28789>; else goto <D.28790>;
  <D.28789>:
  D.28738 = 0;
  return D.28738;
  <D.28790>:
  <D.28747>:
  D.28791 = *dest;
  if (D.28791 == m) goto <D.28792>; else goto <D.28793>;
  <D.28792>:
  *dest = 0B;
  D.28738 = 0;
  return D.28738;
  <D.28793>:
  D.28791 = *dest;
  if (D.28791 == 0B) goto <D.28794>; else goto <D.28795>;
  <D.28794>:
  *dest = m;
  D.28738 = 1;
  return D.28738;
  <D.28795>:
  D.28738 = 0;
  return D.28738;
}


ves_icall_type_from_handle (struct MonoType * handle)
{
  struct MonoReflectionType * D.28797;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.28797 = mono_type_get_object (domain, handle);
  return D.28797;
}


ves_icall_Type_get_IsGenericTypeDefinition (struct MonoReflectionType * type)
{
  struct MonoVTable * D.28803;
  struct MonoClass * D.28804;
  struct MonoImage * D.28805;
  struct MonoImage * D.28806;
  struct MonoType * D.28808;
  gboolean D.28809;
  unsigned char D.28810;
  unsigned char D.28811;
  struct MonoGenericContainer * D.28814;
  _Bool D.28815;
  struct MonoClass * klass;

  if (type != 0B) goto <D.28801>; else goto <D.28802>;
  <D.28801>:
  D.28803 = MEM[(struct MonoObject *)type].vtable;
  D.28804 = D.28803->klass;
  D.28805 = D.28804->image;
  D.28806 = mono_defaults.corlib;
  if (D.28805 != D.28806) goto <D.28799>; else goto <D.28807>;
  <D.28807>:
  D.28808 = type->type;
  if (D.28808 == 0B) goto <D.28799>; else goto <D.28800>;
  <D.28799>:
  D.28809 = 0;
  return D.28809;
  <D.28800>:
  <D.28802>:
  D.28808 = type->type;
  D.28810 = BIT_FIELD_REF <*D.28808, 8, 56>;
  D.28811 = D.28810 & 64;
  if (D.28811 != 0) goto <D.28812>; else goto <D.28813>;
  <D.28812>:
  D.28809 = 0;
  return D.28809;
  <D.28813>:
  D.28808 = type->type;
  klass = mono_class_from_mono_type (D.28808);
  D.28814 = klass->generic_container;
  D.28815 = D.28814 != 0B;
  D.28809 = (gboolean) D.28815;
  return D.28809;
}


ves_icall_Type_get_IsGenericType (struct MonoReflectionType * type)
{
  struct MonoVTable * D.28821;
  struct MonoClass * D.28822;
  struct MonoImage * D.28823;
  struct MonoImage * D.28824;
  struct MonoType * D.28826;
  gboolean D.28827;
  unsigned char D.28828;
  unsigned char D.28829;
  int iftmp.50;
  struct MonoGenericClass * D.28836;
  struct MonoGenericContainer * D.28838;
  struct MonoClass * klass;

  if (type != 0B) goto <D.28819>; else goto <D.28820>;
  <D.28819>:
  D.28821 = MEM[(struct MonoObject *)type].vtable;
  D.28822 = D.28821->klass;
  D.28823 = D.28822->image;
  D.28824 = mono_defaults.corlib;
  if (D.28823 != D.28824) goto <D.28817>; else goto <D.28825>;
  <D.28825>:
  D.28826 = type->type;
  if (D.28826 == 0B) goto <D.28817>; else goto <D.28818>;
  <D.28817>:
  D.28827 = 0;
  return D.28827;
  <D.28818>:
  <D.28820>:
  D.28826 = type->type;
  D.28828 = BIT_FIELD_REF <*D.28826, 8, 56>;
  D.28829 = D.28828 & 64;
  if (D.28829 != 0) goto <D.28830>; else goto <D.28831>;
  <D.28830>:
  D.28827 = 0;
  return D.28827;
  <D.28831>:
  D.28826 = type->type;
  klass = mono_class_from_mono_type (D.28826);
  D.28836 = klass->generic_class;
  if (D.28836 != 0B) goto <D.28833>; else goto <D.28837>;
  <D.28837>:
  D.28838 = klass->generic_container;
  if (D.28838 != 0B) goto <D.28833>; else goto <D.28834>;
  <D.28833>:
  iftmp.50 = 1;
  goto <D.28835>;
  <D.28834>:
  iftmp.50 = 0;
  <D.28835>:
  D.28827 = iftmp.50;
  return D.28827;
}


ves_icall_Type_get_IsGenericInstance (struct MonoReflectionType * type)
{
  struct MonoType * D.28840;
  unsigned char D.28841;
  unsigned char D.28842;
  gboolean D.28845;
  struct MonoGenericClass * D.28846;
  _Bool D.28847;
  struct MonoClass * klass;

  D.28840 = type->type;
  D.28841 = BIT_FIELD_REF <*D.28840, 8, 56>;
  D.28842 = D.28841 & 64;
  if (D.28842 != 0) goto <D.28843>; else goto <D.28844>;
  <D.28843>:
  D.28845 = 0;
  return D.28845;
  <D.28844>:
  D.28840 = type->type;
  klass = mono_class_from_mono_type (D.28840);
  D.28846 = klass->generic_class;
  D.28847 = D.28846 != 0B;
  D.28845 = (gboolean) D.28847;
  return D.28845;
}


ves_icall_Type_MakePointerType (struct MonoReflectionType * type)
{
  struct MonoType * D.28849;
  struct MonoReflectionType * D.28850;
  struct MonoVTable * D.28851;
  struct MonoDomain * D.28852;
  struct MonoType * D.28853;
  struct MonoClass * klass;
  struct MonoClass * pklass;

  D.28849 = type->type;
  klass = mono_class_from_mono_type (D.28849);
  mono_class_init_or_throw (klass);
  check_for_invalid_type (klass);
  D.28849 = type->type;
  pklass = mono_ptr_class_get (D.28849);
  D.28851 = MEM[(struct MonoObject *)type].vtable;
  D.28852 = D.28851->domain;
  D.28853 = &pklass->byval_arg;
  D.28850 = mono_type_get_object (D.28852, D.28853);
  return D.28850;
}


ves_icall_Type_MakeGenericType (struct MonoReflectionType * type, struct MonoArray * type_array)
{
  int iftmp.51;
  struct MonoVTable * D.28860;
  struct MonoClass * D.28861;
  struct MonoImage * D.28862;
  struct MonoImage * D.28863;
  struct MonoType * D.28865;
  _Bool D.28866;
  long int D.28867;
  long int D.28868;
  struct MonoClass * D.28871;
  unsigned int D.28872;
  unsigned int count.52;
  unsigned int D.28874;
  unsigned int i.53;
  char * D.28876;
  unsigned int i.54;
  unsigned int D.28878;
  struct MonoType * * D.28879;
  struct MonoType * D.28880;
  struct MonoReflectionType * D.28883;
  struct MonoGenericClass * D.28884;
  int D.28887;
  struct MonoException * D.28890;
  struct MonoDomain * D.28891;
  struct MonoClass * class;
  struct MonoType * geninst;
  struct MonoType * * types;
  int i;
  int count;

  if (type != 0B) goto <D.28859>; else goto <D.28856>;
  <D.28859>:
  D.28860 = MEM[(struct MonoObject *)type].vtable;
  D.28861 = D.28860->klass;
  D.28862 = D.28861->image;
  D.28863 = mono_defaults.corlib;
  if (D.28862 != D.28863) goto <D.28857>; else goto <D.28864>;
  <D.28864>:
  D.28865 = type->type;
  if (D.28865 == 0B) goto <D.28857>; else goto <D.28856>;
  <D.28857>:
  iftmp.51 = 1;
  goto <D.28858>;
  <D.28856>:
  iftmp.51 = 0;
  <D.28858>:
  D.28866 = iftmp.51 != 0;
  D.28867 = (long int) D.28866;
  D.28868 = __builtin_expect (D.28867, 0);
  if (D.28868 != 0) goto <D.28869>; else goto <D.28870>;
  <D.28869>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2404, "IS_MONOTYPE (type)");
  <D.28870>:
  D.28865 = type->type;
  D.28871 = mono_class_from_mono_type (D.28865);
  mono_class_init_or_throw (D.28871);
  D.28872 = mono_array_length (type_array);
  count = (int) D.28872;
  count.52 = (unsigned int) count;
  D.28874 = count.52 * 4;
  types = monoeg_malloc0 (D.28874);
  i = 0;
  goto <D.23919>;
  <D.23918>:
  {
    struct MonoReflectionType * t;

    i.53 = (unsigned int) i;
    D.28876 = mono_array_addr_with_size (type_array, 4, i.53);
    t = MEM[(void * *)D.28876];
    i.54 = (unsigned int) i;
    D.28878 = i.54 * 4;
    D.28879 = types + D.28878;
    D.28880 = t->type;
    *D.28879 = D.28880;
  }
  i = i + 1;
  <D.23919>:
  if (i < count) goto <D.23918>; else goto <D.23920>;
  <D.23920>:
  geninst = mono_reflection_bind_generic_parameters (type, count, types);
  monoeg_g_free (types);
  if (geninst == 0B) goto <D.28881>; else goto <D.28882>;
  <D.28881>:
  D.28883 = 0B;
  return D.28883;
  <D.28882>:
  class = mono_class_from_mono_type (geninst);
  D.28884 = class->generic_class;
  if (D.28884 != 0B) goto <D.28885>; else goto <D.28886>;
  <D.28885>:
  D.28887 = mono_verifier_class_is_valid_generic_instantiation (class);
  if (D.28887 == 0) goto <D.28888>; else goto <D.28889>;
  <D.28888>:
  D.28890 = mono_get_exception_argument ("typeArguments", "Invalid generic arguments");
  mono_raise_exception (D.28890);
  <D.28889>:
  <D.28886>:
  D.28860 = MEM[(struct MonoObject *)type].vtable;
  D.28891 = D.28860->domain;
  D.28883 = mono_type_get_object (D.28891, geninst);
  return D.28883;
}


ves_icall_type_IsInstanceOfType (struct MonoReflectionType * type, struct MonoObject * obj)
{
  struct MonoType * D.28893;
  guint32 D.28894;
  struct MonoObject * D.28895;
  _Bool D.28896;
  struct MonoClass * klass;

  D.28893 = type->type;
  klass = mono_class_from_mono_type (D.28893);
  mono_class_init_or_throw (klass);
  D.28895 = mono_object_isinst (obj, klass);
  D.28896 = D.28895 != 0B;
  D.28894 = (guint32) D.28896;
  return D.28894;
}


ves_icall_Type_IsArrayImpl (struct MonoReflectionType * t)
{
  int iftmp.55;
  unsigned char D.28901;
  unsigned char D.28902;
  unsigned char D.28904;
  _Bool D.28905;
  _Bool D.28906;
  _Bool D.28907;
  MonoBoolean D.28909;
  struct MonoType * type;
  MonoBoolean res;

  type = t->type;
  D.28901 = BIT_FIELD_REF <*type, 8, 56>;
  D.28902 = D.28901 & 64;
  if (D.28902 == 0) goto <D.28903>; else goto <D.28899>;
  <D.28903>:
  D.28904 = type->type;
  D.28905 = D.28904 == 20;
  D.28906 = D.28904 == 29;
  D.28907 = D.28905 | D.28906;
  if (D.28907 != 0) goto <D.28908>; else goto <D.28899>;
  <D.28908>:
  iftmp.55 = 1;
  goto <D.28900>;
  <D.28899>:
  iftmp.55 = 0;
  <D.28900>:
  res = (MonoBoolean) iftmp.55;
  D.28909 = res;
  return D.28909;
}


ves_icall_type_GetTypeCodeInternal (struct MonoReflectionType * type)
{
  struct MonoType * D.28911;
  unsigned char D.28912;
  unsigned char D.28913;
  unsigned char D.28914;
  guint32 D.28917;
  unsigned char D.28918;
  unsigned char D.28919;
  struct MonoType * D.28922;
  unsigned char D.28923;
  struct MonoImage * D.28924;
  int D.28925;
  int D.23497;
  int iftmp.56;
  int D.23496;
  const char[7] * D.28931;
  unsigned char D.28932;
  int D.28933;
  unsigned char D.28934;
  int D.28935;
  _Bool D.28936;
  _Bool D.28937;
  _Bool D.28938;
  const unsigned char * D.28941;
  unsigned char D.28942;
  int D.28943;
  const unsigned char * D.28944;
  unsigned char D.28945;
  int D.28946;
  _Bool D.28947;
  _Bool D.28948;
  const unsigned char * D.28951;
  unsigned char D.28952;
  int D.28953;
  const unsigned char * D.28954;
  unsigned char D.28955;
  int D.28956;
  _Bool D.28957;
  _Bool D.28958;
  const unsigned char * D.28961;
  unsigned char D.28962;
  int D.28963;
  const unsigned char * D.28964;
  unsigned char D.28965;
  int D.28966;
  const char * D.28968;
  int D.23506;
  int iftmp.57;
  int D.23505;
  const char[8] * D.28974;
  unsigned char D.28975;
  int D.28976;
  unsigned char D.28977;
  int D.28978;
  _Bool D.28979;
  _Bool D.28980;
  _Bool D.28981;
  const unsigned char * D.28984;
  unsigned char D.28985;
  int D.28986;
  const unsigned char * D.28987;
  unsigned char D.28988;
  int D.28989;
  _Bool D.28990;
  _Bool D.28991;
  const unsigned char * D.28994;
  unsigned char D.28995;
  int D.28996;
  const unsigned char * D.28997;
  unsigned char D.28998;
  int D.28999;
  _Bool D.29000;
  _Bool D.29001;
  const unsigned char * D.29004;
  unsigned char D.29005;
  int D.29006;
  const unsigned char * D.29007;
  unsigned char D.29008;
  int D.29009;
  const char * D.29011;
  int D.23515;
  int iftmp.58;
  int D.23514;
  const char[9] * D.29017;
  unsigned char D.29018;
  int D.29019;
  unsigned char D.29020;
  int D.29021;
  _Bool D.29022;
  _Bool D.29023;
  _Bool D.29024;
  const unsigned char * D.29027;
  unsigned char D.29028;
  int D.29029;
  const unsigned char * D.29030;
  unsigned char D.29031;
  int D.29032;
  _Bool D.29033;
  _Bool D.29034;
  const unsigned char * D.29037;
  unsigned char D.29038;
  int D.29039;
  const unsigned char * D.29040;
  unsigned char D.29041;
  int D.29042;
  _Bool D.29043;
  _Bool D.29044;
  const unsigned char * D.29047;
  unsigned char D.29048;
  int D.29049;
  const unsigned char * D.29050;
  unsigned char D.29051;
  int D.29052;
  struct MonoImage * D.29056;
  struct MonoImage * D.29057;
  int D.23533;
  int iftmp.59;
  int D.23532;
  unsigned char D.29063;
  int D.29064;
  _Bool D.29065;
  _Bool D.29066;
  _Bool D.29067;
  const unsigned char * D.29070;
  unsigned char D.29071;
  int D.29072;
  _Bool D.29073;
  _Bool D.29074;
  const unsigned char * D.29077;
  unsigned char D.29078;
  int D.29079;
  _Bool D.29080;
  _Bool D.29081;
  const unsigned char * D.29084;
  unsigned char D.29085;
  int D.29086;
  const char * D.29088;
  int D.23542;
  int iftmp.60;
  int D.23541;
  const char[7] * D.29094;
  unsigned char D.29095;
  int D.29096;
  unsigned char D.29097;
  int D.29098;
  _Bool D.29099;
  _Bool D.29100;
  _Bool D.29101;
  const unsigned char * D.29104;
  unsigned char D.29105;
  int D.29106;
  const unsigned char * D.29107;
  unsigned char D.29108;
  int D.29109;
  _Bool D.29110;
  _Bool D.29111;
  const unsigned char * D.29114;
  unsigned char D.29115;
  int D.29116;
  const unsigned char * D.29117;
  unsigned char D.29118;
  int D.29119;
  _Bool D.29120;
  _Bool D.29121;
  const unsigned char * D.29124;
  unsigned char D.29125;
  int D.29126;
  const unsigned char * D.29127;
  unsigned char D.29128;
  int D.29129;
  const char * D.29131;
  int t;
  void handle_enum = <<< error >>>;

  D.28911 = type->type;
  D.28912 = D.28911->type;
  t = (int) D.28912;
  D.28911 = type->type;
  D.28913 = BIT_FIELD_REF <*D.28911, 8, 56>;
  D.28914 = D.28913 & 64;
  if (D.28914 != 0) goto <D.28915>; else goto <D.28916>;
  <D.28915>:
  D.28917 = 1;
  return D.28917;
  <D.28916>:
  handle_enum:
  switch (t) <default: <D.23544>, case 1: <D.23471>, case 2: <D.23472>, case 3: <D.23477>, case 4: <D.23474>, case 5: <D.23473>, case 6: <D.23476>, case 7: <D.23475>, case 8: <D.23482>, case 9: <D.23481>, case 10: <D.23484>, case 11: <D.23483>, case 12: <D.23485>, case 13: <D.23486>, case 14: <D.23516>, case 15: <D.23478>, case 17: <D.23487>, case 18: <D.23523>, case 19: <D.23520>, case 20: <D.23518>, case 21: <D.23543>, case 22: <D.23522>, case 24: <D.23480>, case 25: <D.23479>, case 28: <D.23519>, case 29: <D.23517>, case 30: <D.23521>>
  <D.23471>:
  D.28917 = 1;
  return D.28917;
  <D.23472>:
  D.28917 = 3;
  return D.28917;
  <D.23473>:
  D.28917 = 6;
  return D.28917;
  <D.23474>:
  D.28917 = 5;
  return D.28917;
  <D.23475>:
  D.28917 = 8;
  return D.28917;
  <D.23476>:
  D.28917 = 7;
  return D.28917;
  <D.23477>:
  D.28917 = 4;
  return D.28917;
  <D.23478>:
  <D.23479>:
  <D.23480>:
  D.28917 = 1;
  return D.28917;
  <D.23481>:
  D.28917 = 10;
  return D.28917;
  <D.23482>:
  D.28917 = 9;
  return D.28917;
  <D.23483>:
  D.28917 = 12;
  return D.28917;
  <D.23484>:
  D.28917 = 11;
  return D.28917;
  <D.23485>:
  D.28917 = 13;
  return D.28917;
  <D.23486>:
  D.28917 = 14;
  return D.28917;
  <D.23487>:
  {
    struct MonoClass * klass;

    D.28911 = type->type;
    klass = D.28911->data.klass;
    D.28918 = BIT_FIELD_REF <*klass, 8, 160>;
    D.28919 = D.28918 & 16;
    if (D.28919 != 0) goto <D.28920>; else goto <D.28921>;
    <D.28920>:
    D.28922 = mono_class_enum_basetype (klass);
    D.28923 = D.28922->type;
    t = (int) D.28923;
    goto handle_enum;
    <D.28921>:
    D.28924 = klass->image;
    D.28925 = mono_is_corlib_image (D.28924);
    if (D.28925 != 0) goto <D.28926>; else goto <D.28927>;
    <D.28926>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 6;
      if (__s2_len <= 3) goto <D.28929>; else goto <D.28930>;
      <D.28929>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = klass->name_space;
        D.28931 = "System";
        D.28932 = MEM[(const unsigned char *)D.28931];
        D.28933 = (int) D.28932;
        D.28934 = *__s2;
        D.28935 = (int) D.28934;
        __result = D.28933 - D.28935;
        {
          D.28936 = __s2_len != 0;
          D.28937 = __result == 0;
          D.28938 = D.28936 & D.28937;
          if (D.28938 != 0) goto <D.28939>; else goto <D.28940>;
          <D.28939>:
          D.28941 = &MEM[(void *)"System" + 1B];
          D.28942 = *D.28941;
          D.28943 = (int) D.28942;
          D.28944 = __s2 + 1;
          D.28945 = *D.28944;
          D.28946 = (int) D.28945;
          __result = D.28943 - D.28946;
          D.28947 = __s2_len > 1;
          D.28937 = __result == 0;
          D.28948 = D.28947 & D.28937;
          if (D.28948 != 0) goto <D.28949>; else goto <D.28950>;
          <D.28949>:
          D.28951 = &MEM[(void *)"System" + 2B];
          D.28952 = *D.28951;
          D.28953 = (int) D.28952;
          D.28954 = __s2 + 2;
          D.28955 = *D.28954;
          D.28956 = (int) D.28955;
          __result = D.28953 - D.28956;
          D.28957 = __s2_len > 2;
          D.28937 = __result == 0;
          D.28958 = D.28957 & D.28937;
          if (D.28958 != 0) goto <D.28959>; else goto <D.28960>;
          <D.28959>:
          D.28961 = &MEM[(void *)"System" + 3B];
          D.28962 = *D.28961;
          D.28963 = (int) D.28962;
          D.28964 = __s2 + 3;
          D.28965 = *D.28964;
          D.28966 = (int) D.28965;
          __result = D.28963 - D.28966;
          <D.28960>:
          <D.28950>:
          <D.28940>:
        }
        D.23496 = __result;
      }
      iftmp.56 = -D.23496;
      goto <D.28967>;
      <D.28930>:
      D.28968 = klass->name_space;
      iftmp.56 = __builtin_strcmp (D.28968, "System");
      <D.28967>:
      D.23497 = iftmp.56;
    }
    if (D.23497 == 0) goto <D.28969>; else goto <D.28970>;
    <D.28969>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 7;
      if (__s2_len <= 3) goto <D.28972>; else goto <D.28973>;
      <D.28972>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = klass->name;
        D.28974 = "Decimal";
        D.28975 = MEM[(const unsigned char *)D.28974];
        D.28976 = (int) D.28975;
        D.28977 = *__s2;
        D.28978 = (int) D.28977;
        __result = D.28976 - D.28978;
        {
          D.28979 = __s2_len != 0;
          D.28980 = __result == 0;
          D.28981 = D.28979 & D.28980;
          if (D.28981 != 0) goto <D.28982>; else goto <D.28983>;
          <D.28982>:
          D.28984 = &MEM[(void *)"Decimal" + 1B];
          D.28985 = *D.28984;
          D.28986 = (int) D.28985;
          D.28987 = __s2 + 1;
          D.28988 = *D.28987;
          D.28989 = (int) D.28988;
          __result = D.28986 - D.28989;
          D.28990 = __s2_len > 1;
          D.28980 = __result == 0;
          D.28991 = D.28990 & D.28980;
          if (D.28991 != 0) goto <D.28992>; else goto <D.28993>;
          <D.28992>:
          D.28994 = &MEM[(void *)"Decimal" + 2B];
          D.28995 = *D.28994;
          D.28996 = (int) D.28995;
          D.28997 = __s2 + 2;
          D.28998 = *D.28997;
          D.28999 = (int) D.28998;
          __result = D.28996 - D.28999;
          D.29000 = __s2_len > 2;
          D.28980 = __result == 0;
          D.29001 = D.29000 & D.28980;
          if (D.29001 != 0) goto <D.29002>; else goto <D.29003>;
          <D.29002>:
          D.29004 = &MEM[(void *)"Decimal" + 3B];
          D.29005 = *D.29004;
          D.29006 = (int) D.29005;
          D.29007 = __s2 + 3;
          D.29008 = *D.29007;
          D.29009 = (int) D.29008;
          __result = D.29006 - D.29009;
          <D.29003>:
          <D.28993>:
          <D.28983>:
        }
        D.23505 = __result;
      }
      iftmp.57 = -D.23505;
      goto <D.29010>;
      <D.28973>:
      D.29011 = klass->name;
      iftmp.57 = __builtin_strcmp (D.29011, "Decimal");
      <D.29010>:
      D.23506 = iftmp.57;
    }
    if (D.23506 == 0) goto <D.29012>; else goto <D.29013>;
    <D.29012>:
    D.28917 = 15;
    return D.28917;
    <D.29013>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 8;
      if (__s2_len <= 3) goto <D.29015>; else goto <D.29016>;
      <D.29015>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = klass->name;
        D.29017 = "DateTime";
        D.29018 = MEM[(const unsigned char *)D.29017];
        D.29019 = (int) D.29018;
        D.29020 = *__s2;
        D.29021 = (int) D.29020;
        __result = D.29019 - D.29021;
        {
          D.29022 = __s2_len != 0;
          D.29023 = __result == 0;
          D.29024 = D.29022 & D.29023;
          if (D.29024 != 0) goto <D.29025>; else goto <D.29026>;
          <D.29025>:
          D.29027 = &MEM[(void *)"DateTime" + 1B];
          D.29028 = *D.29027;
          D.29029 = (int) D.29028;
          D.29030 = __s2 + 1;
          D.29031 = *D.29030;
          D.29032 = (int) D.29031;
          __result = D.29029 - D.29032;
          D.29033 = __s2_len > 1;
          D.29023 = __result == 0;
          D.29034 = D.29033 & D.29023;
          if (D.29034 != 0) goto <D.29035>; else goto <D.29036>;
          <D.29035>:
          D.29037 = &MEM[(void *)"DateTime" + 2B];
          D.29038 = *D.29037;
          D.29039 = (int) D.29038;
          D.29040 = __s2 + 2;
          D.29041 = *D.29040;
          D.29042 = (int) D.29041;
          __result = D.29039 - D.29042;
          D.29043 = __s2_len > 2;
          D.29023 = __result == 0;
          D.29044 = D.29043 & D.29023;
          if (D.29044 != 0) goto <D.29045>; else goto <D.29046>;
          <D.29045>:
          D.29047 = &MEM[(void *)"DateTime" + 3B];
          D.29048 = *D.29047;
          D.29049 = (int) D.29048;
          D.29050 = __s2 + 3;
          D.29051 = *D.29050;
          D.29052 = (int) D.29051;
          __result = D.29049 - D.29052;
          <D.29046>:
          <D.29036>:
          <D.29026>:
        }
        D.23514 = __result;
      }
      iftmp.58 = -D.23514;
      goto <D.29053>;
      <D.29016>:
      D.29011 = klass->name;
      iftmp.58 = __builtin_strcmp (D.29011, "DateTime");
      <D.29053>:
      D.23515 = iftmp.58;
    }
    if (D.23515 == 0) goto <D.29054>; else goto <D.29055>;
    <D.29054>:
    D.28917 = 16;
    return D.28917;
    <D.29055>:
    <D.28970>:
    <D.28927>:
    D.28917 = 1;
    return D.28917;
  }
  <D.23516>:
  D.28917 = 18;
  return D.28917;
  <D.23517>:
  <D.23518>:
  <D.23519>:
  <D.23520>:
  <D.23521>:
  <D.23522>:
  D.28917 = 1;
  return D.28917;
  <D.23523>:
  {
    struct MonoClass * klass;

    D.28911 = type->type;
    klass = D.28911->data.klass;
    D.29056 = klass->image;
    D.29057 = mono_defaults.corlib;
    if (D.29056 == D.29057) goto <D.29058>; else goto <D.29059>;
    <D.29058>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 6;
      if (__s2_len <= 3) goto <D.29061>; else goto <D.29062>;
      <D.29061>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = klass->name_space;
        D.28931 = "System";
        D.28932 = MEM[(const unsigned char *)D.28931];
        D.28933 = (int) D.28932;
        D.29063 = *__s2;
        D.29064 = (int) D.29063;
        __result = D.28933 - D.29064;
        {
          D.29065 = __s2_len != 0;
          D.29066 = __result == 0;
          D.29067 = D.29065 & D.29066;
          if (D.29067 != 0) goto <D.29068>; else goto <D.29069>;
          <D.29068>:
          D.28941 = &MEM[(void *)"System" + 1B];
          D.28942 = *D.28941;
          D.28943 = (int) D.28942;
          D.29070 = __s2 + 1;
          D.29071 = *D.29070;
          D.29072 = (int) D.29071;
          __result = D.28943 - D.29072;
          D.29073 = __s2_len > 1;
          D.29066 = __result == 0;
          D.29074 = D.29073 & D.29066;
          if (D.29074 != 0) goto <D.29075>; else goto <D.29076>;
          <D.29075>:
          D.28951 = &MEM[(void *)"System" + 2B];
          D.28952 = *D.28951;
          D.28953 = (int) D.28952;
          D.29077 = __s2 + 2;
          D.29078 = *D.29077;
          D.29079 = (int) D.29078;
          __result = D.28953 - D.29079;
          D.29080 = __s2_len > 2;
          D.29066 = __result == 0;
          D.29081 = D.29080 & D.29066;
          if (D.29081 != 0) goto <D.29082>; else goto <D.29083>;
          <D.29082>:
          D.28961 = &MEM[(void *)"System" + 3B];
          D.28962 = *D.28961;
          D.28963 = (int) D.28962;
          D.29084 = __s2 + 3;
          D.29085 = *D.29084;
          D.29086 = (int) D.29085;
          __result = D.28963 - D.29086;
          <D.29083>:
          <D.29076>:
          <D.29069>:
        }
        D.23532 = __result;
      }
      iftmp.59 = -D.23532;
      goto <D.29087>;
      <D.29062>:
      D.29088 = klass->name_space;
      iftmp.59 = __builtin_strcmp (D.29088, "System");
      <D.29087>:
      D.23533 = iftmp.59;
    }
    if (D.23533 == 0) goto <D.29089>; else goto <D.29090>;
    <D.29089>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 6;
      if (__s2_len <= 3) goto <D.29092>; else goto <D.29093>;
      <D.29092>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = klass->name;
        D.29094 = "DBNull";
        D.29095 = MEM[(const unsigned char *)D.29094];
        D.29096 = (int) D.29095;
        D.29097 = *__s2;
        D.29098 = (int) D.29097;
        __result = D.29096 - D.29098;
        {
          D.29099 = __s2_len != 0;
          D.29100 = __result == 0;
          D.29101 = D.29099 & D.29100;
          if (D.29101 != 0) goto <D.29102>; else goto <D.29103>;
          <D.29102>:
          D.29104 = &MEM[(void *)"DBNull" + 1B];
          D.29105 = *D.29104;
          D.29106 = (int) D.29105;
          D.29107 = __s2 + 1;
          D.29108 = *D.29107;
          D.29109 = (int) D.29108;
          __result = D.29106 - D.29109;
          D.29110 = __s2_len > 1;
          D.29100 = __result == 0;
          D.29111 = D.29110 & D.29100;
          if (D.29111 != 0) goto <D.29112>; else goto <D.29113>;
          <D.29112>:
          D.29114 = &MEM[(void *)"DBNull" + 2B];
          D.29115 = *D.29114;
          D.29116 = (int) D.29115;
          D.29117 = __s2 + 2;
          D.29118 = *D.29117;
          D.29119 = (int) D.29118;
          __result = D.29116 - D.29119;
          D.29120 = __s2_len > 2;
          D.29100 = __result == 0;
          D.29121 = D.29120 & D.29100;
          if (D.29121 != 0) goto <D.29122>; else goto <D.29123>;
          <D.29122>:
          D.29124 = &MEM[(void *)"DBNull" + 3B];
          D.29125 = *D.29124;
          D.29126 = (int) D.29125;
          D.29127 = __s2 + 3;
          D.29128 = *D.29127;
          D.29129 = (int) D.29128;
          __result = D.29126 - D.29129;
          <D.29123>:
          <D.29113>:
          <D.29103>:
        }
        D.23541 = __result;
      }
      iftmp.60 = -D.23541;
      goto <D.29130>;
      <D.29093>:
      D.29131 = klass->name;
      iftmp.60 = __builtin_strcmp (D.29131, "DBNull");
      <D.29130>:
      D.23542 = iftmp.60;
    }
    if (D.23542 == 0) goto <D.29132>; else goto <D.29133>;
    <D.29132>:
    D.28917 = 2;
    return D.28917;
    <D.29133>:
    <D.29090>:
    <D.29059>:
  }
  D.28917 = 1;
  return D.28917;
  <D.23543>:
  D.28917 = 1;
  return D.28917;
  <D.23544>:
  monoeg_g_log (0B, 4, "type 0x%02x not handled in GetTypeCode()", t);
  <D.23545>:
  goto <D.23545>;
  D.28917 = 0;
  return D.28917;
}


ves_icall_Type_GetPacking (struct MonoReflectionType * type, guint32 * packing, guint32 * size)
{
  struct MonoType * D.29135;
  struct MonoImage * D.29136;
  unsigned char D.29137;
  unsigned char D.29138;
  int D.29141;
  unsigned int D.29142;
  int D.29143;
  unsigned int D.29144;
  unsigned int D.29146;
  struct MonoClass * klass;

  D.29135 = type->type;
  klass = mono_class_from_mono_type (D.29135);
  mono_class_init_or_throw (klass);
  D.29136 = klass->image;
  D.29137 = BIT_FIELD_REF <*D.29136, 8, 128>;
  D.29138 = D.29137 & 8;
  if (D.29138 != 0) goto <D.29139>; else goto <D.29140>;
  <D.29139>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = type;
    D.29141 = tb->packing_size;
    D.29142 = (unsigned int) D.29141;
    *packing = D.29142;
    D.29143 = tb->class_size;
    D.29144 = (unsigned int) D.29143;
    *size = D.29144;
  }
  goto <D.29145>;
  <D.29140>:
  D.29136 = klass->image;
  D.29146 = klass->type_token;
  mono_metadata_packing_from_typedef (D.29136, D.29146, packing, size);
  <D.29145>:
}


ves_icall_Type_GetInterfaceMapData (struct MonoReflectionType * type, struct MonoReflectionType * iface, struct MonoArray * * targets, struct MonoArray * * methods)
{
  struct MonoType * D.29147;
  struct MonoType * D.29148;
  struct MonoVTable * D.29151;
  struct MonoClass * D.29152;
  unsigned int len.61;
  struct MonoArray * D.29154;
  struct MonoArray * D.29155;
  struct MonoArray * D.29156;
  unsigned int i.62;
  struct MonoMethod * * D.29158;
  int D.29159;
  unsigned int D.29160;
  unsigned int D.29161;
  struct MonoMethod * * D.29162;
  struct MonoMethod * D.29163;
  struct MonoArray * D.29164;
  gboolean variance_used;
  struct MonoClass * class;
  struct MonoClass * iclass;
  struct MonoReflectionMethod * member;
  struct MonoMethod * method;
  void * iter;
  int i;
  int len;
  int ioffset;
  struct MonoDomain * domain;

  try
    {
      D.29147 = type->type;
      class = mono_class_from_mono_type (D.29147);
      D.29148 = iface->type;
      iclass = mono_class_from_mono_type (D.29148);
      i = 0;
      mono_class_init_or_throw (class);
      mono_class_init_or_throw (iclass);
      mono_class_setup_vtable (class);
      ioffset = mono_class_interface_offset_with_variance (class, iclass, &variance_used);
      if (ioffset == -1) goto <D.29149>; else goto <D.29150>;
      <D.29149>:
      return;
      <D.29150>:
      len = mono_class_num_methods (iclass);
      D.29151 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29151->domain;
      D.29152 = mono_defaults.method_info_class;
      len.61 = (unsigned int) len;
      D.29154 = mono_array_new (domain, D.29152, len.61);
      mono_gc_wbarrier_generic_store (targets, D.29154);
      D.29152 = mono_defaults.method_info_class;
      len.61 = (unsigned int) len;
      D.29155 = mono_array_new (domain, D.29152, len.61);
      mono_gc_wbarrier_generic_store (methods, D.29155);
      iter = 0B;
      goto <D.23814>;
      <D.23813>:
      member = mono_method_get_object (domain, method, iclass);
      {
        void * * __p;

        D.29156 = *methods;
        i.62 = (unsigned int) i;
        __p = mono_array_addr_with_size (D.29156, 4, i.62);
        D.29156 = *methods;
        mono_gc_wbarrier_set_arrayref (D.29156, __p, member);
      }
      D.29158 = class->vtable;
      D.29159 = i + ioffset;
      D.29160 = (unsigned int) D.29159;
      D.29161 = D.29160 * 4;
      D.29162 = D.29158 + D.29161;
      D.29163 = *D.29162;
      member = mono_method_get_object (domain, D.29163, class);
      {
        void * * __p;

        D.29164 = *targets;
        i.62 = (unsigned int) i;
        __p = mono_array_addr_with_size (D.29164, 4, i.62);
        D.29164 = *targets;
        mono_gc_wbarrier_set_arrayref (D.29164, __p, member);
      }
      i = i + 1;
      <D.23814>:
      method = mono_class_get_methods (iclass, &iter);
      if (method != 0B) goto <D.23813>; else goto <D.23815>;
      <D.23815>:
    }
  finally
    {
      variance_used = {CLOBBER};
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetGenericTypeDefinition_impl (struct MonoReflectionType * type)
{
  struct MonoType * D.29168;
  unsigned char D.29169;
  unsigned char D.29170;
  struct MonoReflectionType * D.29173;
  struct MonoGenericContainer * D.29174;
  struct MonoGenericClass * D.29177;
  unsigned char D.29181;
  unsigned char D.29182;
  struct MonoVTable * D.29185;
  struct MonoDomain * D.29186;
  struct MonoType * D.29187;
  struct MonoClass * klass;

  D.29168 = type->type;
  D.29169 = BIT_FIELD_REF <*D.29168, 8, 56>;
  D.29170 = D.29169 & 64;
  if (D.29170 != 0) goto <D.29171>; else goto <D.29172>;
  <D.29171>:
  D.29173 = 0B;
  return D.29173;
  <D.29172>:
  D.29168 = type->type;
  klass = mono_class_from_mono_type (D.29168);
  D.29174 = klass->generic_container;
  if (D.29174 != 0B) goto <D.29175>; else goto <D.29176>;
  <D.29175>:
  D.29173 = type;
  return D.29173;
  <D.29176>:
  D.29177 = klass->generic_class;
  if (D.29177 != 0B) goto <D.29178>; else goto <D.29179>;
  <D.29178>:
  {
    struct MonoClass * generic_class;
    void * tb;

    D.29177 = klass->generic_class;
    generic_class = D.29177->container_class;
    tb = mono_class_get_ref_info (generic_class);
    D.29181 = BIT_FIELD_REF <*generic_class, 8, 160>;
    D.29182 = D.29181 & 128;
    if (D.29182 != 0) goto <D.29183>; else goto <D.29180>;
    <D.29183>:
    if (tb != 0B) goto <D.29184>; else goto <D.29180>;
    <D.29184>:
    D.29173 = tb;
    return D.29173;
    <D.29180>:
    D.29185 = MEM[(struct MonoObject *)type].vtable;
    D.29186 = D.29185->domain;
    D.29187 = &generic_class->byval_arg;
    D.29173 = mono_type_get_object (D.29186, D.29187);
    return D.29173;
  }
  <D.29179>:
  D.29173 = 0B;
  return D.29173;
}


ves_icall_Type_GetGenericParameterPosition (struct MonoReflectionType * type)
{
  struct MonoVTable * D.29193;
  struct MonoClass * D.29194;
  struct MonoImage * D.29195;
  struct MonoImage * D.29196;
  struct MonoType * D.29198;
  gint32 D.29199;
  unsigned char D.29200;
  struct MonoGenericParam * D.29203;
  short unsigned int D.29204;

  if (type != 0B) goto <D.29191>; else goto <D.29192>;
  <D.29191>:
  D.29193 = MEM[(struct MonoObject *)type].vtable;
  D.29194 = D.29193->klass;
  D.29195 = D.29194->image;
  D.29196 = mono_defaults.corlib;
  if (D.29195 != D.29196) goto <D.29189>; else goto <D.29197>;
  <D.29197>:
  D.29198 = type->type;
  if (D.29198 == 0B) goto <D.29189>; else goto <D.29190>;
  <D.29189>:
  D.29199 = -1;
  return D.29199;
  <D.29190>:
  <D.29192>:
  D.29198 = type->type;
  D.29200 = is_generic_parameter (D.29198);
  if (D.29200 != 0) goto <D.29201>; else goto <D.29202>;
  <D.29201>:
  D.29198 = type->type;
  D.29203 = D.29198->data.generic_param;
  D.29204 = D.29203->num;
  D.29199 = (gint32) D.29204;
  return D.29199;
  <D.29202>:
  D.29199 = -1;
  return D.29199;
}


ves_icall_Type_GetGenericParameterConstraints (struct MonoReflectionType * type)
{
  int iftmp.63;
  struct MonoVTable * D.29211;
  struct MonoClass * D.29212;
  struct MonoImage * D.29213;
  struct MonoImage * D.29214;
  struct MonoType * D.29216;
  _Bool D.29217;
  long int D.29218;
  long int D.29219;
  struct MonoGenericParamInfo * iftmp.64;
  struct MonoGenericParam * D.29223;
  struct MonoGenericContainer * D.29224;
  struct MonoClass * D.29229;
  struct MonoClass * D.29230;
  unsigned int count.65;
  unsigned int i.66;
  struct MonoClass * * D.29233;
  unsigned int i.67;
  unsigned int D.29235;
  struct MonoClass * * D.29236;
  struct MonoClass * D.29237;
  struct MonoType * D.29238;
  struct MonoReflectionType * D.29239;
  struct MonoArray * D.29240;
  struct MonoGenericParamInfo * param_info;
  struct MonoDomain * domain;
  struct MonoClass * * ptr;
  struct MonoArray * res;
  int i;
  int count;

  if (type != 0B) goto <D.29210>; else goto <D.29207>;
  <D.29210>:
  D.29211 = MEM[(struct MonoObject *)type].vtable;
  D.29212 = D.29211->klass;
  D.29213 = D.29212->image;
  D.29214 = mono_defaults.corlib;
  if (D.29213 != D.29214) goto <D.29208>; else goto <D.29215>;
  <D.29215>:
  D.29216 = type->type;
  if (D.29216 == 0B) goto <D.29208>; else goto <D.29207>;
  <D.29208>:
  iftmp.63 = 1;
  goto <D.29209>;
  <D.29207>:
  iftmp.63 = 0;
  <D.29209>:
  D.29217 = iftmp.63 != 0;
  D.29218 = (long int) D.29217;
  D.29219 = __builtin_expect (D.29218, 0);
  if (D.29219 != 0) goto <D.29220>; else goto <D.29221>;
  <D.29220>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2493, "IS_MONOTYPE (type)");
  <D.29221>:
  D.29211 = MEM[(struct MonoObject *)type].vtable;
  domain = D.29211->domain;
  D.29216 = type->type;
  D.29223 = D.29216->data.generic_param;
  D.29224 = D.29223->owner;
  if (D.29224 != 0B) goto <D.29225>; else goto <D.29226>;
  <D.29225>:
  D.29216 = type->type;
  D.29223 = D.29216->data.generic_param;
  iftmp.64 = &MEM[(struct MonoGenericParamFull *)D.29223].info;
  goto <D.29227>;
  <D.29226>:
  iftmp.64 = 0B;
  <D.29227>:
  param_info = iftmp.64;
  count = 0;
  ptr = param_info->constraints;
  goto <D.23945>;
  <D.23944>:
  ptr = ptr + 4;
  count = count + 1;
  <D.23945>:
  if (ptr != 0B) goto <D.29228>; else goto <D.23946>;
  <D.29228>:
  D.29229 = *ptr;
  if (D.29229 != 0B) goto <D.23944>; else goto <D.23946>;
  <D.23946>:
  D.29230 = mono_defaults.monotype_class;
  count.65 = (unsigned int) count;
  res = mono_array_new (domain, D.29230, count.65);
  i = 0;
  goto <D.23949>;
  <D.23948>:
  {
    void * * __p;

    i.66 = (unsigned int) i;
    __p = mono_array_addr_with_size (res, 4, i.66);
    D.29233 = param_info->constraints;
    i.67 = (unsigned int) i;
    D.29235 = i.67 * 4;
    D.29236 = D.29233 + D.29235;
    D.29237 = *D.29236;
    D.29238 = &D.29237->byval_arg;
    D.29239 = mono_type_get_object (domain, D.29238);
    mono_gc_wbarrier_set_arrayref (res, __p, D.29239);
  }
  i = i + 1;
  <D.23949>:
  if (i < count) goto <D.23948>; else goto <D.23950>;
  <D.23950>:
  D.29240 = res;
  return D.29240;
}


ves_icall_Type_GetGenericParameterAttributes (struct MonoReflectionType * type)
{
  int iftmp.68;
  struct MonoVTable * D.29247;
  struct MonoClass * D.29248;
  struct MonoImage * D.29249;
  struct MonoImage * D.29250;
  struct MonoType * D.29252;
  _Bool D.29253;
  long int D.29254;
  long int D.29255;
  unsigned char D.29258;
  _Bool D.29259;
  long int D.29260;
  long int D.29261;
  GenericParameterAttributes D.29264;
  struct MonoGenericParamInfo * iftmp.69;
  struct MonoGenericParam * D.29266;
  struct MonoGenericContainer * D.29267;
  short unsigned int D.29271;

  if (type != 0B) goto <D.29246>; else goto <D.29243>;
  <D.29246>:
  D.29247 = MEM[(struct MonoObject *)type].vtable;
  D.29248 = D.29247->klass;
  D.29249 = D.29248->image;
  D.29250 = mono_defaults.corlib;
  if (D.29249 != D.29250) goto <D.29244>; else goto <D.29251>;
  <D.29251>:
  D.29252 = type->type;
  if (D.29252 == 0B) goto <D.29244>; else goto <D.29243>;
  <D.29244>:
  iftmp.68 = 1;
  goto <D.29245>;
  <D.29243>:
  iftmp.68 = 0;
  <D.29245>:
  D.29253 = iftmp.68 != 0;
  D.29254 = (long int) D.29253;
  D.29255 = __builtin_expect (D.29254, 0);
  if (D.29255 != 0) goto <D.29256>; else goto <D.29257>;
  <D.29256>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2477, "IS_MONOTYPE (type)");
  <D.29257>:
  D.29252 = type->type;
  D.29258 = is_generic_parameter (D.29252);
  D.29259 = D.29258 == 0;
  D.29260 = (long int) D.29259;
  D.29261 = __builtin_expect (D.29260, 0);
  if (D.29261 != 0) goto <D.29262>; else goto <D.29263>;
  <D.29262>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2478, "is_generic_parameter (type->type)");
  <D.29263>:
  D.29252 = type->type;
  D.29266 = D.29252->data.generic_param;
  D.29267 = D.29266->owner;
  if (D.29267 != 0B) goto <D.29268>; else goto <D.29269>;
  <D.29268>:
  D.29252 = type->type;
  D.29266 = D.29252->data.generic_param;
  iftmp.69 = &MEM[(struct MonoGenericParamFull *)D.29266].info;
  goto <D.29270>;
  <D.29269>:
  iftmp.69 = 0B;
  <D.29270>:
  D.29271 = iftmp.69->flags;
  D.29264 = (GenericParameterAttributes) D.29271;
  return D.29264;
}


ves_icall_System_Type_EqualsInternal (struct MonoReflectionType * type, struct MonoReflectionType * c)
{
  struct MonoType * D.29275;
  struct MonoType * D.29277;
  MonoBoolean D.29279;
  int D.29280;
  _Bool D.29281;

  if (c != 0B) goto <D.29274>; else goto <D.29273>;
  <D.29274>:
  D.29275 = type->type;
  if (D.29275 != 0B) goto <D.29276>; else goto <D.29273>;
  <D.29276>:
  D.29277 = c->type;
  if (D.29277 != 0B) goto <D.29278>; else goto <D.29273>;
  <D.29278>:
  D.29275 = type->type;
  D.29277 = c->type;
  D.29280 = mono_metadata_type_equal (D.29275, D.29277);
  D.29279 = (MonoBoolean) D.29280;
  return D.29279;
  <D.29273>:
  D.29281 = type == c;
  D.29279 = (MonoBoolean) D.29281;
  return D.29279;
}


ves_icall_System_Text_Encoding_InternalCodePage (gint32 * int_code_page)
{
  const char * cset.70;
  char D.29284;
  int D.29285;
  int D.29286;
  const short unsigned int * * D.29289;
  const short unsigned int * D.29290;
  unsigned int D.29291;
  unsigned int D.29292;
  const short unsigned int * D.29293;
  short unsigned int D.29294;
  int D.29295;
  int D.29296;
  int D.25496;
  int D.29301;
  const int iftmp.71;
  unsigned int __c.72;
  unsigned int D.29306;
  const __int32_t * * D.29309;
  const __int32_t * D.29310;
  unsigned int __c.73;
  unsigned int D.29312;
  const __int32_t * D.29313;
  unsigned int D.29317;
  const __int32_t * D.29318;
  char D.29319;
  int p.74;
  int D.25509;
  char * D.29327;
  int D.29330;
  int D.29331;
  struct MonoString * D.29335;
  struct MonoDomain * D.29336;
  const char * cset;
  const char * p;
  char * c;
  char * codepage;
  int code;
  int want_name;
  int i;

  try
    {
      codepage = 0B;
      want_name = *int_code_page;
      *int_code_page = -1;
      monoeg_g_get_charset (&cset);
      cset.70 = cset;
      codepage = __strdup (cset.70);
      c = codepage;
      c = codepage;
      goto <D.25498>;
      <D.25497>:
      D.29284 = *c;
      D.29285 = (int) D.29284;
      D.29286 = D.29285 & -128;
      if (D.29286 == 0) goto <D.29287>; else goto <D.29288>;
      <D.29287>:
      D.29289 = __ctype_b_loc ();
      D.29290 = *D.29289;
      D.29284 = *c;
      D.29291 = (unsigned int) D.29284;
      D.29292 = D.29291 * 2;
      D.29293 = D.29290 + D.29292;
      D.29294 = *D.29293;
      D.29295 = (int) D.29294;
      D.29296 = D.29295 & 1024;
      if (D.29296 != 0) goto <D.29297>; else goto <D.29298>;
      <D.29297>:
      {
        int __res;

        {
          if (0 != 0) goto <D.29299>; else goto <D.29300>;
          <D.29299>:
          D.29284 = *c;
          D.29285 = (int) D.29284;
          D.29301 = __builtin_constant_p (D.29285);
          if (D.29301 != 0) goto <D.29302>; else goto <D.29303>;
          <D.29302>:
          {
            int __c;

            D.29284 = *c;
            __c = (int) D.29284;
            __c.72 = (unsigned int) __c;
            D.29306 = __c.72 + 128;
            if (D.29306 <= 383) goto <D.29307>; else goto <D.29308>;
            <D.29307>:
            D.29309 = __ctype_tolower_loc ();
            D.29310 = *D.29309;
            __c.73 = (unsigned int) __c;
            D.29312 = __c.73 * 4;
            D.29313 = D.29310 + D.29312;
            iftmp.71 = *D.29313;
            goto <D.29314>;
            <D.29308>:
            iftmp.71 = __c;
            <D.29314>:
            __res = iftmp.71;
          }
          goto <D.29315>;
          <D.29303>:
          D.29284 = *c;
          D.29285 = (int) D.29284;
          __res = tolower (D.29285);
          <D.29315>:
          goto <D.29316>;
          <D.29300>:
          D.29309 = __ctype_tolower_loc ();
          D.29310 = *D.29309;
          D.29284 = *c;
          D.29291 = (unsigned int) D.29284;
          D.29317 = D.29291 * 4;
          D.29318 = D.29310 + D.29317;
          __res = *D.29318;
          <D.29316>:
        }
        D.25496 = __res;
      }
      D.29319 = (char) D.25496;
      *c = D.29319;
      <D.29298>:
      <D.29288>:
      D.29284 = *c;
      if (D.29284 == 45) goto <D.29320>; else goto <D.29321>;
      <D.29320>:
      *c = 95;
      <D.29321>:
      c = c + 1;
      <D.25498>:
      D.29284 = *c;
      if (D.29284 != 0) goto <D.25497>; else goto <D.25499>;
      <D.25499>:
      p = encodings[0];
      code = 0;
      i = 0;
      goto <D.25500>;
      <D.25511>:
      p.74 = (int) p;
      if (p.74 <= 6) goto <D.29323>; else goto <D.29324>;
      <D.29323>:
      code = (int) p;
      i = i + 1;
      p = encodings[i];
      // predicted unlikely by continue predictor.
      goto <D.25500>;
      <D.29324>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.25509 = __builtin_strcmp (p, codepage);
      }
      if (D.25509 == 0) goto <D.29325>; else goto <D.29326>;
      <D.29325>:
      *int_code_page = code;
      goto <D.25510>;
      <D.29326>:
      i = i + 1;
      p = encodings[i];
      <D.25500>:
      if (p != 0B) goto <D.25511>; else goto <D.25510>;
      <D.25510>:
      D.29327 = strstr (codepage, "utf_8");
      if (D.29327 != 0B) goto <D.29328>; else goto <D.29329>;
      <D.29328>:
      D.29330 = *int_code_page;
      D.29331 = D.29330 | 268435456;
      *int_code_page = D.29331;
      <D.29329>:
      free (codepage);
      if (want_name != 0) goto <D.29333>; else goto <D.29332>;
      <D.29333>:
      D.29330 = *int_code_page;
      if (D.29330 == -1) goto <D.29334>; else goto <D.29332>;
      <D.29334>:
      D.29336 = mono_domain_get ();
      cset.70 = cset;
      D.29335 = mono_string_new (D.29336, cset.70);
      return D.29335;
      <D.29332>:
      D.29335 = 0B;
      return D.29335;
    }
  finally
    {
      cset = {CLOBBER};
    }
}


ves_icall_RuntimeMethod_GetFunctionPointer (struct MonoMethod * method)
{
  void * D.29339;

  D.29339 = mono_compile_method (method);
  return D.29339;
}


ves_icall_IsTransparentProxy (struct MonoObject * proxy)
{
  MonoBoolean D.29343;
  struct MonoVTable * D.29344;
  struct MonoClass * D.29345;
  struct MonoClass * D.29346;

  if (proxy == 0B) goto <D.29341>; else goto <D.29342>;
  <D.29341>:
  D.29343 = 0;
  return D.29343;
  <D.29342>:
  D.29344 = proxy->vtable;
  D.29345 = D.29344->klass;
  D.29346 = mono_defaults.transparent_proxy_class;
  if (D.29345 == D.29346) goto <D.29347>; else goto <D.29348>;
  <D.29347>:
  D.29343 = 1;
  return D.29343;
  <D.29348>:
  D.29343 = 0;
  return D.29343;
}


ves_icall_InternalExecute (struct MonoReflectionMethod * method, struct MonoObject * this, struct MonoArray * params, struct MonoArray * * outArgs)
{
  struct MonoVTable * D.29350;
  struct MonoClass * D.29351;
  struct MonoClass * D.29352;
  int D.24096;
  int iftmp.75;
  int D.24095;
  const char[12] * D.29358;
  unsigned char D.29359;
  int D.29360;
  unsigned char D.29361;
  int D.29362;
  _Bool D.29363;
  _Bool D.29364;
  _Bool D.29365;
  const unsigned char * D.29368;
  unsigned char D.29369;
  int D.29370;
  const unsigned char * D.29371;
  unsigned char D.29372;
  int D.29373;
  _Bool D.29374;
  _Bool D.29375;
  const unsigned char * D.29378;
  unsigned char D.29379;
  int D.29380;
  const unsigned char * D.29381;
  unsigned char D.29382;
  int D.29383;
  _Bool D.29384;
  _Bool D.29385;
  const unsigned char * D.29388;
  unsigned char D.29389;
  int D.29390;
  const unsigned char * D.29391;
  unsigned char D.29392;
  int D.29393;
  const char * D.29395;
  struct MonoVTable * D.29398;
  struct MonoClass * D.29399;
  struct MonoRealProxy * D.29402;
  _Bool D.29403;
  long int D.29404;
  long int D.29405;
  char * D.29408;
  struct MonoType * D.29411;
  unsigned char D.29412;
  unsigned char D.29413;
  int D.29416;
  sizetype D.29417;
  void * D.29418;
  void * * D.29420;
  struct MonoObject * D.29421;
  int D.24114;
  int iftmp.76;
  int D.24113;
  const char[12] * D.29425;
  unsigned char D.29426;
  int D.29427;
  unsigned char D.29428;
  int D.29429;
  _Bool D.29430;
  _Bool D.29431;
  _Bool D.29432;
  const unsigned char * D.29435;
  unsigned char D.29436;
  int D.29437;
  const unsigned char * D.29438;
  unsigned char D.29439;
  int D.29440;
  _Bool D.29441;
  _Bool D.29442;
  const unsigned char * D.29445;
  unsigned char D.29446;
  int D.29447;
  const unsigned char * D.29448;
  unsigned char D.29449;
  int D.29450;
  _Bool D.29451;
  _Bool D.29452;
  const unsigned char * D.29455;
  unsigned char D.29456;
  int D.29457;
  const unsigned char * D.29458;
  unsigned char D.29459;
  int D.29460;
  struct MonoRealProxy * D.29466;
  char * D.29469;
  struct MonoType * D.29472;
  char * D.29473;
  unsigned char D.29474;
  unsigned char D.29475;
  int D.29478;
  int D.29479;
  unsigned int D.29480;
  _Bool D.29481;
  long int D.29482;
  long int D.29483;
  int D.29486;
  sizetype D.29487;
  void * D.29488;
  void * D.29489;
  struct MonoType * D.29491;
  unsigned char D.29492;
  unsigned char D.29493;
  unsigned int i.77;
  unsigned int D.29497;
  unsigned int outarg_count.78;
  int D.24137;
  int iftmp.79;
  int D.24136;
  struct MonoMethod * D.29502;
  const char[6] * D.29503;
  unsigned char D.29504;
  int D.29505;
  unsigned char D.29506;
  int D.29507;
  _Bool D.29508;
  _Bool D.29509;
  _Bool D.29510;
  const unsigned char * D.29513;
  unsigned char D.29514;
  int D.29515;
  const unsigned char * D.29516;
  unsigned char D.29517;
  int D.29518;
  _Bool D.29519;
  _Bool D.29520;
  const unsigned char * D.29523;
  unsigned char D.29524;
  int D.29525;
  const unsigned char * D.29526;
  unsigned char D.29527;
  int D.29528;
  _Bool D.29529;
  _Bool D.29530;
  const unsigned char * D.29533;
  unsigned char D.29534;
  int D.29535;
  const unsigned char * D.29536;
  unsigned char D.29537;
  int D.29538;
  const char * D.29540;
  struct MonoClass * D.29545;
  unsigned char D.29546;
  unsigned char D.29547;
  _Bool D.29548;
  long int D.29549;
  long int D.29550;
  char * D.29555;
  unsigned int j.80;
  unsigned int D.29557;
  struct MonoDomain * domain;
  struct MonoMethod * m;
  struct MonoMethodSignature * sig;
  struct MonoArray * out_args;
  struct MonoObject * result;
  int i;
  int j;
  int outarg_count;

  D.29350 = MEM[(struct MonoObject *)method].vtable;
  domain = D.29350->domain;
  m = method->method;
  sig = mono_method_signature (m);
  outarg_count = 0;
  D.29351 = m->klass;
  D.29352 = mono_defaults.object_class;
  if (D.29351 == D.29352) goto <D.29353>; else goto <D.29354>;
  <D.29353>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 11;
    if (__s2_len <= 3) goto <D.29356>; else goto <D.29357>;
    <D.29356>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = m->name;
      D.29358 = "FieldGetter";
      D.29359 = MEM[(const unsigned char *)D.29358];
      D.29360 = (int) D.29359;
      D.29361 = *__s2;
      D.29362 = (int) D.29361;
      __result = D.29360 - D.29362;
      {
        D.29363 = __s2_len != 0;
        D.29364 = __result == 0;
        D.29365 = D.29363 & D.29364;
        if (D.29365 != 0) goto <D.29366>; else goto <D.29367>;
        <D.29366>:
        D.29368 = &MEM[(void *)"FieldGetter" + 1B];
        D.29369 = *D.29368;
        D.29370 = (int) D.29369;
        D.29371 = __s2 + 1;
        D.29372 = *D.29371;
        D.29373 = (int) D.29372;
        __result = D.29370 - D.29373;
        D.29374 = __s2_len > 1;
        D.29364 = __result == 0;
        D.29375 = D.29374 & D.29364;
        if (D.29375 != 0) goto <D.29376>; else goto <D.29377>;
        <D.29376>:
        D.29378 = &MEM[(void *)"FieldGetter" + 2B];
        D.29379 = *D.29378;
        D.29380 = (int) D.29379;
        D.29381 = __s2 + 2;
        D.29382 = *D.29381;
        D.29383 = (int) D.29382;
        __result = D.29380 - D.29383;
        D.29384 = __s2_len > 2;
        D.29364 = __result == 0;
        D.29385 = D.29384 & D.29364;
        if (D.29385 != 0) goto <D.29386>; else goto <D.29387>;
        <D.29386>:
        D.29388 = &MEM[(void *)"FieldGetter" + 3B];
        D.29389 = *D.29388;
        D.29390 = (int) D.29389;
        D.29391 = __s2 + 3;
        D.29392 = *D.29391;
        D.29393 = (int) D.29392;
        __result = D.29390 - D.29393;
        <D.29387>:
        <D.29377>:
        <D.29367>:
      }
      D.24095 = __result;
    }
    iftmp.75 = -D.24095;
    goto <D.29394>;
    <D.29357>:
    D.29395 = m->name;
    iftmp.75 = __builtin_strcmp (D.29395, "FieldGetter");
    <D.29394>:
    D.24096 = iftmp.75;
  }
  if (D.24096 == 0) goto <D.29396>; else goto <D.29397>;
  <D.29396>:
  {
    struct MonoClass * k;
    struct MonoString * name;
    char * str;

    D.29398 = this->vtable;
    k = D.29398->klass;
    D.29399 = mono_defaults.transparent_proxy_class;
    if (D.29399 == k) goto <D.29400>; else goto <D.29401>;
    <D.29400>:
    {
      struct MonoTransparentProxy * tp;

      tp = this;
      D.29402 = tp->rp;
      this = D.29402->unwrapped_server;
      D.29403 = this == 0B;
      D.29404 = (long int) D.29403;
      D.29405 = __builtin_expect (D.29404, 0);
      if (D.29405 != 0) goto <D.29406>; else goto <D.29407>;
      <D.29406>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2870, "this");
      <D.29407>:
      D.29398 = this->vtable;
      k = D.29398->klass;
    }
    <D.29401>:
    D.29408 = mono_array_addr_with_size (params, 4, 1);
    name = MEM[(struct MonoString * *)D.29408];
    str = mono_string_to_utf8 (name);
    <D.24104>:
    {
      struct MonoClassField * field;

      field = mono_class_get_field_from_name (k, str);
      if (field != 0B) goto <D.29409>; else goto <D.29410>;
      <D.29409>:
      {
        struct MonoClass * field_klass;

        D.29411 = field->type;
        field_klass = mono_class_from_mono_type (D.29411);
        D.29412 = BIT_FIELD_REF <*field_klass, 8, 160>;
        D.29413 = D.29412 & 8;
        if (D.29413 != 0) goto <D.29414>; else goto <D.29415>;
        <D.29414>:
        D.29416 = field->offset;
        D.29417 = (sizetype) D.29416;
        D.29418 = this + D.29417;
        result = mono_value_box (domain, field_klass, D.29418);
        goto <D.29419>;
        <D.29415>:
        D.29416 = field->offset;
        D.29417 = (sizetype) D.29416;
        D.29420 = this + D.29417;
        result = *D.29420;
        <D.29419>:
        D.29352 = mono_defaults.object_class;
        out_args = mono_array_new (domain, D.29352, 1);
        mono_gc_wbarrier_generic_store (outArgs, out_args);
        {
          void * * __p;

          __p = mono_array_addr_with_size (out_args, 4, 0);
          mono_gc_wbarrier_set_arrayref (out_args, __p, result);
        }
        monoeg_g_free (str);
        D.29421 = 0B;
        return D.29421;
      }
      <D.29410>:
      k = k->parent;
    }
    if (k != 0B) goto <D.24104>; else goto <D.24105>;
    <D.24105>:
    monoeg_g_free (str);
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 2896);
  }
  <D.29397>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 11;
    if (__s2_len <= 3) goto <D.29423>; else goto <D.29424>;
    <D.29423>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = m->name;
      D.29425 = "FieldSetter";
      D.29426 = MEM[(const unsigned char *)D.29425];
      D.29427 = (int) D.29426;
      D.29428 = *__s2;
      D.29429 = (int) D.29428;
      __result = D.29427 - D.29429;
      {
        D.29430 = __s2_len != 0;
        D.29431 = __result == 0;
        D.29432 = D.29430 & D.29431;
        if (D.29432 != 0) goto <D.29433>; else goto <D.29434>;
        <D.29433>:
        D.29435 = &MEM[(void *)"FieldSetter" + 1B];
        D.29436 = *D.29435;
        D.29437 = (int) D.29436;
        D.29438 = __s2 + 1;
        D.29439 = *D.29438;
        D.29440 = (int) D.29439;
        __result = D.29437 - D.29440;
        D.29441 = __s2_len > 1;
        D.29431 = __result == 0;
        D.29442 = D.29441 & D.29431;
        if (D.29442 != 0) goto <D.29443>; else goto <D.29444>;
        <D.29443>:
        D.29445 = &MEM[(void *)"FieldSetter" + 2B];
        D.29446 = *D.29445;
        D.29447 = (int) D.29446;
        D.29448 = __s2 + 2;
        D.29449 = *D.29448;
        D.29450 = (int) D.29449;
        __result = D.29447 - D.29450;
        D.29451 = __s2_len > 2;
        D.29431 = __result == 0;
        D.29452 = D.29451 & D.29431;
        if (D.29452 != 0) goto <D.29453>; else goto <D.29454>;
        <D.29453>:
        D.29455 = &MEM[(void *)"FieldSetter" + 3B];
        D.29456 = *D.29455;
        D.29457 = (int) D.29456;
        D.29458 = __s2 + 3;
        D.29459 = *D.29458;
        D.29460 = (int) D.29459;
        __result = D.29457 - D.29460;
        <D.29454>:
        <D.29444>:
        <D.29434>:
      }
      D.24113 = __result;
    }
    iftmp.76 = -D.24113;
    goto <D.29461>;
    <D.29424>:
    D.29395 = m->name;
    iftmp.76 = __builtin_strcmp (D.29395, "FieldSetter");
    <D.29461>:
    D.24114 = iftmp.76;
  }
  if (D.24114 == 0) goto <D.29462>; else goto <D.29463>;
  <D.29462>:
  {
    struct MonoClass * k;
    struct MonoString * name;
    guint32 size;
    gint32 align;
    char * str;

    try
      {
        D.29398 = this->vtable;
        k = D.29398->klass;
        D.29399 = mono_defaults.transparent_proxy_class;
        if (D.29399 == k) goto <D.29464>; else goto <D.29465>;
        <D.29464>:
        {
          struct MonoTransparentProxy * tp;

          tp = this;
          D.29466 = tp->rp;
          this = D.29466->unwrapped_server;
          D.29403 = this == 0B;
          D.29404 = (long int) D.29403;
          D.29405 = __builtin_expect (D.29404, 0);
          if (D.29405 != 0) goto <D.29467>; else goto <D.29468>;
          <D.29467>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2909, "this");
          <D.29468>:
          D.29398 = this->vtable;
          k = D.29398->klass;
        }
        <D.29465>:
        D.29469 = mono_array_addr_with_size (params, 4, 1);
        name = MEM[(struct MonoString * *)D.29469];
        str = mono_string_to_utf8 (name);
        <D.24124>:
        {
          struct MonoClassField * field;

          field = mono_class_get_field_from_name (k, str);
          if (field != 0B) goto <D.29470>; else goto <D.29471>;
          <D.29470>:
          {
            struct MonoClass * field_klass;
            struct MonoObject * val;

            D.29472 = field->type;
            field_klass = mono_class_from_mono_type (D.29472);
            D.29473 = mono_array_addr_with_size (params, 4, 2);
            val = MEM[(void * *)D.29473];
            D.29474 = BIT_FIELD_REF <*field_klass, 8, 160>;
            D.29475 = D.29474 & 8;
            if (D.29475 != 0) goto <D.29476>; else goto <D.29477>;
            <D.29476>:
            D.29472 = field->type;
            D.29478 = mono_type_size (D.29472, &align);
            size = (guint32) D.29478;
            D.29479 = mono_class_value_size (field_klass, 0B);
            D.29480 = (unsigned int) D.29479;
            D.29481 = D.29480 != size;
            D.29482 = (long int) D.29481;
            D.29483 = __builtin_expect (D.29482, 0);
            if (D.29483 != 0) goto <D.29484>; else goto <D.29485>;
            <D.29484>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2924, "size == mono_class_value_size (field_klass, NULL)");
            <D.29485>:
            D.29486 = field->offset;
            D.29487 = (sizetype) D.29486;
            D.29488 = this + D.29487;
            D.29489 = val + 8;
            mono_gc_wbarrier_value_copy (D.29488, D.29489, 1, field_klass);
            goto <D.29490>;
            <D.29477>:
            D.29486 = field->offset;
            D.29487 = (sizetype) D.29486;
            D.29488 = this + D.29487;
            mono_gc_wbarrier_set_field (this, D.29488, val);
            <D.29490>:
            D.29352 = mono_defaults.object_class;
            out_args = mono_array_new (domain, D.29352, 0);
            mono_gc_wbarrier_generic_store (outArgs, out_args);
            monoeg_g_free (str);
            D.29421 = 0B;
            return D.29421;
          }
          <D.29471>:
          k = k->parent;
        }
        if (k != 0B) goto <D.24124>; else goto <D.24125>;
        <D.24125>:
        monoeg_g_free (str);
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 2941);
      }
    finally
      {
        align = {CLOBBER};
      }
  }
  <D.29463>:
  <D.29354>:
  i = 0;
  goto <D.24127>;
  <D.24126>:
  D.29491 = sig->params[i];
  D.29492 = BIT_FIELD_REF <*D.29491, 8, 56>;
  D.29493 = D.29492 & 64;
  if (D.29493 != 0) goto <D.29494>; else goto <D.29495>;
  <D.29494>:
  outarg_count = outarg_count + 1;
  <D.29495>:
  i = i + 1;
  <D.24127>:
  i.77 = (unsigned int) i;
  D.29497 = mono_array_length (params);
  if (i.77 < D.29497) goto <D.24126>; else goto <D.24128>;
  <D.24128>:
  D.29352 = mono_defaults.object_class;
  outarg_count.78 = (unsigned int) outarg_count;
  out_args = mono_array_new (domain, D.29352, outarg_count.78);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.29500>; else goto <D.29501>;
    <D.29500>:
    {
      const unsigned char * __s2;
      int __result;

      D.29502 = method->method;
      __s2 = D.29502->name;
      D.29503 = ".ctor";
      D.29504 = MEM[(const unsigned char *)D.29503];
      D.29505 = (int) D.29504;
      D.29506 = *__s2;
      D.29507 = (int) D.29506;
      __result = D.29505 - D.29507;
      {
        D.29508 = __s2_len != 0;
        D.29509 = __result == 0;
        D.29510 = D.29508 & D.29509;
        if (D.29510 != 0) goto <D.29511>; else goto <D.29512>;
        <D.29511>:
        D.29513 = &MEM[(void *)".ctor" + 1B];
        D.29514 = *D.29513;
        D.29515 = (int) D.29514;
        D.29516 = __s2 + 1;
        D.29517 = *D.29516;
        D.29518 = (int) D.29517;
        __result = D.29515 - D.29518;
        D.29519 = __s2_len > 1;
        D.29509 = __result == 0;
        D.29520 = D.29519 & D.29509;
        if (D.29520 != 0) goto <D.29521>; else goto <D.29522>;
        <D.29521>:
        D.29523 = &MEM[(void *)".ctor" + 2B];
        D.29524 = *D.29523;
        D.29525 = (int) D.29524;
        D.29526 = __s2 + 2;
        D.29527 = *D.29526;
        D.29528 = (int) D.29527;
        __result = D.29525 - D.29528;
        D.29529 = __s2_len > 2;
        D.29509 = __result == 0;
        D.29530 = D.29529 & D.29509;
        if (D.29530 != 0) goto <D.29531>; else goto <D.29532>;
        <D.29531>:
        D.29533 = &MEM[(void *)".ctor" + 3B];
        D.29534 = *D.29533;
        D.29535 = (int) D.29534;
        D.29536 = __s2 + 3;
        D.29537 = *D.29536;
        D.29538 = (int) D.29537;
        __result = D.29535 - D.29538;
        <D.29532>:
        <D.29522>:
        <D.29512>:
      }
      D.24136 = __result;
    }
    iftmp.79 = -D.24136;
    goto <D.29539>;
    <D.29501>:
    D.29502 = method->method;
    D.29540 = D.29502->name;
    iftmp.79 = __builtin_strcmp (D.29540, ".ctor");
    <D.29539>:
    D.24137 = iftmp.79;
  }
  if (D.24137 == 0) goto <D.29541>; else goto <D.29542>;
  <D.29541>:
  D.29403 = this == 0B;
  D.29404 = (long int) D.29403;
  D.29405 = __builtin_expect (D.29404, 0);
  if (D.29405 != 0) goto <D.29543>; else goto <D.29544>;
  <D.29543>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2955, "this");
  <D.29544>:
  <D.29542>:
  D.29502 = method->method;
  D.29545 = D.29502->klass;
  D.29546 = BIT_FIELD_REF <*D.29545, 8, 160>;
  D.29547 = D.29546 & 8;
  D.29548 = D.29547 != 0;
  D.29549 = (long int) D.29548;
  D.29550 = __builtin_expect (D.29549, 0);
  if (D.29550 != 0) goto <D.29551>; else goto <D.29552>;
  <D.29551>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2958, "!method->method->klass->valuetype");
  <D.29552>:
  D.29502 = method->method;
  result = mono_runtime_invoke_array (D.29502, this, params, 0B);
  i = 0;
  j = 0;
  goto <D.24141>;
  <D.24140>:
  D.29491 = sig->params[i];
  D.29492 = BIT_FIELD_REF <*D.29491, 8, 56>;
  D.29493 = D.29492 & 64;
  if (D.29493 != 0) goto <D.29553>; else goto <D.29554>;
  <D.29553>:
  {
    void * arg;

    i.77 = (unsigned int) i;
    D.29555 = mono_array_addr_with_size (params, 4, i.77);
    arg = MEM[(void * *)D.29555];
    {
      void * * __p;

      j.80 = (unsigned int) j;
      __p = mono_array_addr_with_size (out_args, 4, j.80);
      mono_gc_wbarrier_set_arrayref (out_args, __p, arg);
    }
    j = j + 1;
  }
  <D.29554>:
  i = i + 1;
  <D.24141>:
  i.77 = (unsigned int) i;
  D.29557 = mono_array_length (params);
  if (i.77 < D.29557) goto <D.24140>; else goto <D.24142>;
  <D.24142>:
  mono_gc_wbarrier_generic_store (outArgs, out_args);
  D.29421 = result;
  return D.29421;
}


ves_icall_Remoting_RemotingServices_GetVirtualMethod (struct MonoReflectionType * rtype, struct MonoReflectionMethod * rmethod)
{
  _Bool D.29560;
  long int D.29561;
  long int D.29562;
  _Bool D.29567;
  long int D.29568;
  long int D.29569;
  struct MonoType * D.29574;
  unsigned int D.29577;
  unsigned int D.29578;
  unsigned char D.29580;
  struct MonoReflectionMethod * D.29582;
  short unsigned int D.29583;
  int D.29584;
  int D.29585;
  unsigned int D.29588;
  unsigned int D.29589;
  struct MonoClass * D.29594;
  int D.29596;
  unsigned int D.29597;
  unsigned int D.29598;
  short int D.29603;
  int D.29604;
  int D.29605;
  unsigned int D.29606;
  unsigned int D.29607;
  struct MonoMethod * * D.29608;
  int D.29612;
  unsigned int D.29617;
  unsigned int D.29618;
  struct MonoMethod * * D.29619;
  struct MonoDomain * D.29622;
  struct MonoClass * klass;
  struct MonoMethod * method;
  struct MonoMethod * * vtable;
  struct MonoMethod * res;

  res = 0B;
  D.29560 = rtype == 0B;
  D.29561 = (long int) D.29560;
  D.29562 = __builtin_expect (D.29561, 0);
  if (D.29562 != 0) goto <D.29563>; else goto <D.29564>;
  <D.29563>:
  {
    struct MonoException * ex;

    if (rtype != 0B) goto <D.29565>; else goto <D.29566>;
    <D.29565>:
    <D.29566>:
    ex = mono_get_exception_argument_null ("rtype");
    mono_raise_exception (ex);
  }
  <D.29564>:
  D.29567 = rmethod == 0B;
  D.29568 = (long int) D.29567;
  D.29569 = __builtin_expect (D.29568, 0);
  if (D.29569 != 0) goto <D.29570>; else goto <D.29571>;
  <D.29570>:
  {
    struct MonoException * ex;

    if (rmethod != 0B) goto <D.29572>; else goto <D.29573>;
    <D.29572>:
    <D.29573>:
    ex = mono_get_exception_argument_null ("rmethod");
    mono_raise_exception (ex);
  }
  <D.29571>:
  method = rmethod->method;
  D.29574 = rtype->type;
  klass = mono_class_from_mono_type (D.29574);
  mono_class_init_or_throw (klass);
  D.29577 = klass->flags;
  D.29578 = D.29577 & 32;
  if (D.29578 != 0) goto <D.29575>; else goto <D.29579>;
  <D.29579>:
  D.29580 = klass->byval_arg.type;
  if (D.29580 == 19) goto <D.29575>; else goto <D.29581>;
  <D.29581>:
  D.29580 = klass->byval_arg.type;
  if (D.29580 == 30) goto <D.29575>; else goto <D.29576>;
  <D.29575>:
  D.29582 = 0B;
  return D.29582;
  <D.29576>:
  D.29583 = method->flags;
  D.29584 = (int) D.29583;
  D.29585 = D.29584 & 16;
  if (D.29585 != 0) goto <D.29586>; else goto <D.29587>;
  <D.29586>:
  D.29582 = 0B;
  return D.29582;
  <D.29587>:
  D.29583 = method->flags;
  D.29588 = (unsigned int) D.29583;
  D.29589 = D.29588 & 96;
  if (D.29589 != 64) goto <D.29590>; else goto <D.29591>;
  <D.29590>:
  D.29594 = method->klass;
  if (D.29594 == klass) goto <D.29592>; else goto <D.29595>;
  <D.29595>:
  D.29594 = method->klass;
  D.29596 = mono_class_is_subclass_of (klass, D.29594, 0);
  if (D.29596 != 0) goto <D.29592>; else goto <D.29593>;
  <D.29592>:
  D.29582 = rmethod;
  return D.29582;
  <D.29593>:
  D.29582 = 0B;
  return D.29582;
  <D.29591>:
  mono_class_setup_vtable (klass);
  vtable = klass->vtable;
  D.29594 = method->klass;
  D.29597 = D.29594->flags;
  D.29598 = D.29597 & 32;
  if (D.29598 != 0) goto <D.29599>; else goto <D.29600>;
  <D.29599>:
  {
    gboolean variance_used;
    int offs;

    try
      {
        variance_used = 0;
        D.29594 = method->klass;
        offs = mono_class_interface_offset_with_variance (klass, D.29594, &variance_used);
        if (offs >= 0) goto <D.29601>; else goto <D.29602>;
        <D.29601>:
        D.29603 = method->slot;
        D.29604 = (int) D.29603;
        D.29605 = D.29604 + offs;
        D.29606 = (unsigned int) D.29605;
        D.29607 = D.29606 * 4;
        D.29608 = vtable + D.29607;
        res = *D.29608;
        <D.29602>:
      }
    finally
      {
        variance_used = {CLOBBER};
      }
  }
  goto <D.29609>;
  <D.29600>:
  D.29594 = method->klass;
  if (D.29594 != klass) goto <D.29610>; else goto <D.29611>;
  <D.29610>:
  D.29594 = method->klass;
  D.29612 = mono_class_is_subclass_of (klass, D.29594, 0);
  if (D.29612 == 0) goto <D.29613>; else goto <D.29614>;
  <D.29613>:
  D.29582 = 0B;
  return D.29582;
  <D.29614>:
  <D.29611>:
  D.29603 = method->slot;
  if (D.29603 != -1) goto <D.29615>; else goto <D.29616>;
  <D.29615>:
  D.29603 = method->slot;
  D.29617 = (unsigned int) D.29603;
  D.29618 = D.29617 * 4;
  D.29619 = vtable + D.29618;
  res = *D.29619;
  <D.29616>:
  <D.29609>:
  if (res == 0B) goto <D.29620>; else goto <D.29621>;
  <D.29620>:
  D.29582 = 0B;
  return D.29582;
  <D.29621>:
  D.29622 = mono_domain_get ();
  D.29582 = mono_method_get_object (D.29622, res, 0B);
  return D.29582;
}


ves_icall_Remoting_RealProxy_GetTransparentProxy (struct MonoObject * this, struct MonoString * class_name)
{
  struct MonoVTable * D.29624;
  struct MonoClass * D.29625;
  struct MonoRealProxy * * D.29626;
  struct MonoReflectionType * D.29627;
  struct MonoClass * D.29628;
  struct MonoObject * D.29629;
  _Bool D.29630;
  unsigned char D.29631;
  struct MonoRemoteClass * D.29632;
  struct MonoRemoteClass * D.29633;
  void * D.29634;
  struct MonoObject * D.29635;
  struct MonoDomain * domain;
  struct MonoObject * res;
  struct MonoRealProxy * rp;
  struct MonoTransparentProxy * tp;
  struct MonoType * type;
  struct MonoClass * klass;

  D.29624 = this->vtable;
  domain = D.29624->domain;
  rp = this;
  D.29625 = mono_defaults.transparent_proxy_class;
  res = mono_object_new (domain, D.29625);
  tp = res;
  D.29626 = &tp->rp;
  mono_gc_wbarrier_set_field (tp, D.29626, rp);
  D.29627 = rp->class_to_proxy;
  type = D.29627->type;
  klass = mono_class_from_mono_type (type);
  D.29628 = mono_defaults.iremotingtypeinfo_class;
  D.29629 = mono_object_isinst (this, D.29628);
  D.29630 = D.29629 != 0B;
  D.29631 = (unsigned char) D.29630;
  tp->custom_type_info = D.29631;
  D.29632 = mono_remote_class (domain, class_name, klass);
  tp->remote_class = D.29632;
  D.29633 = tp->remote_class;
  D.29634 = mono_remote_class_vtable (domain, D.29633, rp);
  res->vtable = D.29634;
  D.29635 = res;
  return D.29635;
}


ves_icall_Remoting_RealProxy_InternalGetProxyType (struct MonoTransparentProxy * tp)
{
  struct MonoReflectionType * D.29637;
  struct MonoVTable * D.29638;
  struct MonoDomain * D.29639;
  struct MonoRemoteClass * D.29640;
  struct MonoClass * D.29641;
  struct MonoType * D.29642;

  D.29638 = MEM[(struct MonoObject *)tp].vtable;
  D.29639 = D.29638->domain;
  D.29640 = tp->remote_class;
  D.29641 = D.29640->proxy_class;
  D.29642 = &D.29641->byval_arg;
  D.29637 = mono_type_get_object (D.29639, D.29642);
  return D.29637;
}


ves_icall_MonoMethodMessage_InitMessage (struct MonoMethodMessage * this, struct MonoReflectionMethod * method, struct MonoArray * out_args)
{
  struct MonoVTable * D.29644;
  struct MonoDomain * D.29645;

  D.29644 = MEM[(struct MonoObject *)this].vtable;
  D.29645 = D.29644->domain;
  mono_message_init (D.29645, this, method, out_args);
}


ves_icall_System_Runtime_Activation_ActivationServices_EnableProxyActivation (struct MonoReflectionType * type, MonoBoolean enable)
{
  struct MonoType * D.29646;
  struct MonoDomain * D.29647;
  _Bool D.29648;
  struct MonoClass * klass;
  struct MonoVTable * vtable;

  D.29646 = type->type;
  klass = mono_class_from_mono_type (D.29646);
  D.29647 = mono_domain_get ();
  vtable = mono_class_vtable_full (D.29647, klass, 1);
  D.29648 = enable != 0;
  vtable->remote = D.29648;
}


ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClassInstance (struct MonoReflectionType * type)
{
  struct MonoVTable * D.29649;
  struct MonoType * D.29650;
  unsigned int D.29653;
  unsigned int D.29654;
  unsigned char D.29656;
  unsigned int D.29659;
  struct MonoException * D.29660;
  unsigned char D.29661;
  _Bool D.29664;
  long int D.29665;
  long int D.29666;
  struct MonoObject * D.29669;
  struct MonoClass * D.29670;
  struct MonoVTable * D.29671;
  struct MonoClass * klass;
  struct MonoDomain * domain;

  D.29649 = MEM[(struct MonoObject *)type].vtable;
  domain = D.29649->domain;
  D.29650 = type->type;
  klass = mono_class_from_mono_type (D.29650);
  mono_class_init_or_throw (klass);
  D.29653 = klass->flags;
  D.29654 = D.29653 & 32;
  if (D.29654 != 0) goto <D.29651>; else goto <D.29655>;
  <D.29655>:
  D.29656 = klass->byval_arg.type;
  if (D.29656 == 19) goto <D.29651>; else goto <D.29657>;
  <D.29657>:
  D.29656 = klass->byval_arg.type;
  if (D.29656 == 30) goto <D.29651>; else goto <D.29658>;
  <D.29658>:
  D.29653 = klass->flags;
  D.29659 = D.29653 & 128;
  if (D.29659 != 0) goto <D.29651>; else goto <D.29652>;
  <D.29651>:
  D.29660 = mono_get_exception_argument ("type", "Type cannot be instantiated");
  mono_raise_exception (D.29660);
  <D.29652>:
  D.29661 = klass->rank;
  if (D.29661 != 0) goto <D.29662>; else goto <D.29663>;
  <D.29662>:
  D.29661 = klass->rank;
  D.29664 = D.29661 != 1;
  D.29665 = (long int) D.29664;
  D.29666 = __builtin_expect (D.29665, 0);
  if (D.29666 != 0) goto <D.29667>; else goto <D.29668>;
  <D.29667>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 6838, "klass->rank == 1");
  <D.29668>:
  D.29670 = klass->element_class;
  D.29669 = mono_array_new (domain, D.29670, 0);
  return D.29669;
  <D.29663>:
  D.29671 = mono_class_vtable_full (domain, klass, 1);
  D.29669 = mono_object_new_alloc_specific (D.29671);
  return D.29669;
}


ves_icall_System_Runtime_InteropServices_Marshal_PrelinkAll (struct MonoReflectionType * type)
{
  struct MonoType * D.29673;
  struct MonoClass * klass;
  struct MonoMethod * m;
  void * iter;

  try
    {
      D.29673 = type->type;
      klass = mono_class_from_mono_type (D.29673);
      iter = 0B;
      mono_class_init_or_throw (klass);
      goto <D.25691>;
      <D.25690>:
      prelink_method (m);
      <D.25691>:
      m = mono_class_get_methods (klass, &iter);
      if (m != 0B) goto <D.25690>; else goto <D.25692>;
      <D.25692>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


prelink_method (struct MonoMethod * method)
{
  short unsigned int D.29674;
  int D.29675;
  int D.29676;
  const char * exc_class.81;
  struct MonoImage * D.29682;
  const char * exc_arg.82;
  struct MonoException * D.29684;
  const char * exc_class;
  const char * exc_arg;

  try
    {
      D.29674 = method->flags;
      D.29675 = (int) D.29674;
      D.29676 = D.29675 & 8192;
      if (D.29676 == 0) goto <D.29677>; else goto <D.29678>;
      <D.29677>:
      return;
      <D.29678>:
      mono_lookup_pinvoke_call (method, &exc_class, &exc_arg);
      exc_class.81 = exc_class;
      if (exc_class.81 != 0B) goto <D.29680>; else goto <D.29681>;
      <D.29680>:
      D.29682 = mono_defaults.corlib;
      exc_class.81 = exc_class;
      exc_arg.82 = exc_arg;
      D.29684 = mono_exception_from_name_msg (D.29682, "System", exc_class.81, exc_arg.82);
      mono_raise_exception (D.29684);
      <D.29681>:
    }
  finally
    {
      exc_class = {CLOBBER};
      exc_arg = {CLOBBER};
    }
}


ves_icall_System_Runtime_InteropServices_Marshal_Prelink (struct MonoReflectionMethod * method)
{
  struct MonoMethod * D.29688;

  D.29688 = method->method;
  prelink_method (D.29688);
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_SufficientExecutionStack ()
{
  guint8 * stack_addr.83;
  MonoBoolean D.29692;
  int current.84;
  int stack_addr.85;
  int D.29697;
  unsigned int stack_size.86;
  sizetype D.29702;
  guint8 * D.29703;
  int D.29704;
  int D.29705;
  guint8 * stack_addr;
  guint8 * current;
  size_t stack_size;
  int min_size;

  try
    {
      min_size = 65536;
      mono_thread_get_stack_bounds (&stack_addr, &stack_size);
      stack_addr.83 = stack_addr;
      if (stack_addr.83 == 0B) goto <D.29690>; else goto <D.29691>;
      <D.29690>:
      D.29692 = 1;
      return D.29692;
      <D.29691>:
      current = &stack_addr;
      stack_addr.83 = stack_addr;
      if (current > stack_addr.83) goto <D.29693>; else goto <D.29694>;
      <D.29693>:
      current.84 = (int) current;
      stack_addr.83 = stack_addr;
      stack_addr.85 = (int) stack_addr.83;
      D.29697 = current.84 - stack_addr.85;
      if (D.29697 < min_size) goto <D.29698>; else goto <D.29699>;
      <D.29698>:
      D.29692 = 0;
      return D.29692;
      <D.29699>:
      goto <D.29700>;
      <D.29694>:
      current.84 = (int) current;
      stack_addr.83 = stack_addr;
      stack_size.86 = stack_size;
      D.29702 = -stack_size.86;
      D.29703 = stack_addr.83 + D.29702;
      D.29704 = (int) D.29703;
      D.29705 = current.84 - D.29704;
      if (D.29705 < min_size) goto <D.29706>; else goto <D.29707>;
      <D.29706>:
      D.29692 = 0;
      return D.29692;
      <D.29707>:
      <D.29700>:
      D.29692 = 1;
      return D.29692;
    }
  finally
    {
      stack_addr = {CLOBBER};
      stack_size = {CLOBBER};
    }
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunModuleConstructor (struct MonoImage * image)
{
  unsigned char D.29710;
  unsigned char D.29711;
  struct MonoDomain * D.29714;
  struct MonoVTable * D.29715;

  mono_image_check_for_module_cctor (image);
  D.29710 = BIT_FIELD_REF <*image, 8, 128>;
  D.29711 = D.29710 & 128;
  if (D.29711 != 0) goto <D.29712>; else goto <D.29713>;
  <D.29712>:
  {
    struct MonoClass * module_klass;

    module_klass = mono_class_get (image, 33554433);
    D.29714 = mono_domain_get ();
    D.29715 = mono_class_vtable_full (D.29714, module_klass, 1);
    mono_runtime_class_init (D.29715);
  }
  <D.29713>:
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunClassConstructor (struct MonoType * handle)
{
  _Bool D.29716;
  long int D.29717;
  long int D.29718;
  _Bool D.29723;
  long int D.29724;
  long int D.29725;
  struct MonoDomain * D.29730;
  struct MonoClass * klass;
  struct MonoVTable * vtable;

  D.29716 = handle == 0B;
  D.29717 = (long int) D.29716;
  D.29718 = __builtin_expect (D.29717, 0);
  if (D.29718 != 0) goto <D.29719>; else goto <D.29720>;
  <D.29719>:
  {
    struct MonoException * ex;

    if (handle != 0B) goto <D.29721>; else goto <D.29722>;
    <D.29721>:
    <D.29722>:
    ex = mono_get_exception_argument_null ("handle");
    mono_raise_exception (ex);
  }
  <D.29720>:
  klass = mono_class_from_mono_type (handle);
  D.29723 = klass == 0B;
  D.29724 = (long int) D.29723;
  D.29725 = __builtin_expect (D.29724, 0);
  if (D.29725 != 0) goto <D.29726>; else goto <D.29727>;
  <D.29726>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("assertion `%s\' failed", "klass");
    if (handle != 0B) goto <D.29728>; else goto <D.29729>;
    <D.29728>:
    <D.29729>:
    ex = mono_get_exception_argument ("handle", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.29727>:
  D.29730 = mono_domain_get ();
  vtable = mono_class_vtable_full (D.29730, klass, 1);
  mono_runtime_class_init (vtable);
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (struct MonoArray * array, struct MonoClassField * field_handle)
{
  struct MonoVTable * D.29731;
  int D.29732;
  struct MonoClass * D.29733;
  struct MonoType * D.29734;
  int D.29737;
  unsigned char D.29739;
  struct MonoType * D.29740;
  short unsigned int D.29741;
  int D.29742;
  int D.29743;
  unsigned int D.29746;
  int D.29747;
  unsigned int D.29748;
  char * D.29751;
  struct MonoClass * klass;
  guint32 size;
  struct MonoType * type;
  int align;
  const char * field_data;

  try
    {
      D.29731 = array->obj.vtable;
      klass = D.29731->klass;
      D.29732 = mono_array_element_size (klass);
      size = (guint32) D.29732;
      D.29733 = klass->element_class;
      D.29734 = &D.29733->byval_arg;
      type = mono_type_get_underlying_type (D.29734);
      D.29737 = mono_type_is_reference (type);
      if (D.29737 != 0) goto <D.29735>; else goto <D.29738>;
      <D.29738>:
      D.29739 = type->type;
      if (D.29739 == 17) goto <D.29735>; else goto <D.29736>;
      <D.29735>:
      {
        struct MonoException * exc;

        exc = mono_get_exception_argument ("array", "Cannot initialize array of non-primitive type.");
        mono_raise_exception (exc);
      }
      <D.29736>:
      D.29740 = field_handle->type;
      D.29741 = D.29740->attrs;
      D.29742 = (int) D.29741;
      D.29743 = D.29742 & 256;
      if (D.29743 == 0) goto <D.29744>; else goto <D.29745>;
      <D.29744>:
      {
        struct MonoException * exc;

        exc = mono_get_exception_argument ("field_handle", "Field doesn\'t have an RVA");
        mono_raise_exception (exc);
      }
      <D.29745>:
      D.29746 = array->max_length;
      size = D.29746 * size;
      field_data = mono_field_get_data (field_handle);
      D.29740 = field_handle->type;
      D.29747 = mono_type_size (D.29740, &align);
      D.29748 = (unsigned int) D.29747;
      if (D.29748 < size) goto <D.29749>; else goto <D.29750>;
      <D.29749>:
      {
        struct MonoException * exc;

        exc = mono_get_exception_argument ("field_handle", "Field not large enough to fill array");
        mono_raise_exception (exc);
      }
      <D.29750>:
      D.29751 = mono_array_addr_with_size (array, 1, 0);
      memcpy (D.29751, field_data, size);
    }
  finally
    {
      align = {CLOBBER};
    }
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetOffsetToStringData ()
{
  gint D.29752;

  D.29752 = 12;
  return D.29752;
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetObjectValue (struct MonoObject * obj)
{
  struct MonoVTable * D.29757;
  struct MonoClass * D.29758;
  unsigned char D.29759;
  unsigned char D.29760;
  struct MonoObject * D.29761;

  if (obj == 0B) goto <D.29754>; else goto <D.29756>;
  <D.29756>:
  D.29757 = obj->vtable;
  D.29758 = D.29757->klass;
  D.29759 = BIT_FIELD_REF <*D.29758, 8, 160>;
  D.29760 = D.29759 & 8;
  if (D.29760 == 0) goto <D.29754>; else goto <D.29755>;
  <D.29754>:
  D.29761 = obj;
  return D.29761;
  <D.29755>:
  D.29761 = mono_object_clone (obj);
  return D.29761;
}


param_info_get_type_modifiers (struct MonoReflectionParameter * param, MonoBoolean optional)
{
  struct MonoReflectionType * D.29763;
  struct MonoObject * D.29764;
  struct MonoVTable * D.29765;
  int D.29766;
  struct MonoImage * D.29772;
  struct MonoImage * D.29773;
  int D.25755;
  int iftmp.87;
  int D.25751;
  const char[13] * D.29778;
  unsigned char D.29779;
  int D.29780;
  unsigned char D.29781;
  int D.29782;
  _Bool D.29783;
  _Bool D.29784;
  _Bool D.29785;
  const unsigned char * D.29788;
  unsigned char D.29789;
  int D.29790;
  const unsigned char * D.29791;
  unsigned char D.29792;
  int D.29793;
  _Bool D.29794;
  _Bool D.29795;
  const unsigned char * D.29798;
  unsigned char D.29799;
  int D.29800;
  const unsigned char * D.29801;
  unsigned char D.29802;
  int D.29803;
  _Bool D.29804;
  _Bool D.29805;
  const unsigned char * D.29808;
  unsigned char D.29809;
  int D.29810;
  const unsigned char * D.29811;
  unsigned char D.29812;
  int D.29813;
  const char * D.29815;
  struct MonoProperty * D.29817;
  _Bool D.29820;
  long int D.29821;
  long int D.29822;
  struct MonoClass * D.29825;
  struct MonoArray * D.29829;
  int D.29830;
  struct MonoType * type;
  struct MonoClass * member_class;
  struct MonoMethod * method;
  struct MonoImage * image;
  int pos;
  struct MonoMethodSignature * sig;

  D.29763 = param->ClassImpl;
  type = D.29763->type;
  D.29764 = param->MemberImpl;
  D.29765 = D.29764->vtable;
  member_class = D.29765->klass;
  method = 0B;
  D.29766 = mono_class_is_reflection_method_or_constructor (member_class);
  if (D.29766 != 0) goto <D.29767>; else goto <D.29768>;
  <D.29767>:
  {
    struct MonoReflectionMethod * rmethod;

    rmethod = param->MemberImpl;
    method = rmethod->method;
  }
  goto <D.29769>;
  <D.29768>:
  D.29772 = member_class->image;
  D.29773 = mono_defaults.corlib;
  if (D.29772 == D.29773) goto <D.29774>; else goto <D.29770>;
  <D.29774>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 12;
    if (__s1_len <= 3) goto <D.29776>; else goto <D.29777>;
    <D.29776>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = member_class->name;
      D.29778 = "MonoProperty";
      D.29779 = MEM[(const unsigned char *)D.29778];
      D.29780 = (int) D.29779;
      D.29781 = *__s2;
      D.29782 = (int) D.29781;
      __result = D.29780 - D.29782;
      {
        D.29783 = __s1_len != 0;
        D.29784 = __result == 0;
        D.29785 = D.29783 & D.29784;
        if (D.29785 != 0) goto <D.29786>; else goto <D.29787>;
        <D.29786>:
        D.29788 = &MEM[(void *)"MonoProperty" + 1B];
        D.29789 = *D.29788;
        D.29790 = (int) D.29789;
        D.29791 = __s2 + 1;
        D.29792 = *D.29791;
        D.29793 = (int) D.29792;
        __result = D.29790 - D.29793;
        D.29794 = __s1_len > 1;
        D.29784 = __result == 0;
        D.29795 = D.29794 & D.29784;
        if (D.29795 != 0) goto <D.29796>; else goto <D.29797>;
        <D.29796>:
        D.29798 = &MEM[(void *)"MonoProperty" + 2B];
        D.29799 = *D.29798;
        D.29800 = (int) D.29799;
        D.29801 = __s2 + 2;
        D.29802 = *D.29801;
        D.29803 = (int) D.29802;
        __result = D.29800 - D.29803;
        D.29804 = __s1_len > 2;
        D.29784 = __result == 0;
        D.29805 = D.29804 & D.29784;
        if (D.29805 != 0) goto <D.29806>; else goto <D.29807>;
        <D.29806>:
        D.29808 = &MEM[(void *)"MonoProperty" + 3B];
        D.29809 = *D.29808;
        D.29810 = (int) D.29809;
        D.29811 = __s2 + 3;
        D.29812 = *D.29811;
        D.29813 = (int) D.29812;
        __result = D.29810 - D.29813;
        <D.29807>:
        <D.29797>:
        <D.29787>:
      }
      D.25751 = __result;
    }
    iftmp.87 = D.25751;
    goto <D.29814>;
    <D.29777>:
    D.29815 = member_class->name;
    iftmp.87 = __builtin_strcmp ("MonoProperty", D.29815);
    <D.29814>:
    D.25755 = iftmp.87;
  }
  if (D.25755 == 0) goto <D.29816>; else goto <D.29770>;
  <D.29816>:
  {
    struct MonoReflectionProperty * prop;

    prop = param->MemberImpl;
    D.29817 = prop->property;
    method = D.29817->get;
    if (method == 0B) goto <D.29818>; else goto <D.29819>;
    <D.29818>:
    D.29817 = prop->property;
    method = D.29817->set;
    <D.29819>:
    D.29820 = method == 0B;
    D.29821 = (long int) D.29820;
    D.29822 = __builtin_expect (D.29821, 0);
    if (D.29822 != 0) goto <D.29823>; else goto <D.29824>;
    <D.29823>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7444, "method");
    <D.29824>:
  }
  goto <D.29771>;
  <D.29770>:
  {
    char * type_name;
    char * msg;
    struct MonoException * ex;

    type_name = mono_type_get_full_name (member_class);
    msg = monoeg_g_strdup_printf ("Custom modifiers on a ParamInfo with member %s are not supported", type_name);
    ex = mono_get_exception_not_supported (msg);
    monoeg_g_free (type_name);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.29771>:
  <D.29769>:
  D.29825 = method->klass;
  image = D.29825->image;
  pos = param->PositionImpl;
  sig = mono_method_signature (method);
  if (pos == -1) goto <D.29826>; else goto <D.29827>;
  <D.29826>:
  type = sig->ret;
  goto <D.29828>;
  <D.29827>:
  type = sig->params[pos];
  <D.29828>:
  D.29830 = (int) optional;
  D.29829 = type_array_from_modifiers (image, type, D.29830);
  return D.29829;
}


type_array_from_modifiers (struct MonoImage * image, struct MonoType * type, int optional)
{
  <unnamed-unsigned:1> D.29836;
  <unnamed-unsigned:6> D.29838;
  int D.29839;
  struct MonoArray * D.29842;
  struct MonoDomain * D.29843;
  struct MonoClass * D.29844;
  unsigned int count.88;
  <unnamed-unsigned:31> D.29851;
  unsigned int D.29852;
  struct MonoDomain * D.29853;
  struct MonoType * D.29854;
  struct MonoReflectionType * D.29855;
  struct MonoArray * res;
  int i;
  int count;

  count = 0;
  i = 0;
  goto <D.25729>;
  <D.25728>:
  if (optional != 0) goto <D.29835>; else goto <D.29832>;
  <D.29835>:
  D.29836 = type->modifiers[i].required;
  if (D.29836 == 0) goto <D.29833>; else goto <D.29832>;
  <D.29832>:
  if (optional == 0) goto <D.29837>; else goto <D.29834>;
  <D.29837>:
  D.29836 = type->modifiers[i].required;
  if (D.29836 != 0) goto <D.29833>; else goto <D.29834>;
  <D.29833>:
  count = count + 1;
  <D.29834>:
  i = i + 1;
  <D.25729>:
  D.29838 = type->num_mods;
  D.29839 = (int) D.29838;
  if (D.29839 > i) goto <D.25728>; else goto <D.25730>;
  <D.25730>:
  if (count == 0) goto <D.29840>; else goto <D.29841>;
  <D.29840>:
  D.29842 = 0B;
  return D.29842;
  <D.29841>:
  D.29843 = mono_domain_get ();
  D.29844 = mono_defaults.systemtype_class;
  count.88 = (unsigned int) count;
  res = mono_array_new (D.29843, D.29844, count.88);
  count = 0;
  i = 0;
  goto <D.25734>;
  <D.25733>:
  if (optional != 0) goto <D.29849>; else goto <D.29846>;
  <D.29849>:
  D.29836 = type->modifiers[i].required;
  if (D.29836 == 0) goto <D.29847>; else goto <D.29846>;
  <D.29846>:
  if (optional == 0) goto <D.29850>; else goto <D.29848>;
  <D.29850>:
  D.29836 = type->modifiers[i].required;
  if (D.29836 != 0) goto <D.29847>; else goto <D.29848>;
  <D.29847>:
  {
    struct MonoClass * klass;

    D.29851 = type->modifiers[i].token;
    D.29852 = (unsigned int) D.29851;
    klass = mono_class_get (image, D.29852);
    {
      void * * __p;

      count.88 = (unsigned int) count;
      __p = mono_array_addr_with_size (res, 4, count.88);
      D.29853 = mono_domain_get ();
      D.29854 = &klass->byval_arg;
      D.29855 = mono_type_get_object (D.29853, D.29854);
      mono_gc_wbarrier_set_arrayref (res, __p, D.29855);
    }
    count = count + 1;
  }
  <D.29848>:
  i = i + 1;
  <D.25734>:
  D.29838 = type->num_mods;
  D.29839 = (int) D.29838;
  if (D.29839 > i) goto <D.25733>; else goto <D.25735>;
  <D.25735>:
  D.29842 = res;
  return D.29842;
}


ves_icall_get_property_info (struct MonoReflectionProperty * property, struct MonoPropertyInfo * info, PInfo req_info)
{
  struct MonoVTable * D.29857;
  unsigned int D.29858;
  struct MonoReflectionType * * D.29861;
  struct MonoClass * D.29862;
  struct MonoType * D.29863;
  struct MonoReflectionType * D.29864;
  unsigned int D.29865;
  struct MonoReflectionType * * D.29868;
  struct MonoProperty * D.29869;
  struct MonoClass * D.29870;
  struct MonoType * D.29871;
  struct MonoReflectionType * D.29872;
  unsigned int D.29873;
  struct MonoString * * D.29876;
  const char * D.29877;
  struct MonoString * D.29878;
  unsigned int D.29879;
  unsigned int D.29882;
  unsigned int D.29883;
  struct MonoReflectionMethod * * D.29886;
  struct MonoObject * iftmp.89;
  struct MonoMethod * D.29888;
  unsigned int D.29892;
  struct MonoReflectionMethod * * D.29895;
  struct MonoObject * iftmp.90;
  struct MonoMethod * D.29897;
  struct MonoDomain * domain;

  D.29857 = MEM[(struct MonoObject *)property].vtable;
  domain = D.29857->domain;
  D.29858 = req_info & 8;
  if (D.29858 != 0) goto <D.29859>; else goto <D.29860>;
  <D.29859>:
  D.29861 = &info->parent;
  D.29862 = property->klass;
  D.29863 = &D.29862->byval_arg;
  D.29864 = mono_type_get_object (domain, D.29863);
  mono_gc_wbarrier_generic_store (D.29861, D.29864);
  <D.29860>:
  D.29865 = req_info & 16;
  if (D.29865 != 0) goto <D.29866>; else goto <D.29867>;
  <D.29866>:
  D.29868 = &info->declaring_type;
  D.29869 = property->property;
  D.29870 = D.29869->parent;
  D.29871 = &D.29870->byval_arg;
  D.29872 = mono_type_get_object (domain, D.29871);
  mono_gc_wbarrier_generic_store (D.29868, D.29872);
  <D.29867>:
  D.29873 = req_info & 32;
  if (D.29873 != 0) goto <D.29874>; else goto <D.29875>;
  <D.29874>:
  D.29876 = &info->name;
  D.29869 = property->property;
  D.29877 = D.29869->name;
  D.29878 = mono_string_new (domain, D.29877);
  mono_gc_wbarrier_generic_store (D.29876, D.29878);
  <D.29875>:
  D.29879 = req_info & 1;
  if (D.29879 != 0) goto <D.29880>; else goto <D.29881>;
  <D.29880>:
  D.29869 = property->property;
  D.29882 = D.29869->attrs;
  info->attrs = D.29882;
  <D.29881>:
  D.29883 = req_info & 2;
  if (D.29883 != 0) goto <D.29884>; else goto <D.29885>;
  <D.29884>:
  D.29886 = &info->get;
  D.29869 = property->property;
  D.29888 = D.29869->get;
  if (D.29888 != 0B) goto <D.29889>; else goto <D.29890>;
  <D.29889>:
  D.29869 = property->property;
  D.29888 = D.29869->get;
  D.29862 = property->klass;
  iftmp.89 = mono_method_get_object (domain, D.29888, D.29862);
  goto <D.29891>;
  <D.29890>:
  iftmp.89 = 0B;
  <D.29891>:
  mono_gc_wbarrier_generic_store (D.29886, iftmp.89);
  <D.29885>:
  D.29892 = req_info & 4;
  if (D.29892 != 0) goto <D.29893>; else goto <D.29894>;
  <D.29893>:
  D.29895 = &info->set;
  D.29869 = property->property;
  D.29897 = D.29869->set;
  if (D.29897 != 0B) goto <D.29898>; else goto <D.29899>;
  <D.29898>:
  D.29869 = property->property;
  D.29897 = D.29869->set;
  D.29862 = property->klass;
  iftmp.90 = mono_method_get_object (domain, D.29897, D.29862);
  goto <D.29900>;
  <D.29899>:
  iftmp.90 = 0B;
  <D.29900>:
  mono_gc_wbarrier_generic_store (D.29895, iftmp.90);
  <D.29894>:
}


property_info_get_default_value (struct MonoReflectionProperty * property)
{
  struct MonoVTable * D.29901;
  struct MonoClass * D.29902;
  unsigned int D.29903;
  unsigned int D.29904;
  struct MonoException * D.29907;
  <unnamed type> def_type.91;
  struct MonoObject * D.29909;
  struct MonoType blob_type;
  struct MonoProperty * prop;
  struct MonoType * type;
  struct MonoDomain * domain;
  MonoTypeEnum def_type;
  const char * def_value;
  struct MonoObject * o;

  try
    {
      prop = property->property;
      type = get_property_type (prop);
      D.29901 = MEM[(struct MonoObject *)property].vtable;
      domain = D.29901->domain;
      D.29902 = prop->parent;
      mono_class_init (D.29902);
      D.29903 = prop->attrs;
      D.29904 = D.29903 & 4096;
      if (D.29904 == 0) goto <D.29905>; else goto <D.29906>;
      <D.29905>:
      D.29907 = mono_get_exception_invalid_operation (0B);
      mono_raise_exception (D.29907);
      <D.29906>:
      def_value = mono_class_get_property_default_value (prop, &def_type);
      def_type.91 = def_type;
      mono_type_from_blob_type (&blob_type, def_type.91, type);
      o = mono_get_object_from_blob (domain, &blob_type, def_value);
      D.29909 = o;
      return D.29909;
    }
  finally
    {
      blob_type = {CLOBBER};
      def_type = {CLOBBER};
    }
}


get_property_type (struct MonoProperty * prop)
{
  struct MonoMethod * D.29912;
  struct MonoType * D.29915;
  struct MonoMethod * D.29916;
  short unsigned int D.29919;
  int D.29920;
  int D.29921;
  struct MonoMethodSignature * sig;

  D.29912 = prop->get;
  if (D.29912 != 0B) goto <D.29913>; else goto <D.29914>;
  <D.29913>:
  D.29912 = prop->get;
  sig = mono_method_signature (D.29912);
  D.29915 = sig->ret;
  return D.29915;
  <D.29914>:
  D.29916 = prop->set;
  if (D.29916 != 0B) goto <D.29917>; else goto <D.29918>;
  <D.29917>:
  D.29916 = prop->set;
  sig = mono_method_signature (D.29916);
  D.29919 = sig->param_count;
  D.29920 = (int) D.29919;
  D.29921 = D.29920 + -1;
  D.29915 = sig->params[D.29921];
  return D.29915;
  <D.29918>:
  D.29915 = 0B;
  return D.29915;
}


mono_type_from_blob_type (struct MonoType * type, MonoTypeEnum blob_type, struct MonoType * real_type)
{
  unsigned char D.29923;
  struct MonoClass * D.29926;
  unsigned char D.29930;
  struct MonoClass * D.29932;
  unsigned char D.29933;
  unsigned char D.29934;
  struct MonoClass * D.29936;
  struct MonoClass * D.29937;

  D.29923 = (unsigned char) blob_type;
  type->type = D.29923;
  type->data.klass = 0B;
  if (blob_type == 18) goto <D.29924>; else goto <D.29925>;
  <D.29924>:
  D.29926 = mono_defaults.object_class;
  type->data.klass = D.29926;
  goto <D.29927>;
  <D.29925>:
  D.29930 = real_type->type;
  if (D.29930 == 17) goto <D.29931>; else goto <D.29928>;
  <D.29931>:
  D.29932 = real_type->data.klass;
  D.29933 = BIT_FIELD_REF <*D.29932, 8, 160>;
  D.29934 = D.29933 & 16;
  if (D.29934 != 0) goto <D.29935>; else goto <D.29928>;
  <D.29935>:
  type->type = 17;
  D.29936 = mono_class_from_mono_type (real_type);
  type->data.klass = D.29936;
  goto <D.29929>;
  <D.29928>:
  D.29937 = mono_class_from_mono_type (real_type);
  type->data.klass = D.29937;
  <D.29929>:
  <D.29927>:
}


property_info_get_type_modifiers (struct MonoReflectionProperty * property, MonoBoolean optional)
{
  struct MonoProperty * D.29938;
  struct MonoClass * D.29939;
  struct MonoArray * D.29942;
  int D.29943;
  struct MonoType * type;
  struct MonoImage * image;

  D.29938 = property->property;
  type = get_property_type (D.29938);
  D.29939 = property->klass;
  image = D.29939->image;
  if (type == 0B) goto <D.29940>; else goto <D.29941>;
  <D.29940>:
  D.29942 = 0B;
  return D.29942;
  <D.29941>:
  D.29943 = (int) optional;
  D.29942 = type_array_from_modifiers (image, type, D.29943);
  return D.29942;
}


ves_icall_System_MonoMethodInfo_get_retval_marshal (struct MonoMethod * method)
{
  struct MonoMethodSignature * D.29945;
  short unsigned int D.29946;
  int D.29947;
  int D.29948;
  unsigned int D.29949;
  unsigned int D.29950;
  struct MonoMarshalSpec * D.29951;
  struct MonoClass * D.29954;
  struct MonoMethodSignature * D.29955;
  short unsigned int D.29956;
  unsigned int i.92;
  unsigned int D.29958;
  struct MonoMarshalSpec * * D.29959;
  struct MonoMarshalSpec * D.29960;
  struct MonoReflectionMarshalAsAttribute * D.29963;
  struct MonoDomain * domain;
  struct MonoReflectionMarshalAsAttribute * res;
  struct MonoMarshalSpec * * mspecs;
  int i;

  domain = mono_domain_get ();
  res = 0B;
  D.29945 = mono_method_signature (method);
  D.29946 = D.29945->param_count;
  D.29947 = (int) D.29946;
  D.29948 = D.29947 + 1;
  D.29949 = (unsigned int) D.29948;
  D.29950 = D.29949 * 4;
  mspecs = monoeg_malloc (D.29950);
  mono_method_get_marshal_info (method, mspecs);
  D.29951 = *mspecs;
  if (D.29951 != 0B) goto <D.29952>; else goto <D.29953>;
  <D.29952>:
  D.29954 = method->klass;
  D.29951 = *mspecs;
  res = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, D.29954, D.29951);
  <D.29953>:
  D.29955 = mono_method_signature (method);
  D.29956 = D.29955->param_count;
  i = (int) D.29956;
  goto <D.23626>;
  <D.23625>:
  i.92 = (unsigned int) i;
  D.29958 = i.92 * 4;
  D.29959 = mspecs + D.29958;
  D.29960 = *D.29959;
  if (D.29960 != 0B) goto <D.29961>; else goto <D.29962>;
  <D.29961>:
  i.92 = (unsigned int) i;
  D.29958 = i.92 * 4;
  D.29959 = mspecs + D.29958;
  D.29960 = *D.29959;
  mono_metadata_free_marshal_spec (D.29960);
  <D.29962>:
  i = i + -1;
  <D.23626>:
  if (i >= 0) goto <D.23625>; else goto <D.23627>;
  <D.23627>:
  monoeg_g_free (mspecs);
  D.29963 = res;
  return D.29963;
}


ves_icall_get_parameter_info (struct MonoMethod * method, struct MonoReflectionMethod * member)
{
  struct MonoArray * D.29965;
  struct MonoClass * iftmp.93;
  struct MonoReflectionType * D.29967;
  struct MonoType * D.29970;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.29967 = member->reftype;
  if (D.29967 != 0B) goto <D.29968>; else goto <D.29969>;
  <D.29968>:
  D.29967 = member->reftype;
  D.29970 = D.29967->type;
  iftmp.93 = mono_class_from_mono_type (D.29970);
  goto <D.29971>;
  <D.29969>:
  iftmp.93 = 0B;
  <D.29971>:
  D.29965 = mono_param_get_objects_internal (domain, method, iftmp.93);
  return D.29965;
}


ves_icall_get_method_info (struct MonoMethod * method, struct MonoMethodInfo * info)
{
  int D.29973;
  struct MonoReflectionType * * D.29976;
  struct MonoClass * D.29977;
  struct MonoType * D.29978;
  struct MonoReflectionType * D.29979;
  struct MonoReflectionType * * D.29980;
  struct MonoType * D.29981;
  struct MonoReflectionType * D.29982;
  short unsigned int D.29983;
  unsigned int D.29984;
  short unsigned int D.29985;
  unsigned int D.29986;
  unsigned char D.29987;
  unsigned char D.29988;
  guint32 iftmp.94;
  short int D.29992;
  unsigned int D.30001;
  <unnamed-unsigned:1> D.30002;
  int D.30003;
  int D.30004;
  <unnamed-unsigned:1> D.30005;
  int D.30006;
  int D.30007;
  int D.30008;
  unsigned int D.30009;
  unsigned int D.30010;
  struct MonoError error;
  struct MonoDomain * domain;
  struct MonoMethodSignature * sig;

  try
    {
      domain = mono_domain_get ();
      sig = mono_method_signature_checked (method, &error);
      D.29973 = mono_error_ok (&error);
      if (D.29973 == 0) goto <D.29974>; else goto <D.29975>;
      <D.29974>:
      mono_error_raise_exception (&error);
      <D.29975>:
      D.29976 = &info->parent;
      D.29977 = method->klass;
      D.29978 = &D.29977->byval_arg;
      D.29979 = mono_type_get_object (domain, D.29978);
      mono_gc_wbarrier_generic_store (D.29976, D.29979);
      D.29980 = &info->ret;
      D.29981 = sig->ret;
      D.29982 = mono_type_get_object (domain, D.29981);
      mono_gc_wbarrier_generic_store (D.29980, D.29982);
      D.29983 = method->flags;
      D.29984 = (unsigned int) D.29983;
      info->attrs = D.29984;
      D.29985 = method->iflags;
      D.29986 = (unsigned int) D.29985;
      info->implattrs = D.29986;
      D.29987 = BIT_FIELD_REF <*sig, 8, 80>;
      D.29988 = D.29987 & 63;
      if (D.29988 == 0) goto <D.29989>; else goto <D.29990>;
      <D.29989>:
      D.29992 = sig->sentinelpos;
      if (D.29992 >= 0) goto <D.29993>; else goto <D.29994>;
      <D.29993>:
      iftmp.94 = 2;
      goto <D.29995>;
      <D.29994>:
      iftmp.94 = 1;
      <D.29995>:
      info->callconv = iftmp.94;
      goto <D.29996>;
      <D.29990>:
      D.29987 = BIT_FIELD_REF <*sig, 8, 80>;
      D.29988 = D.29987 & 63;
      if (D.29988 == 5) goto <D.29997>; else goto <D.30000>;
      <D.30000>:
      D.29992 = sig->sentinelpos;
      if (D.29992 >= 0) goto <D.29997>; else goto <D.29998>;
      <D.29997>:
      info->callconv = 2;
      goto <D.29999>;
      <D.29998>:
      info->callconv = 1;
      <D.29999>:
      <D.29996>:
      D.30001 = info->callconv;
      D.30002 = sig->hasthis;
      D.30003 = (int) D.30002;
      D.30004 = D.30003 << 5;
      D.30005 = sig->explicit_this;
      D.30006 = (int) D.30005;
      D.30007 = D.30006 << 6;
      D.30008 = D.30004 | D.30007;
      D.30009 = (unsigned int) D.30008;
      D.30010 = D.30001 | D.30009;
      info->callconv = D.30010;
    }
  finally
    {
      error = {CLOBBER};
    }
}


vell_icall_get_method_attributes (struct MonoMethod * method)
{
  int D.30011;
  short unsigned int D.30012;

  D.30012 = method->flags;
  D.30011 = (int) D.30012;
  return D.30011;
}


ves_icall_MonoMethod_get_name (struct MonoReflectionMethod * m)
{
  struct MonoString * * D.30014;
  struct MonoVTable * D.30015;
  struct MonoDomain * D.30016;
  const char * D.30017;
  struct MonoString * D.30018;
  struct MonoString * D.30019;
  struct MonoMethod * method;

  method = m->method;
  D.30014 = &m->name;
  D.30015 = MEM[(struct MonoObject *)m].vtable;
  D.30016 = D.30015->domain;
  D.30017 = method->name;
  D.30018 = mono_string_new (D.30016, D.30017);
  mono_gc_wbarrier_set_field (m, D.30014, D.30018);
  D.30019 = m->name;
  return D.30019;
}


ves_icall_MonoMethod_get_base_method (struct MonoReflectionMethod * m, gboolean definition)
{
  struct MonoClass * D.30021;
  struct MonoReflectionMethod * D.30024;
  short unsigned int D.30027;
  int D.30028;
  int D.30029;
  unsigned int D.30031;
  unsigned int D.30032;
  unsigned char D.30034;
  int D.30037;
  struct MonoGenericClass * D.30040;
  int D.30045;
  int D.30052;
  struct MonoMethod * * D.30055;
  unsigned int slot.95;
  unsigned int D.30057;
  struct MonoMethod * * D.30058;
  short int D.30061;
  int D.30062;
  struct MonoDomain * D.30066;
  struct MonoClass * klass;
  struct MonoClass * parent;
  struct MonoMethod * method;
  struct MonoMethod * result;
  int slot;

  method = m->method;
  result = 0B;
  D.30021 = method->klass;
  if (D.30021 == 0B) goto <D.30022>; else goto <D.30023>;
  <D.30022>:
  D.30024 = m;
  return D.30024;
  <D.30023>:
  D.30027 = method->flags;
  D.30028 = (int) D.30027;
  D.30029 = D.30028 & 64;
  if (D.30029 == 0) goto <D.30025>; else goto <D.30030>;
  <D.30030>:
  D.30021 = method->klass;
  D.30031 = D.30021->flags;
  D.30032 = D.30031 & 32;
  if (D.30032 != 0) goto <D.30025>; else goto <D.30033>;
  <D.30033>:
  D.30021 = method->klass;
  D.30034 = D.30021->byval_arg.type;
  if (D.30034 == 19) goto <D.30025>; else goto <D.30035>;
  <D.30035>:
  D.30021 = method->klass;
  D.30034 = D.30021->byval_arg.type;
  if (D.30034 == 30) goto <D.30025>; else goto <D.30036>;
  <D.30036>:
  D.30027 = method->flags;
  D.30028 = (int) D.30027;
  D.30037 = D.30028 & 256;
  if (D.30037 != 0) goto <D.30025>; else goto <D.30026>;
  <D.30025>:
  D.30024 = m;
  return D.30024;
  <D.30026>:
  slot = mono_method_get_vtable_slot (method);
  if (slot == -1) goto <D.30038>; else goto <D.30039>;
  <D.30038>:
  D.30024 = m;
  return D.30024;
  <D.30039>:
  klass = method->klass;
  D.30040 = klass->generic_class;
  if (D.30040 != 0B) goto <D.30041>; else goto <D.30042>;
  <D.30041>:
  D.30040 = klass->generic_class;
  klass = D.30040->container_class;
  <D.30042>:
  if (definition != 0) goto <D.30043>; else goto <D.30044>;
  <D.30043>:
  parent = klass->parent;
  goto <D.25630>;
  <D.25629>:
  mono_class_setup_vtable (parent);
  D.30045 = parent->vtable_size;
  if (D.30045 <= slot) goto <D.25628>; else goto <D.30046>;
  <D.30046>:
  klass = parent;
  parent = parent->parent;
  <D.25630>:
  if (parent != 0B) goto <D.25629>; else goto <D.25628>;
  <D.25628>:
  goto <D.30047>;
  <D.30044>:
  klass = klass->parent;
  if (klass == 0B) goto <D.30048>; else goto <D.30049>;
  <D.30048>:
  D.30024 = m;
  return D.30024;
  <D.30049>:
  <D.30047>:
  D.30021 = method->klass;
  if (D.30021 == klass) goto <D.30050>; else goto <D.30051>;
  <D.30050>:
  D.30024 = m;
  return D.30024;
  <D.30051>:
  D.30052 = klass->vtable_size;
  if (D.30052 <= slot) goto <D.30053>; else goto <D.30054>;
  <D.30053>:
  D.30024 = m;
  return D.30024;
  <D.30054>:
  mono_class_setup_vtable (klass);
  D.30055 = klass->vtable;
  slot.95 = (unsigned int) slot;
  D.30057 = slot.95 * 4;
  D.30058 = D.30055 + D.30057;
  result = *D.30058;
  if (result == 0B) goto <D.30059>; else goto <D.30060>;
  <D.30059>:
  {
    void * iter;

    try
      {
        iter = 0B;
        goto <D.25634>;
        <D.25633>:
        D.30061 = result->slot;
        D.30062 = (int) D.30061;
        if (D.30062 == slot) goto <D.25632>; else goto <D.30063>;
        <D.30063>:
        <D.25634>:
        result = mono_class_get_methods (klass, &iter);
        if (result != 0B) goto <D.25633>; else goto <D.25632>;
        <D.25632>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  <D.30060>:
  if (result == 0B) goto <D.30064>; else goto <D.30065>;
  <D.30064>:
  D.30024 = m;
  return D.30024;
  <D.30065>:
  D.30066 = mono_domain_get ();
  D.30024 = mono_method_get_object (D.30066, result, 0B);
  return D.30024;
}


ves_icall_MonoMethod_get_IsGenericMethodDefinition (struct MonoReflectionMethod * method)
{
  gboolean D.30068;
  struct MonoMethod * D.30069;
  <unnamed-unsigned:1> D.30070;

  D.30069 = method->method;
  D.30070 = D.30069->is_generic;
  D.30068 = (gboolean) D.30070;
  return D.30068;
}


ves_icall_MonoMethod_get_IsGenericMethod (struct MonoReflectionMethod * method)
{
  gboolean D.30072;
  struct MonoMethod * D.30073;
  struct MonoMethodSignature * D.30074;
  short unsigned int D.30075;
  _Bool D.30076;

  D.30073 = method->method;
  D.30074 = mono_method_signature (D.30073);
  D.30075 = D.30074->generic_param_count;
  D.30076 = D.30075 != 0;
  D.30072 = (gboolean) D.30076;
  return D.30072;
}


ves_icall_MonoMethod_GetGenericArguments (struct MonoReflectionMethod * method)
{
  struct MonoVTable * D.30078;
  struct MonoMethod * D.30079;
  unsigned char D.30080;
  unsigned char D.30081;
  struct MonoGenericContext * D.30084;
  <unnamed-unsigned:22> D.30087;
  struct MonoClass * D.30088;
  unsigned int count.96;
  unsigned int i.97;
  struct MonoType * D.30091;
  struct MonoReflectionType * D.30092;
  struct MonoArray * D.30093;
  struct MonoMethodSignature * D.30094;
  short unsigned int D.30095;
  struct MonoGenericParamFull * D.30096;
  unsigned int i.98;
  unsigned int D.30098;
  struct MonoClass * D.30099;
  struct MonoImage * D.30100;
  struct MonoType * D.30101;
  struct MonoReflectionType * D.30102;
  struct MonoArray * res;
  struct MonoDomain * domain;
  int count;
  int i;

  D.30078 = MEM[(struct MonoObject *)method].vtable;
  domain = D.30078->domain;
  D.30079 = method->method;
  D.30080 = BIT_FIELD_REF <*D.30079, 8, 168>;
  D.30081 = D.30080 & 16;
  if (D.30081 != 0) goto <D.30082>; else goto <D.30083>;
  <D.30082>:
  {
    struct MonoGenericInst * inst;

    D.30079 = method->method;
    D.30084 = mono_method_get_context (D.30079);
    inst = D.30084->method_inst;
    if (inst != 0B) goto <D.30085>; else goto <D.30086>;
    <D.30085>:
    D.30087 = inst->type_argc;
    count = (int) D.30087;
    D.30088 = mono_defaults.systemtype_class;
    count.96 = (unsigned int) count;
    res = mono_array_new (domain, D.30088, count.96);
    i = 0;
    goto <D.24018>;
    <D.24017>:
    {
      void * * __p;

      i.97 = (unsigned int) i;
      __p = mono_array_addr_with_size (res, 4, i.97);
      D.30091 = inst->type_argv[i];
      D.30092 = mono_type_get_object (domain, D.30091);
      mono_gc_wbarrier_set_arrayref (res, __p, D.30092);
    }
    i = i + 1;
    <D.24018>:
    if (i < count) goto <D.24017>; else goto <D.24019>;
    <D.24019>:
    D.30093 = res;
    return D.30093;
    <D.30086>:
  }
  <D.30083>:
  D.30079 = method->method;
  D.30094 = mono_method_signature (D.30079);
  D.30095 = D.30094->generic_param_count;
  count = (int) D.30095;
  D.30088 = mono_defaults.systemtype_class;
  count.96 = (unsigned int) count;
  res = mono_array_new (domain, D.30088, count.96);
  i = 0;
  goto <D.24025>;
  <D.24024>:
  {
    struct MonoGenericContainer * container;
    struct MonoGenericParam * param;
    struct MonoClass * pklass;

    D.30079 = method->method;
    container = mono_method_get_generic_container (D.30079);
    D.30096 = container->type_params;
    i.98 = (unsigned int) i;
    D.30098 = i.98 * 32;
    param = D.30096 + D.30098;
    D.30079 = method->method;
    D.30099 = D.30079->klass;
    D.30100 = D.30099->image;
    pklass = mono_class_from_generic_parameter (param, D.30100, 1);
    {
      void * * __p;

      i.97 = (unsigned int) i;
      __p = mono_array_addr_with_size (res, 4, i.97);
      D.30101 = &pklass->byval_arg;
      D.30102 = mono_type_get_object (domain, D.30101);
      mono_gc_wbarrier_set_arrayref (res, __p, D.30102);
    }
  }
  i = i + 1;
  <D.24025>:
  if (i < count) goto <D.24024>; else goto <D.24026>;
  <D.24026>:
  D.30093 = res;
  return D.30093;
}


ves_icall_MonoMethod_GetDllImportAttribute (struct MonoMethod * method)
{
  struct MonoClass * D.30104;
  short unsigned int D.30105;
  int D.30106;
  int D.30107;
  struct MonoReflectionDllImportAttribute * D.30110;
  struct MonoClass * DllImportAttributeClass.99;
  struct MonoImage * D.30114;
  struct MonoClass * DllImportAttributeClass.100;
  _Bool D.30116;
  long int D.30117;
  long int D.30118;
  struct MonoImage * D.30121;
  unsigned char D.30122;
  unsigned char D.30123;
  struct GHashTable * D.30126;
  _Bool D.30129;
  _Bool D.30130;
  _Bool D.30131;
  struct MonoException * D.30134;
  short unsigned int D.30136;
  int D.30139;
  int D.30140;
  unsigned int D.30141;
  short unsigned int D.30142;
  unsigned int D.30143;
  unsigned int D.30144;
  unsigned int D.30145;
  int D.30146;
  short unsigned int D.30147;
  struct MonoString * * D.30148;
  struct MonoString * D.30149;
  struct MonoString * * D.30150;
  struct MonoString * D.30151;
  unsigned int D.30152;
  unsigned int D.30153;
  int D.30154;
  unsigned int D.30155;
  unsigned int D.30156;
  unsigned int D.30157;
  int D.30158;
  int D.30159;
  unsigned int D.30162;
  _Bool D.30163;
  unsigned char D.30164;
  unsigned int D.30165;
  _Bool D.30166;
  unsigned char D.30167;
  unsigned int D.30168;
  _Bool D.30169;
  unsigned char D.30170;
  unsigned int D.30171;
  _Bool D.30172;
  unsigned char D.30173;
  static struct MonoClass * DllImportAttributeClass = 0B;
  struct MonoDomain * domain;
  struct MonoReflectionDllImportAttribute * attr;
  struct MonoImage * image;
  struct MonoMethodPInvoke * piinfo;
  struct MonoTableInfo * tables;
  struct MonoTableInfo * im;
  struct MonoTableInfo * mr;
  guint32 im_cols[4];
  guint32 scope_token;
  const char * import;
  const char * scope;
  guint32 flags;

  try
    {
      domain = mono_domain_get ();
      D.30104 = method->klass;
      image = D.30104->image;
      piinfo = method;
      tables = &image->tables;
      im = tables + 336;
      mr = tables + 312;
      import = 0B;
      scope = 0B;
      D.30105 = method->flags;
      D.30106 = (int) D.30105;
      D.30107 = D.30106 & 8192;
      if (D.30107 == 0) goto <D.30108>; else goto <D.30109>;
      <D.30108>:
      D.30110 = 0B;
      return D.30110;
      <D.30109>:
      DllImportAttributeClass.99 = DllImportAttributeClass;
      if (DllImportAttributeClass.99 == 0B) goto <D.30112>; else goto <D.30113>;
      <D.30112>:
      D.30114 = mono_defaults.corlib;
      DllImportAttributeClass.100 = mono_class_from_name (D.30114, "System.Runtime.InteropServices", "DllImportAttribute");
      DllImportAttributeClass = DllImportAttributeClass.100;
      DllImportAttributeClass.99 = DllImportAttributeClass;
      D.30116 = DllImportAttributeClass.99 == 0B;
      D.30117 = (long int) D.30116;
      D.30118 = __builtin_expect (D.30117, 0);
      if (D.30118 != 0) goto <D.30119>; else goto <D.30120>;
      <D.30119>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2598, "DllImportAttributeClass");
      <D.30120>:
      <D.30113>:
      D.30104 = method->klass;
      D.30121 = D.30104->image;
      D.30122 = BIT_FIELD_REF <*D.30121, 8, 128>;
      D.30123 = D.30122 & 8;
      if (D.30123 != 0) goto <D.30124>; else goto <D.30125>;
      <D.30124>:
      {
        struct MonoReflectionMethodAux * method_aux;

        D.30104 = method->klass;
        D.30121 = D.30104->image;
        D.30126 = MEM[(struct MonoDynamicImage *)D.30121].method_aux_hash;
        method_aux = monoeg_g_hash_table_lookup (D.30126, method);
        if (method_aux != 0B) goto <D.30127>; else goto <D.30128>;
        <D.30127>:
        import = method_aux->dllentry;
        scope = method_aux->dll;
        <D.30128>:
        D.30129 = import == 0B;
        D.30130 = scope == 0B;
        D.30131 = D.30129 | D.30130;
        if (D.30131 != 0) goto <D.30132>; else goto <D.30133>;
        <D.30132>:
        D.30134 = mono_get_exception_argument ("method", "System.Reflection.Emit method with invalid pinvoke information");
        mono_raise_exception (D.30134);
        D.30110 = 0B;
        return D.30110;
        <D.30133>:
      }
      goto <D.30135>;
      <D.30125>:
      D.30136 = piinfo->implmap_idx;
      if (D.30136 != 0) goto <D.30137>; else goto <D.30138>;
      <D.30137>:
      D.30136 = piinfo->implmap_idx;
      D.30139 = (int) D.30136;
      D.30140 = D.30139 + -1;
      mono_metadata_decode_row (im, D.30140, &im_cols, 4);
      D.30141 = im_cols[0];
      D.30142 = (short unsigned int) D.30141;
      piinfo->piflags = D.30142;
      D.30143 = im_cols[2];
      import = mono_metadata_string_heap (image, D.30143);
      D.30144 = im_cols[3];
      D.30145 = D.30144 + 4294967295;
      D.30146 = (int) D.30145;
      scope_token = mono_metadata_decode_row_col (mr, D.30146, 0);
      scope = mono_metadata_string_heap (image, scope_token);
      <D.30138>:
      <D.30135>:
      D.30147 = piinfo->piflags;
      flags = (guint32) D.30147;
      DllImportAttributeClass.99 = DllImportAttributeClass;
      attr = mono_object_new (domain, DllImportAttributeClass.99);
      D.30148 = &attr->dll;
      D.30149 = mono_string_new (domain, scope);
      mono_gc_wbarrier_set_field (attr, D.30148, D.30149);
      D.30150 = &attr->entry_point;
      D.30151 = mono_string_new (domain, import);
      mono_gc_wbarrier_set_field (attr, D.30150, D.30151);
      D.30152 = flags & 1792;
      D.30153 = D.30152 >> 8;
      D.30154 = (int) D.30153;
      attr->call_conv = D.30154;
      D.30155 = flags & 6;
      D.30156 = D.30155 >> 1;
      D.30157 = D.30156 + 1;
      D.30158 = (int) D.30157;
      attr->charset = D.30158;
      D.30159 = attr->charset;
      if (D.30159 == 1) goto <D.30160>; else goto <D.30161>;
      <D.30160>:
      attr->charset = 2;
      <D.30161>:
      D.30162 = flags & 1;
      D.30163 = D.30162 != 0;
      D.30164 = (unsigned char) D.30163;
      attr->exact_spelling = D.30164;
      D.30165 = flags & 64;
      D.30166 = D.30165 != 0;
      D.30167 = (unsigned char) D.30166;
      attr->set_last_error = D.30167;
      D.30168 = flags & 48;
      D.30169 = D.30168 == 16;
      D.30170 = (unsigned char) D.30169;
      attr->best_fit_mapping = D.30170;
      D.30171 = flags & 12288;
      D.30172 = D.30171 == 4096;
      D.30173 = (unsigned char) D.30172;
      attr->throw_on_unmappable = D.30173;
      attr->preserve_sig = 0;
      D.30110 = attr;
      return D.30110;
    }
  finally
    {
      im_cols = {CLOBBER};
    }
}


ves_icall_MonoGenericMethod_get_ReflectedType (struct MonoReflectionGenericMethod * rmethod)
{
  struct MonoReflectionType * D.30176;
  struct MonoVTable * D.30177;
  struct MonoDomain * D.30178;
  struct MonoClass * D.30179;
  struct MonoType * D.30180;
  struct MonoMethod * method;

  method = rmethod->method.method;
  D.30177 = MEM[(struct MonoObject *)rmethod].vtable;
  D.30178 = D.30177->domain;
  D.30179 = method->klass;
  D.30180 = &D.30179->byval_arg;
  D.30176 = mono_type_get_object (D.30178, D.30180);
  return D.30176;
}


ves_icall_MonoField_SetValueInternal (struct MonoReflectionField * field, struct MonoObject * obj, struct MonoObject * value)
{
  struct MonoClass * D.30182;
  struct MonoImage * D.30183;
  struct MonoAssembly * D.30184;
  int D.30185;
  struct MonoException * D.30188;
  <unnamed type> D.30189;
  int D.30192;
  unsigned char D.30195;
  unsigned char D.30196;
  unsigned char D.30199;
  int D.30200;
  struct MonoGenericInst * D.30203;
  unsigned char D.30204;
  unsigned char D.30205;
  _Bool D.30206;
  long int D.30207;
  long int D.30208;
  struct MonoClass * D.30211;
  int D.30212;
  struct MonoDomain * D.30215;
  void * D.30216;
  struct MonoClass * D.30218;
  unsigned char D.30219;
  unsigned char D.30220;
  short unsigned int D.30225;
  int D.30226;
  int D.30227;
  struct MonoVTable * D.30230;
  struct MonoDomain * D.30231;
  struct MonoClass * D.30232;
  unsigned char D.30233;
  unsigned char D.30234;
  struct MonoError error;
  struct MonoClassField * cf;
  struct MonoType * type;
  gchar * v;

  try
    {
      cf = field->field;
      D.30182 = field->klass;
      D.30183 = D.30182->image;
      D.30184 = D.30183->assembly;
      D.30185 = D.30184->ref_only;
      if (D.30185 != 0) goto <D.30186>; else goto <D.30187>;
      <D.30186>:
      D.30188 = mono_get_exception_invalid_operation ("It is illegal to set the value on a field on a type loaded using the ReflectionOnly methods.");
      mono_raise_exception (D.30188);
      <D.30187>:
      D.30189 = mono_security_get_mode ();
      if (D.30189 == 1) goto <D.30190>; else goto <D.30191>;
      <D.30190>:
      mono_security_core_clr_ensure_reflection_access_field (cf);
      <D.30191>:
      type = mono_field_get_type_checked (cf, &error);
      D.30192 = mono_error_ok (&error);
      if (D.30192 == 0) goto <D.30193>; else goto <D.30194>;
      <D.30193>:
      mono_error_raise_exception (&error);
      <D.30194>:
      v = value;
      D.30195 = BIT_FIELD_REF <*type, 8, 56>;
      D.30196 = D.30195 & 64;
      if (D.30196 == 0) goto <D.30197>; else goto <D.30198>;
      <D.30197>:
      D.30199 = type->type;
      D.30200 = (int) D.30199;
      switch (D.30200) <default: <D.23679>, case 2: <D.23655>, case 3: <D.23658>, case 4: <D.23654>, case 5: <D.23653>, case 6: <D.23657>, case 7: <D.23656>, case 8: <D.23662>, case 9: <D.23661>, case 10: <D.23665>, case 11: <D.23664>, case 12: <D.23663>, case 13: <D.23666>, case 14: <D.23670>, case 15: <D.23668>, case 17: <D.23667>, case 18: <D.23672>, case 20: <D.23673>, case 21: <D.23675>, case 24: <D.23660>, case 25: <D.23659>, case 28: <D.23671>, case 29: <D.23674>>
      <D.23653>:
      <D.23654>:
      <D.23655>:
      <D.23656>:
      <D.23657>:
      <D.23658>:
      <D.23659>:
      <D.23660>:
      <D.23661>:
      <D.23662>:
      <D.23663>:
      <D.23664>:
      <D.23665>:
      <D.23666>:
      <D.23667>:
      <D.23668>:
      if (v != 0B) goto <D.30201>; else goto <D.30202>;
      <D.30201>:
      v = v + 8;
      <D.30202>:
      goto <D.23669>;
      <D.23670>:
      <D.23671>:
      <D.23672>:
      <D.23673>:
      <D.23674>:
      goto <D.23669>;
      <D.23675>:
      {
        struct MonoGenericClass * gclass;

        gclass = type->data.generic_class;
        D.30203 = gclass->context.class_inst;
        D.30204 = BIT_FIELD_REF <*D.30203, 8, 48>;
        D.30205 = D.30204 & 64;
        D.30206 = D.30205 != 0;
        D.30207 = (long int) D.30206;
        D.30208 = __builtin_expect (D.30207, 0);
        if (D.30208 != 0) goto <D.30209>; else goto <D.30210>;
        <D.30209>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1825, "!gclass->context.class_inst->is_open");
        <D.30210>:
        D.30211 = mono_class_from_mono_type (type);
        D.30212 = mono_class_is_nullable (D.30211);
        if (D.30212 != 0) goto <D.30213>; else goto <D.30214>;
        <D.30213>:
        {
          struct MonoClass * nklass;
          struct MonoObject * nullable;

          nklass = mono_class_from_mono_type (type);
          D.30215 = mono_domain_get ();
          nullable = mono_object_new (D.30215, nklass);
          D.30216 = mono_object_unbox (nullable);
          mono_nullable_init (D.30216, value, nklass);
          v = mono_object_unbox (nullable);
        }
        goto <D.30217>;
        <D.30214>:
        D.30218 = gclass->container_class;
        D.30219 = BIT_FIELD_REF <*D.30218, 8, 160>;
        D.30220 = D.30219 & 8;
        if (D.30220 != 0) goto <D.30221>; else goto <D.30222>;
        <D.30221>:
        if (v != 0B) goto <D.30223>; else goto <D.30224>;
        <D.30223>:
        v = v + 8;
        <D.30224>:
        <D.30222>:
        <D.30217>:
        goto <D.23669>;
      }
      <D.23679>:
      D.30199 = type->type;
      D.30200 = (int) D.30199;
      monoeg_g_log (0B, 4, "type 0x%x not handled in ves_icall_FieldInfo_SetValueInternal", D.30200);
      <D.23680>:
      goto <D.23680>;
      return;
      <D.23669>:
      <D.30198>:
      D.30225 = type->attrs;
      D.30226 = (int) D.30225;
      D.30227 = D.30226 & 16;
      if (D.30227 != 0) goto <D.30228>; else goto <D.30229>;
      <D.30228>:
      {
        struct MonoVTable * vtable;

        D.30230 = MEM[(struct MonoObject *)field].vtable;
        D.30231 = D.30230->domain;
        D.30232 = cf->parent;
        vtable = mono_class_vtable_full (D.30231, D.30232, 1);
        D.30233 = BIT_FIELD_REF <*vtable, 8, 184>;
        D.30234 = D.30233 & 2;
        if (D.30234 == 0) goto <D.30235>; else goto <D.30236>;
        <D.30235>:
        mono_runtime_class_init (vtable);
        <D.30236>:
        mono_field_static_set_value (vtable, cf, v);
      }
      goto <D.30237>;
      <D.30229>:
      mono_field_set_value (obj, cf, v);
      <D.30237>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_MonoField_ResolveType (struct MonoReflectionField * ref_field)
{
  int D.30239;
  struct MonoReflectionType * D.30242;
  struct MonoVTable * D.30243;
  struct MonoDomain * D.30244;
  struct MonoError error;
  struct MonoClassField * field;
  struct MonoType * type;

  try
    {
      field = ref_field->field;
      type = mono_field_get_type_checked (field, &error);
      D.30239 = mono_error_ok (&error);
      if (D.30239 == 0) goto <D.30240>; else goto <D.30241>;
      <D.30240>:
      mono_error_raise_exception (&error);
      <D.30241>:
      D.30243 = MEM[(struct MonoObject *)ref_field].vtable;
      D.30244 = D.30243->domain;
      D.30242 = mono_type_get_object (D.30244, type);
      return D.30242;
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_MonoField_GetValueInternal (struct MonoReflectionField * field, struct MonoObject * obj)
{
  struct MonoVTable * D.30247;
  struct MonoImage * D.30248;
  struct MonoAssembly * D.30249;
  int D.30250;
  struct MonoException * D.30253;
  <unnamed type> D.30254;
  struct MonoObject * D.30257;
  struct MonoClass * fklass;
  struct MonoClassField * cf;
  struct MonoDomain * domain;

  fklass = field->klass;
  cf = field->field;
  D.30247 = MEM[(struct MonoObject *)field].vtable;
  domain = D.30247->domain;
  D.30248 = fklass->image;
  D.30249 = D.30248->assembly;
  D.30250 = D.30249->ref_only;
  if (D.30250 != 0) goto <D.30251>; else goto <D.30252>;
  <D.30251>:
  D.30253 = mono_get_exception_invalid_operation ("It is illegal to get the value on a field on a type loaded using the ReflectionOnly methods.");
  mono_raise_exception (D.30253);
  <D.30252>:
  D.30254 = mono_security_get_mode ();
  if (D.30254 == 1) goto <D.30255>; else goto <D.30256>;
  <D.30255>:
  mono_security_core_clr_ensure_reflection_access_field (cf);
  <D.30256>:
  D.30257 = mono_field_get_value_object (domain, cf, obj);
  return D.30257;
}


ves_icall_MonoField_GetRawConstantValue (struct MonoReflectionField * this)
{
  struct MonoVTable * D.30259;
  struct MonoClass * D.30260;
  int D.30261;
  short unsigned int D.30264;
  signed short D.30265;
  struct MonoException * D.30268;
  struct MonoImage * D.30269;
  unsigned char D.30270;
  unsigned char D.30271;
  struct MonoException * D.30276;
  <unnamed type> def_type.101;
  unsigned char D.30278;
  struct MonoObject * o.102;
  struct MonoObject * o.103;
  struct MonoObject * D.30281;
  struct MonoObject * o;
  struct MonoClassField * field;
  struct MonoClass * klass;
  struct MonoDomain * domain;
  gchar * v;
  MonoTypeEnum def_type;
  const char * def_value;
  struct MonoType * t;
  struct MonoError error;

  try
    {
      o = 0B;
      field = this->field;
      D.30259 = MEM[(struct MonoObject *)this].vtable;
      domain = D.30259->domain;
      D.30260 = field->parent;
      mono_class_init (D.30260);
      t = mono_field_get_type_checked (field, &error);
      D.30261 = mono_error_ok (&error);
      if (D.30261 == 0) goto <D.30262>; else goto <D.30263>;
      <D.30262>:
      mono_error_raise_exception (&error);
      <D.30263>:
      D.30264 = t->attrs;
      D.30265 = (signed short) D.30264;
      if (D.30265 >= 0) goto <D.30266>; else goto <D.30267>;
      <D.30266>:
      D.30268 = mono_get_exception_invalid_operation (0B);
      mono_raise_exception (D.30268);
      <D.30267>:
      D.30260 = field->parent;
      D.30269 = D.30260->image;
      D.30270 = BIT_FIELD_REF <*D.30269, 8, 128>;
      D.30271 = D.30270 & 8;
      if (D.30271 != 0) goto <D.30272>; else goto <D.30273>;
      <D.30272>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 1890);
      <D.30273>:
      def_value = mono_class_get_field_default_value (field, &def_type);
      if (def_value == 0B) goto <D.30274>; else goto <D.30275>;
      <D.30274>:
      D.30276 = mono_get_exception_invalid_operation (0B);
      mono_raise_exception (D.30276);
      <D.30275>:
      def_type.101 = def_type;
      switch (def_type.101) <default: <D.23712>, case 2: <D.23696>, case 3: <D.23699>, case 4: <D.23695>, case 5: <D.23694>, case 6: <D.23698>, case 7: <D.23697>, case 8: <D.23703>, case 9: <D.23702>, case 10: <D.23706>, case 11: <D.23705>, case 12: <D.23704>, case 13: <D.23707>, case 14: <D.23710>, case 18: <D.23711>, case 24: <D.23701>, case 25: <D.23700>>
      <D.23694>:
      <D.23695>:
      <D.23696>:
      <D.23697>:
      <D.23698>:
      <D.23699>:
      <D.23700>:
      <D.23701>:
      <D.23702>:
      <D.23703>:
      <D.23704>:
      <D.23705>:
      <D.23706>:
      <D.23707>:
      {
        struct MonoType * t;

        t = monoeg_malloc0 (8);
        def_type.101 = def_type;
        D.30278 = (unsigned char) def_type.101;
        t->type = D.30278;
        klass = mono_class_from_mono_type (t);
        monoeg_g_free (t);
        o.102 = mono_object_new (domain, klass);
        o = o.102;
        o.103 = o;
        v = o.103 + 8;
        def_type.101 = def_type;
        mono_get_constant_value_from_blob (domain, def_type.101, def_value, v);
        goto <D.23709>;
      }
      <D.23710>:
      <D.23711>:
      def_type.101 = def_type;
      mono_get_constant_value_from_blob (domain, def_type.101, def_value, &o);
      goto <D.23709>;
      <D.23712>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 1930);
      <D.23709>:
      D.30281 = o;
      return D.30281;
    }
  finally
    {
      o = {CLOBBER};
      def_type = {CLOBBER};
      error = {CLOBBER};
    }
}


ves_icall_MonoField_GetParentType (struct MonoReflectionField * field, MonoBoolean declaring)
{
  struct MonoClass * iftmp.104;
  struct MonoClassField * D.30287;
  struct MonoReflectionType * D.30289;
  struct MonoVTable * D.30290;
  struct MonoDomain * D.30291;
  struct MonoType * D.30292;
  struct MonoClass * parent;

  if (declaring != 0) goto <D.30285>; else goto <D.30286>;
  <D.30285>:
  D.30287 = field->field;
  iftmp.104 = D.30287->parent;
  goto <D.30288>;
  <D.30286>:
  iftmp.104 = field->klass;
  <D.30288>:
  parent = iftmp.104;
  D.30290 = MEM[(struct MonoObject *)field].vtable;
  D.30291 = D.30290->domain;
  D.30292 = &parent->byval_arg;
  D.30289 = mono_type_get_object (D.30291, D.30292);
  return D.30289;
}


ves_icall_MonoField_GetFieldOffset (struct MonoReflectionField * field)
{
  struct MonoClassField * D.30294;
  unsigned char D.30295;
  unsigned char D.30296;
  gint32 D.30299;
  int D.30300;
  unsigned int D.30301;
  unsigned int D.30302;
  struct MonoClass * parent;

  D.30294 = field->field;
  parent = D.30294->parent;
  D.30295 = BIT_FIELD_REF <*parent, 8, 160>;
  D.30296 = D.30295 & 4;
  if (D.30296 == 0) goto <D.30297>; else goto <D.30298>;
  <D.30297>:
  mono_class_init (parent);
  <D.30298>:
  D.30294 = field->field;
  D.30300 = D.30294->offset;
  D.30301 = (unsigned int) D.30300;
  D.30302 = D.30301 + 4294967288;
  D.30299 = (gint32) D.30302;
  return D.30299;
}


ves_icall_get_event_info (struct MonoReflectionMonoEvent * event, struct MonoEventInfo * info)
{
  struct MonoVTable * D.30304;
  struct MonoReflectionType * * D.30305;
  struct MonoClass * D.30306;
  struct MonoType * D.30307;
  struct MonoReflectionType * D.30308;
  struct MonoReflectionType * * D.30309;
  struct MonoEvent * D.30310;
  struct MonoClass * D.30311;
  struct MonoType * D.30312;
  struct MonoReflectionType * D.30313;
  struct MonoString * * D.30314;
  const char * D.30315;
  struct MonoString * D.30316;
  unsigned int D.30317;
  struct MonoReflectionMethod * * D.30318;
  struct MonoObject * iftmp.105;
  struct MonoMethod * D.30320;
  struct MonoReflectionMethod * * D.30324;
  struct MonoObject * iftmp.106;
  struct MonoMethod * D.30326;
  struct MonoReflectionMethod * * D.30330;
  struct MonoObject * iftmp.107;
  struct MonoMethod * D.30332;
  struct MonoMethod * * D.30336;
  unsigned int n.108;
  unsigned int D.30340;
  struct MonoMethod * * D.30341;
  struct MonoMethod * D.30342;
  struct MonoArray * * D.30343;
  struct MonoClass * D.30344;
  unsigned int n.109;
  struct MonoArray * D.30346;
  struct MonoArray * D.30347;
  unsigned int i.110;
  unsigned int i.111;
  unsigned int D.30350;
  struct MonoMethod * * D.30351;
  struct MonoMethod * D.30352;
  struct MonoReflectionMethod * D.30353;
  struct MonoDomain * domain;

  D.30304 = MEM[(struct MonoObject *)event].vtable;
  domain = D.30304->domain;
  D.30305 = &info->reflected_type;
  D.30306 = event->klass;
  D.30307 = &D.30306->byval_arg;
  D.30308 = mono_type_get_object (domain, D.30307);
  mono_gc_wbarrier_generic_store (D.30305, D.30308);
  D.30309 = &info->declaring_type;
  D.30310 = event->event;
  D.30311 = D.30310->parent;
  D.30312 = &D.30311->byval_arg;
  D.30313 = mono_type_get_object (domain, D.30312);
  mono_gc_wbarrier_generic_store (D.30309, D.30313);
  D.30314 = &info->name;
  D.30310 = event->event;
  D.30315 = D.30310->name;
  D.30316 = mono_string_new (domain, D.30315);
  mono_gc_wbarrier_generic_store (D.30314, D.30316);
  D.30310 = event->event;
  D.30317 = D.30310->attrs;
  info->attrs = D.30317;
  D.30318 = &info->add_method;
  D.30310 = event->event;
  D.30320 = D.30310->add;
  if (D.30320 != 0B) goto <D.30321>; else goto <D.30322>;
  <D.30321>:
  D.30310 = event->event;
  D.30320 = D.30310->add;
  iftmp.105 = mono_method_get_object (domain, D.30320, 0B);
  goto <D.30323>;
  <D.30322>:
  iftmp.105 = 0B;
  <D.30323>:
  mono_gc_wbarrier_generic_store (D.30318, iftmp.105);
  D.30324 = &info->remove_method;
  D.30310 = event->event;
  D.30326 = D.30310->remove;
  if (D.30326 != 0B) goto <D.30327>; else goto <D.30328>;
  <D.30327>:
  D.30310 = event->event;
  D.30326 = D.30310->remove;
  iftmp.106 = mono_method_get_object (domain, D.30326, 0B);
  goto <D.30329>;
  <D.30328>:
  iftmp.106 = 0B;
  <D.30329>:
  mono_gc_wbarrier_generic_store (D.30324, iftmp.106);
  D.30330 = &info->raise_method;
  D.30310 = event->event;
  D.30332 = D.30310->raise;
  if (D.30332 != 0B) goto <D.30333>; else goto <D.30334>;
  <D.30333>:
  D.30310 = event->event;
  D.30332 = D.30310->raise;
  iftmp.107 = mono_method_get_object (domain, D.30332, 0B);
  goto <D.30335>;
  <D.30334>:
  iftmp.107 = 0B;
  <D.30335>:
  mono_gc_wbarrier_generic_store (D.30330, iftmp.107);
  D.30310 = event->event;
  D.30336 = D.30310->other;
  if (D.30336 != 0B) goto <D.30337>; else goto <D.30338>;
  <D.30337>:
  {
    int i;
    int n;

    n = 0;
    goto <D.23745>;
    <D.23744>:
    n = n + 1;
    <D.23745>:
    D.30310 = event->event;
    D.30336 = D.30310->other;
    n.108 = (unsigned int) n;
    D.30340 = n.108 * 4;
    D.30341 = D.30336 + D.30340;
    D.30342 = *D.30341;
    if (D.30342 != 0B) goto <D.23744>; else goto <D.23746>;
    <D.23746>:
    D.30343 = &info->other_methods;
    D.30344 = mono_defaults.method_info_class;
    n.109 = (unsigned int) n;
    D.30346 = mono_array_new (domain, D.30344, n.109);
    mono_gc_wbarrier_generic_store (D.30343, D.30346);
    i = 0;
    goto <D.23749>;
    <D.23748>:
    {
      void * * __p;

      D.30347 = info->other_methods;
      i.110 = (unsigned int) i;
      __p = mono_array_addr_with_size (D.30347, 4, i.110);
      D.30347 = info->other_methods;
      D.30310 = event->event;
      D.30336 = D.30310->other;
      i.111 = (unsigned int) i;
      D.30350 = i.111 * 4;
      D.30351 = D.30336 + D.30350;
      D.30352 = *D.30351;
      D.30353 = mono_method_get_object (domain, D.30352, 0B);
      mono_gc_wbarrier_set_arrayref (D.30347, __p, D.30353);
    }
    i = i + 1;
    <D.23749>:
    if (i < n) goto <D.23748>; else goto <D.23750>;
    <D.23750>:
  }
  <D.30338>:
}


ves_icall_InternalInvoke (struct MonoReflectionMethod * method, struct MonoObject * this, struct MonoArray * params, struct MonoException * * exc)
{
  <unnamed type> D.30354;
  short unsigned int D.30357;
  int D.30358;
  int D.30359;
  struct MonoVTable * D.30362;
  struct MonoDomain * D.30363;
  struct MonoClass * D.30364;
  struct MonoVTable * D.30365;
  struct MonoException * D.30368;
  struct MonoObject * D.30369;
  struct MonoObject * D.30372;
  struct MonoClass * D.30375;
  struct MonoImage * D.30376;
  struct MonoException * D.30377;
  unsigned char D.30378;
  unsigned char D.30379;
  int D.24049;
  int iftmp.112;
  int D.24048;
  const char[6] * D.30386;
  unsigned char D.30387;
  int D.30388;
  unsigned char D.30389;
  int D.30390;
  _Bool D.30391;
  _Bool D.30392;
  _Bool D.30393;
  const unsigned char * D.30396;
  unsigned char D.30397;
  int D.30398;
  const unsigned char * D.30399;
  unsigned char D.30400;
  int D.30401;
  _Bool D.30402;
  _Bool D.30403;
  const unsigned char * D.30406;
  unsigned char D.30407;
  int D.30408;
  const unsigned char * D.30409;
  unsigned char D.30410;
  int D.30411;
  _Bool D.30412;
  _Bool D.30413;
  const unsigned char * D.30416;
  unsigned char D.30417;
  int D.30418;
  const unsigned char * D.30419;
  unsigned char D.30420;
  int D.30421;
  const char * D.30423;
  unsigned char D.30426;
  unsigned char D.30427;
  struct MonoException * D.30430;
  struct MonoType * D.30431;
  unsigned char D.30432;
  unsigned char D.30433;
  struct MonoException * D.30436;
  int iftmp.113;
  unsigned int D.30440;
  short unsigned int D.30442;
  int D.30443;
  struct MonoException * D.30446;
  unsigned int D.30447;
  unsigned int D.30448;
  int D.24058;
  int iftmp.114;
  int D.24057;
  unsigned char D.30454;
  int D.30455;
  _Bool D.30456;
  _Bool D.30457;
  _Bool D.30458;
  const unsigned char * D.30461;
  unsigned char D.30462;
  int D.30463;
  _Bool D.30464;
  _Bool D.30465;
  const unsigned char * D.30468;
  unsigned char D.30469;
  int D.30470;
  _Bool D.30471;
  _Bool D.30472;
  const unsigned char * D.30475;
  unsigned char D.30476;
  int D.30477;
  struct MonoException * D.30483;
  struct MonoAssembly * D.30484;
  int D.30485;
  struct MonoException * D.30488;
  unsigned char D.30489;
  unsigned char D.30490;
  int D.30493;
  struct MonoException * D.30496;
  unsigned char D.30497;
  int D.24067;
  int iftmp.115;
  int D.24066;
  unsigned char D.30503;
  int D.30504;
  _Bool D.30505;
  _Bool D.30506;
  _Bool D.30507;
  const unsigned char * D.30510;
  unsigned char D.30511;
  int D.30512;
  _Bool D.30513;
  _Bool D.30514;
  const unsigned char * D.30517;
  unsigned char D.30518;
  int D.30519;
  _Bool D.30520;
  _Bool D.30521;
  const unsigned char * D.30524;
  unsigned char D.30525;
  int D.30526;
  unsigned int D.30530;
  unsigned int pcount.116;
  unsigned int D.30532;
  unsigned int i.117;
  unsigned int D.30534;
  uintptr_t * D.30535;
  unsigned int i.118;
  char * D.30537;
  void * D.30538;
  int32_t * D.30539;
  int D.30540;
  unsigned int D.30541;
  int D.30542;
  int D.30546;
  _Bool D.30547;
  long int D.30548;
  long int D.30549;
  unsigned int D.30552;
  unsigned int D.30553;
  struct MonoVTable * D.30554;
  struct MonoDomain * D.30555;
  struct MonoMethod * m;
  struct MonoMethodSignature * sig;
  struct MonoImage * image;
  int pcount;
  void * obj;

  m = method->method;
  sig = mono_method_signature (m);
  obj = this;
  *exc = 0B;
  D.30354 = mono_security_get_mode ();
  if (D.30354 == 1) goto <D.30355>; else goto <D.30356>;
  <D.30355>:
  mono_security_core_clr_ensure_reflection_access_method (m);
  <D.30356>:
  D.30357 = m->flags;
  D.30358 = (int) D.30357;
  D.30359 = D.30358 & 16;
  if (D.30359 == 0) goto <D.30360>; else goto <D.30361>;
  <D.30360>:
  D.30362 = MEM[(struct MonoObject *)method].vtable;
  D.30363 = D.30362->domain;
  D.30364 = m->klass;
  D.30365 = mono_class_vtable_full (D.30363, D.30364, 0);
  if (D.30365 == 0B) goto <D.30366>; else goto <D.30367>;
  <D.30366>:
  D.30364 = m->klass;
  D.30368 = mono_class_get_exception_for_failure (D.30364);
  mono_gc_wbarrier_generic_store (exc, D.30368);
  D.30369 = 0B;
  return D.30369;
  <D.30367>:
  if (this != 0B) goto <D.30370>; else goto <D.30371>;
  <D.30370>:
  D.30364 = m->klass;
  D.30372 = mono_object_isinst (this, D.30364);
  if (D.30372 == 0B) goto <D.30373>; else goto <D.30374>;
  <D.30373>:
  {
    char * this_name;
    char * target_name;
    char * msg;

    D.30375 = mono_object_get_class (this);
    this_name = mono_type_get_full_name (D.30375);
    D.30364 = m->klass;
    target_name = mono_type_get_full_name (D.30364);
    msg = monoeg_g_strdup_printf ("Object of type \'%s\' doesn\'t match target type \'%s\'", this_name, target_name);
    D.30376 = mono_defaults.corlib;
    D.30377 = mono_exception_from_name_msg (D.30376, "System.Reflection", "TargetException", msg);
    mono_gc_wbarrier_generic_store (exc, D.30377);
    monoeg_g_free (msg);
    monoeg_g_free (target_name);
    monoeg_g_free (this_name);
    D.30369 = 0B;
    return D.30369;
  }
  <D.30374>:
  m = mono_object_get_virtual_method (this, m);
  D.30364 = m->klass;
  D.30378 = BIT_FIELD_REF <*D.30364, 8, 160>;
  D.30379 = D.30378 & 8;
  if (D.30379 != 0) goto <D.30380>; else goto <D.30381>;
  <D.30380>:
  obj = mono_object_unbox (this);
  <D.30381>:
  goto <D.30382>;
  <D.30371>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.30384>; else goto <D.30385>;
    <D.30384>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = m->name;
      D.30386 = ".ctor";
      D.30387 = MEM[(const unsigned char *)D.30386];
      D.30388 = (int) D.30387;
      D.30389 = *__s2;
      D.30390 = (int) D.30389;
      __result = D.30388 - D.30390;
      {
        D.30391 = __s2_len != 0;
        D.30392 = __result == 0;
        D.30393 = D.30391 & D.30392;
        if (D.30393 != 0) goto <D.30394>; else goto <D.30395>;
        <D.30394>:
        D.30396 = &MEM[(void *)".ctor" + 1B];
        D.30397 = *D.30396;
        D.30398 = (int) D.30397;
        D.30399 = __s2 + 1;
        D.30400 = *D.30399;
        D.30401 = (int) D.30400;
        __result = D.30398 - D.30401;
        D.30402 = __s2_len > 1;
        D.30392 = __result == 0;
        D.30403 = D.30402 & D.30392;
        if (D.30403 != 0) goto <D.30404>; else goto <D.30405>;
        <D.30404>:
        D.30406 = &MEM[(void *)".ctor" + 2B];
        D.30407 = *D.30406;
        D.30408 = (int) D.30407;
        D.30409 = __s2 + 2;
        D.30410 = *D.30409;
        D.30411 = (int) D.30410;
        __result = D.30408 - D.30411;
        D.30412 = __s2_len > 2;
        D.30392 = __result == 0;
        D.30413 = D.30412 & D.30392;
        if (D.30413 != 0) goto <D.30414>; else goto <D.30415>;
        <D.30414>:
        D.30416 = &MEM[(void *)".ctor" + 3B];
        D.30417 = *D.30416;
        D.30418 = (int) D.30417;
        D.30419 = __s2 + 3;
        D.30420 = *D.30419;
        D.30421 = (int) D.30420;
        __result = D.30418 - D.30421;
        <D.30415>:
        <D.30405>:
        <D.30395>:
      }
      D.24048 = __result;
    }
    iftmp.112 = -D.24048;
    goto <D.30422>;
    <D.30385>:
    D.30423 = m->name;
    iftmp.112 = __builtin_strcmp (D.30423, ".ctor");
    <D.30422>:
    D.24049 = iftmp.112;
  }
  if (D.24049 != 0) goto <D.30424>; else goto <D.30425>;
  <D.30424>:
  D.30426 = BIT_FIELD_REF <*m, 8, 160>;
  D.30427 = D.30426 & 124;
  if (D.30427 == 0) goto <D.30428>; else goto <D.30429>;
  <D.30428>:
  D.30376 = mono_defaults.corlib;
  D.30430 = mono_exception_from_name_msg (D.30376, "System.Reflection", "TargetException", "Non-static method requires a target.");
  mono_gc_wbarrier_generic_store (exc, D.30430);
  D.30369 = 0B;
  return D.30369;
  <D.30429>:
  <D.30425>:
  <D.30382>:
  <D.30361>:
  D.30431 = sig->ret;
  D.30432 = BIT_FIELD_REF <*D.30431, 8, 56>;
  D.30433 = D.30432 & 64;
  if (D.30433 != 0) goto <D.30434>; else goto <D.30435>;
  <D.30434>:
  D.30376 = mono_defaults.corlib;
  D.30436 = mono_exception_from_name_msg (D.30376, "System", "NotSupportedException", "Cannot invoke method returning ByRef type via reflection");
  mono_gc_wbarrier_generic_store (exc, D.30436);
  D.30369 = 0B;
  return D.30369;
  <D.30435>:
  if (params != 0B) goto <D.30438>; else goto <D.30439>;
  <D.30438>:
  D.30440 = mono_array_length (params);
  iftmp.113 = (int) D.30440;
  goto <D.30441>;
  <D.30439>:
  iftmp.113 = 0;
  <D.30441>:
  pcount = iftmp.113;
  D.30442 = sig->param_count;
  D.30443 = (int) D.30442;
  if (D.30443 != pcount) goto <D.30444>; else goto <D.30445>;
  <D.30444>:
  D.30376 = mono_defaults.corlib;
  D.30446 = mono_exception_from_name (D.30376, "System.Reflection", "TargetParameterCountException");
  mono_gc_wbarrier_generic_store (exc, D.30446);
  D.30369 = 0B;
  return D.30369;
  <D.30445>:
  D.30364 = m->klass;
  D.30447 = D.30364->flags;
  D.30448 = D.30447 & 128;
  if (D.30448 != 0) goto <D.30449>; else goto <D.30450>;
  <D.30449>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.30452>; else goto <D.30453>;
    <D.30452>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = m->name;
      D.30386 = ".ctor";
      D.30387 = MEM[(const unsigned char *)D.30386];
      D.30388 = (int) D.30387;
      D.30454 = *__s2;
      D.30455 = (int) D.30454;
      __result = D.30388 - D.30455;
      {
        D.30456 = __s2_len != 0;
        D.30457 = __result == 0;
        D.30458 = D.30456 & D.30457;
        if (D.30458 != 0) goto <D.30459>; else goto <D.30460>;
        <D.30459>:
        D.30396 = &MEM[(void *)".ctor" + 1B];
        D.30397 = *D.30396;
        D.30398 = (int) D.30397;
        D.30461 = __s2 + 1;
        D.30462 = *D.30461;
        D.30463 = (int) D.30462;
        __result = D.30398 - D.30463;
        D.30464 = __s2_len > 1;
        D.30457 = __result == 0;
        D.30465 = D.30464 & D.30457;
        if (D.30465 != 0) goto <D.30466>; else goto <D.30467>;
        <D.30466>:
        D.30406 = &MEM[(void *)".ctor" + 2B];
        D.30407 = *D.30406;
        D.30408 = (int) D.30407;
        D.30468 = __s2 + 2;
        D.30469 = *D.30468;
        D.30470 = (int) D.30469;
        __result = D.30408 - D.30470;
        D.30471 = __s2_len > 2;
        D.30457 = __result == 0;
        D.30472 = D.30471 & D.30457;
        if (D.30472 != 0) goto <D.30473>; else goto <D.30474>;
        <D.30473>:
        D.30416 = &MEM[(void *)".ctor" + 3B];
        D.30417 = *D.30416;
        D.30418 = (int) D.30417;
        D.30475 = __s2 + 3;
        D.30476 = *D.30475;
        D.30477 = (int) D.30476;
        __result = D.30418 - D.30477;
        <D.30474>:
        <D.30467>:
        <D.30460>:
      }
      D.24057 = __result;
    }
    iftmp.114 = -D.24057;
    goto <D.30478>;
    <D.30453>:
    D.30423 = m->name;
    iftmp.114 = __builtin_strcmp (D.30423, ".ctor");
    <D.30478>:
    D.24058 = iftmp.114;
  }
  if (D.24058 == 0) goto <D.30479>; else goto <D.30480>;
  <D.30479>:
  if (this == 0B) goto <D.30481>; else goto <D.30482>;
  <D.30481>:
  D.30376 = mono_defaults.corlib;
  D.30483 = mono_exception_from_name_msg (D.30376, "System.Reflection", "TargetException", "Cannot invoke constructor of an abstract class.");
  mono_gc_wbarrier_generic_store (exc, D.30483);
  D.30369 = 0B;
  return D.30369;
  <D.30482>:
  <D.30480>:
  <D.30450>:
  D.30364 = m->klass;
  image = D.30364->image;
  D.30484 = image->assembly;
  D.30485 = D.30484->ref_only;
  if (D.30485 != 0) goto <D.30486>; else goto <D.30487>;
  <D.30486>:
  D.30488 = mono_get_exception_invalid_operation ("It is illegal to invoke a method on a type loaded using the ReflectionOnly api.");
  mono_gc_wbarrier_generic_store (exc, D.30488);
  D.30369 = 0B;
  return D.30369;
  <D.30487>:
  D.30489 = BIT_FIELD_REF <*image, 8, 128>;
  D.30490 = D.30489 & 8;
  if (D.30490 != 0) goto <D.30491>; else goto <D.30492>;
  <D.30491>:
  D.30493 = MEM[(struct MonoDynamicImage *)image].run;
  if (D.30493 == 0) goto <D.30494>; else goto <D.30495>;
  <D.30494>:
  D.30496 = mono_get_exception_not_supported ("Cannot invoke a method in a dynamic assembly without run access.");
  mono_gc_wbarrier_generic_store (exc, D.30496);
  D.30369 = 0B;
  return D.30369;
  <D.30495>:
  <D.30492>:
  D.30364 = m->klass;
  D.30497 = D.30364->rank;
  if (D.30497 != 0) goto <D.30498>; else goto <D.30499>;
  <D.30498>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.30501>; else goto <D.30502>;
    <D.30501>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = m->name;
      D.30386 = ".ctor";
      D.30387 = MEM[(const unsigned char *)D.30386];
      D.30388 = (int) D.30387;
      D.30503 = *__s2;
      D.30504 = (int) D.30503;
      __result = D.30388 - D.30504;
      {
        D.30505 = __s2_len != 0;
        D.30506 = __result == 0;
        D.30507 = D.30505 & D.30506;
        if (D.30507 != 0) goto <D.30508>; else goto <D.30509>;
        <D.30508>:
        D.30396 = &MEM[(void *)".ctor" + 1B];
        D.30397 = *D.30396;
        D.30398 = (int) D.30397;
        D.30510 = __s2 + 1;
        D.30511 = *D.30510;
        D.30512 = (int) D.30511;
        __result = D.30398 - D.30512;
        D.30513 = __s2_len > 1;
        D.30506 = __result == 0;
        D.30514 = D.30513 & D.30506;
        if (D.30514 != 0) goto <D.30515>; else goto <D.30516>;
        <D.30515>:
        D.30406 = &MEM[(void *)".ctor" + 2B];
        D.30407 = *D.30406;
        D.30408 = (int) D.30407;
        D.30517 = __s2 + 2;
        D.30518 = *D.30517;
        D.30519 = (int) D.30518;
        __result = D.30408 - D.30519;
        D.30520 = __s2_len > 2;
        D.30506 = __result == 0;
        D.30521 = D.30520 & D.30506;
        if (D.30521 != 0) goto <D.30522>; else goto <D.30523>;
        <D.30522>:
        D.30416 = &MEM[(void *)".ctor" + 3B];
        D.30417 = *D.30416;
        D.30418 = (int) D.30417;
        D.30524 = __s2 + 3;
        D.30525 = *D.30524;
        D.30526 = (int) D.30525;
        __result = D.30418 - D.30526;
        <D.30523>:
        <D.30516>:
        <D.30509>:
      }
      D.24066 = __result;
    }
    iftmp.115 = -D.24066;
    goto <D.30527>;
    <D.30502>:
    D.30423 = m->name;
    iftmp.115 = __builtin_strcmp (D.30423, ".ctor");
    <D.30527>:
    D.24067 = iftmp.115;
  }
  if (D.24067 == 0) goto <D.30528>; else goto <D.30529>;
  <D.30528>:
  {
    int i;
    uintptr_t * lengths;
    intptr_t * lower_bounds;

    D.30530 = mono_array_length (params);
    pcount = (int) D.30530;
    pcount.116 = (unsigned int) pcount;
    D.30532 = pcount.116 * 4;
    lengths = __builtin_alloca (D.30532);
    i = 0;
    goto <D.24072>;
    <D.24071>:
    i.117 = (unsigned int) i;
    D.30534 = i.117 * 4;
    D.30535 = lengths + D.30534;
    i.118 = (unsigned int) i;
    D.30537 = mono_array_addr_with_size (params, 4, i.118);
    D.30538 = MEM[(void * *)D.30537];
    D.30539 = D.30538 + 8;
    D.30540 = *D.30539;
    D.30541 = (unsigned int) D.30540;
    *D.30535 = D.30541;
    i = i + 1;
    <D.24072>:
    if (i < pcount) goto <D.24071>; else goto <D.24073>;
    <D.24073>:
    D.30364 = m->klass;
    D.30497 = D.30364->rank;
    D.30542 = (int) D.30497;
    if (D.30542 == pcount) goto <D.30543>; else goto <D.30544>;
    <D.30543>:
    lower_bounds = 0B;
    goto <D.30545>;
    <D.30544>:
    D.30364 = m->klass;
    D.30497 = D.30364->rank;
    D.30542 = (int) D.30497;
    D.30546 = D.30542 * 2;
    D.30547 = D.30546 != pcount;
    D.30548 = (long int) D.30547;
    D.30549 = __builtin_expect (D.30548, 0);
    if (D.30549 != 0) goto <D.30550>; else goto <D.30551>;
    <D.30550>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2835, "pcount == (m->klass->rank * 2)");
    <D.30551>:
    lower_bounds = lengths;
    D.30364 = m->klass;
    D.30497 = D.30364->rank;
    D.30552 = (unsigned int) D.30497;
    D.30553 = D.30552 * 4;
    lengths = lengths + D.30553;
    <D.30545>:
    D.30554 = MEM[(struct MonoObject *)params].vtable;
    D.30555 = D.30554->domain;
    D.30364 = m->klass;
    D.30369 = mono_array_new_full (D.30555, D.30364, lengths, lower_bounds);
    return D.30369;
  }
  <D.30529>:
  <D.30499>:
  D.30369 = mono_runtime_invoke_array (m, obj, params, 0B);
  return D.30369;
}


ves_icall_MonoMethod_GetGenericMethodDefinition (struct MonoReflectionMethod * method)
{
  struct MonoMethod * D.30557;
  unsigned char D.30558;
  unsigned char D.30559;
  struct MonoReflectionMethod * D.30562;
  unsigned char D.30563;
  unsigned char D.30566;
  unsigned char D.30567;
  struct MonoClass * D.30570;
  struct MonoImage * D.30571;
  unsigned char D.30572;
  unsigned char D.30573;
  struct MonoGHashTable * D.30576;
  struct MonoGenericInst * D.30579;
  struct MonoGenericContext * D.30582;
  struct MonoGenericContext * D.30585;
  struct MonoVTable * D.30586;
  struct MonoDomain * D.30587;
  struct MonoMethodInflated * imethod;
  struct MonoMethod * result;

  D.30557 = method->method;
  D.30558 = BIT_FIELD_REF <*D.30557, 8, 168>;
  D.30559 = D.30558 & 8;
  if (D.30559 != 0) goto <D.30560>; else goto <D.30561>;
  <D.30560>:
  D.30562 = method;
  return D.30562;
  <D.30561>:
  D.30557 = method->method;
  D.30558 = BIT_FIELD_REF <*D.30557, 8, 168>;
  D.30563 = D.30558 & 16;
  if (D.30563 == 0) goto <D.30564>; else goto <D.30565>;
  <D.30564>:
  D.30562 = 0B;
  return D.30562;
  <D.30565>:
  imethod = method->method;
  result = imethod->declaring;
  D.30566 = BIT_FIELD_REF <*result, 8, 168>;
  D.30567 = D.30566 & 8;
  if (D.30567 == 0) goto <D.30568>; else goto <D.30569>;
  <D.30568>:
  D.30562 = 0B;
  return D.30562;
  <D.30569>:
  D.30557 = method->method;
  D.30570 = D.30557->klass;
  D.30571 = D.30570->image;
  D.30572 = BIT_FIELD_REF <*D.30571, 8, 128>;
  D.30573 = D.30572 & 8;
  if (D.30573 != 0) goto <D.30574>; else goto <D.30575>;
  <D.30574>:
  {
    struct MonoDynamicImage * image;
    struct MonoReflectionMethod * res;

    D.30557 = method->method;
    D.30570 = D.30557->klass;
    image = D.30570->image;
    mono_image_lock (image);
    D.30576 = image->generic_def_objects;
    res = mono_g_hash_table_lookup (D.30576, imethod);
    mono_image_unlock (image);
    if (res != 0B) goto <D.30577>; else goto <D.30578>;
    <D.30577>:
    D.30562 = res;
    return D.30562;
    <D.30578>:
  }
  <D.30575>:
  D.30579 = imethod->context.class_inst;
  if (D.30579 != 0B) goto <D.30580>; else goto <D.30581>;
  <D.30580>:
  {
    struct MonoClass * klass;

    klass = MEM[(struct MonoMethod *)imethod].klass;
    D.30582 = mono_class_get_context (klass);
    if (D.30582 != 0B) goto <D.30583>; else goto <D.30584>;
    <D.30583>:
    D.30585 = mono_class_get_context (klass);
    result = mono_class_inflate_generic_method_full (result, klass, D.30585);
    <D.30584>:
  }
  <D.30581>:
  D.30586 = MEM[(struct MonoObject *)method].vtable;
  D.30587 = D.30586->domain;
  D.30562 = mono_method_get_object (D.30587, result, 0B);
  return D.30562;
}


ves_icall_System_Reflection_Module_ResolveTypeToken (struct MonoImage * image, guint32 token, struct MonoArray * type_args, struct MonoArray * method_args, MonoResolveTokenError * error)
{
  unsigned int D.30589;
  int token.119;
  unsigned int table.120;
  unsigned int D.30592;
  _Bool D.30593;
  _Bool D.30594;
  _Bool D.30595;
  struct MonoType * D.30598;
  unsigned char D.30599;
  unsigned char D.30600;
  struct MonoType * iftmp.121;
  struct MonoType * iftmp.122;
  <unnamed-unsigned:24> D.30616;
  int D.30617;
  struct MonoLoaderError * D.30618;
  struct MonoLoaderError * D.30621;
  struct MonoException * D.30622;
  struct MonoClass * klass;
  int table;
  int index;
  struct MonoGenericContext context;

  try
    {
      D.30589 = token >> 24;
      table = (int) D.30589;
      token.119 = (int) token;
      index = token.119 & 16777215;
      *error = 2;
      table.120 = (unsigned int) table;
      D.30592 = table.120 + 4294967295;
      D.30593 = D.30592 > 1;
      D.30594 = table != 27;
      D.30595 = D.30593 & D.30594;
      if (D.30595 != 0) goto <D.30596>; else goto <D.30597>;
      <D.30596>:
      *error = 1;
      D.30598 = 0B;
      return D.30598;
      <D.30597>:
      D.30599 = BIT_FIELD_REF <*image, 8, 128>;
      D.30600 = D.30599 & 8;
      if (D.30600 != 0) goto <D.30601>; else goto <D.30602>;
      <D.30601>:
      table.120 = (unsigned int) table;
      D.30592 = table.120 + 4294967295;
      if (D.30592 <= 1) goto <D.30603>; else goto <D.30604>;
      <D.30603>:
      klass = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
      if (klass != 0B) goto <D.30606>; else goto <D.30607>;
      <D.30606>:
      iftmp.121 = &klass->byval_arg;
      goto <D.30608>;
      <D.30607>:
      iftmp.121 = 0B;
      <D.30608>:
      D.30598 = iftmp.121;
      return D.30598;
      <D.30604>:
      init_generic_context_from_args (&context, type_args, method_args);
      klass = mono_lookup_dynamic_token_class (image, token, 0, 0B, &context);
      if (klass != 0B) goto <D.30610>; else goto <D.30611>;
      <D.30610>:
      iftmp.122 = &klass->byval_arg;
      goto <D.30612>;
      <D.30611>:
      iftmp.122 = 0B;
      <D.30612>:
      D.30598 = iftmp.122;
      return D.30598;
      <D.30602>:
      if (index <= 0) goto <D.30613>; else goto <D.30615>;
      <D.30615>:
      D.30616 = image->tables[table].rows;
      D.30617 = (int) D.30616;
      if (D.30617 < index) goto <D.30613>; else goto <D.30614>;
      <D.30613>:
      *error = 0;
      D.30598 = 0B;
      return D.30598;
      <D.30614>:
      init_generic_context_from_args (&context, type_args, method_args);
      klass = mono_class_get_full (image, token, &context);
      D.30618 = mono_loader_get_last_error ();
      if (D.30618 != 0B) goto <D.30619>; else goto <D.30620>;
      <D.30619>:
      D.30621 = mono_loader_get_last_error ();
      D.30622 = mono_loader_error_prepare_exception (D.30621);
      mono_raise_exception (D.30622);
      <D.30620>:
      if (klass != 0B) goto <D.30623>; else goto <D.30624>;
      <D.30623>:
      D.30598 = &klass->byval_arg;
      return D.30598;
      <D.30624>:
      D.30598 = 0B;
      return D.30598;
    }
  finally
    {
      context = {CLOBBER};
    }
}


init_generic_context_from_args (struct MonoGenericContext * context, struct MonoArray * type_args, struct MonoArray * method_args)
{
  unsigned int D.30629;
  int D.30630;
  char * D.30631;
  struct MonoGenericInst * D.30632;
  unsigned int D.30636;
  int D.30637;
  char * D.30638;
  struct MonoGenericInst * D.30639;

  if (type_args != 0B) goto <D.30627>; else goto <D.30628>;
  <D.30627>:
  D.30629 = mono_array_length (type_args);
  D.30630 = (int) D.30629;
  D.30631 = mono_array_addr_with_size (type_args, 4, 0);
  D.30632 = mono_metadata_get_generic_inst (D.30630, D.30631);
  context->class_inst = D.30632;
  goto <D.30633>;
  <D.30628>:
  context->class_inst = 0B;
  <D.30633>:
  if (method_args != 0B) goto <D.30634>; else goto <D.30635>;
  <D.30634>:
  D.30636 = mono_array_length (method_args);
  D.30637 = (int) D.30636;
  D.30638 = mono_array_addr_with_size (method_args, 4, 0);
  D.30639 = mono_metadata_get_generic_inst (D.30637, D.30638);
  context->method_inst = D.30639;
  goto <D.30640>;
  <D.30635>:
  context->method_inst = 0B;
  <D.30640>:
}


ves_icall_System_Reflection_Module_ResolveStringToken (struct MonoImage * image, guint32 token, MonoResolveTokenError * error)
{
  int token.123;
  unsigned int D.30642;
  struct MonoString * D.30645;
  unsigned char D.30646;
  unsigned char D.30647;
  unsigned int index.124;
  unsigned int D.30654;
  struct MonoDomain * D.30655;
  unsigned int index.125;
  int index;

  token.123 = (int) token;
  index = token.123 & 16777215;
  *error = 2;
  D.30642 = token & 4278190080;
  if (D.30642 != 1879048192) goto <D.30643>; else goto <D.30644>;
  <D.30643>:
  *error = 1;
  D.30645 = 0B;
  return D.30645;
  <D.30644>:
  D.30646 = BIT_FIELD_REF <*image, 8, 128>;
  D.30647 = D.30646 & 8;
  if (D.30647 != 0) goto <D.30648>; else goto <D.30649>;
  <D.30648>:
  D.30645 = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
  return D.30645;
  <D.30649>:
  if (index <= 0) goto <D.30650>; else goto <D.30652>;
  <D.30652>:
  index.124 = (unsigned int) index;
  D.30654 = image->heap_us.size;
  if (index.124 >= D.30654) goto <D.30650>; else goto <D.30651>;
  <D.30650>:
  *error = 0;
  D.30645 = 0B;
  return D.30645;
  <D.30651>:
  D.30655 = mono_domain_get ();
  index.125 = (unsigned int) index;
  D.30645 = mono_ldstr (D.30655, image, index.125);
  return D.30645;
}


ves_icall_System_Reflection_Module_ResolveSignature (struct MonoImage * image, guint32 token, MonoResolveTokenError * error)
{
  unsigned int D.30658;
  int token.126;
  struct MonoArray * D.30662;
  unsigned char D.30663;
  unsigned char D.30664;
  struct MonoTableInfo * D.30670;
  <unnamed-unsigned:24> D.30671;
  int D.30672;
  const struct MonoTableInfo * D.30673;
  int D.30674;
  const char * ptr.127;
  const char * ptr.128;
  struct MonoDomain * D.30677;
  struct MonoClass * D.30678;
  char * D.30679;
  int table;
  int idx;
  struct MonoTableInfo * tables;
  guint32 sig;
  guint32 len;
  const char * ptr;
  struct MonoArray * res;

  try
    {
      D.30658 = token >> 24;
      table = (int) D.30658;
      token.126 = (int) token;
      idx = token.126 & 16777215;
      tables = &image->tables;
      *error = 0;
      if (table != 17) goto <D.30660>; else goto <D.30661>;
      <D.30660>:
      D.30662 = 0B;
      return D.30662;
      <D.30661>:
      D.30663 = BIT_FIELD_REF <*image, 8, 128>;
      D.30664 = D.30663 & 8;
      if (D.30664 != 0) goto <D.30665>; else goto <D.30666>;
      <D.30665>:
      D.30662 = 0B;
      return D.30662;
      <D.30666>:
      if (idx == 0) goto <D.30667>; else goto <D.30669>;
      <D.30669>:
      D.30670 = tables + 204;
      D.30671 = D.30670->rows;
      D.30672 = (int) D.30671;
      if (D.30672 < idx) goto <D.30667>; else goto <D.30668>;
      <D.30667>:
      D.30662 = 0B;
      return D.30662;
      <D.30668>:
      D.30673 = tables + 204;
      D.30674 = idx + -1;
      sig = mono_metadata_decode_row_col (D.30673, D.30674, 0);
      ptr.127 = mono_metadata_blob_heap (image, sig);
      ptr = ptr.127;
      ptr.128 = ptr;
      len = mono_metadata_decode_blob_size (ptr.128, &ptr);
      D.30677 = mono_domain_get ();
      D.30678 = mono_defaults.byte_class;
      res = mono_array_new (D.30677, D.30678, len);
      D.30679 = mono_array_addr_with_size (res, 1, 0);
      ptr.128 = ptr;
      memcpy (D.30679, ptr.128, len);
      D.30662 = res;
      return D.30662;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


ves_icall_System_Reflection_Module_ResolveMethodToken (struct MonoImage * image, guint32 token, struct MonoArray * type_args, struct MonoArray * method_args, MonoResolveTokenError * error)
{
  unsigned int D.30682;
  int token.129;
  _Bool D.30684;
  _Bool D.30685;
  _Bool D.30686;
  struct MonoMethod * D.30691;
  unsigned char D.30692;
  unsigned char D.30693;
  int D.30700;
  <unnamed-unsigned:24> D.30706;
  int D.30707;
  int D.30710;
  struct MonoLoaderError * D.30713;
  struct MonoLoaderError * D.30716;
  struct MonoException * D.30717;
  int table;
  int index;
  struct MonoGenericContext context;
  struct MonoMethod * method;

  try
    {
      D.30682 = token >> 24;
      table = (int) D.30682;
      token.129 = (int) token;
      index = token.129 & 16777215;
      *error = 2;
      D.30684 = table != 6;
      D.30685 = table != 43;
      D.30686 = D.30684 & D.30685;
      if (D.30686 != 0) goto <D.30687>; else goto <D.30688>;
      <D.30687>:
      if (table != 10) goto <D.30689>; else goto <D.30690>;
      <D.30689>:
      *error = 1;
      D.30691 = 0B;
      return D.30691;
      <D.30690>:
      <D.30688>:
      D.30692 = BIT_FIELD_REF <*image, 8, 128>;
      D.30693 = D.30692 & 8;
      if (D.30693 != 0) goto <D.30694>; else goto <D.30695>;
      <D.30694>:
      if (table == 6) goto <D.30696>; else goto <D.30697>;
      <D.30696>:
      D.30691 = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
      return D.30691;
      <D.30697>:
      if (table == 10) goto <D.30698>; else goto <D.30699>;
      <D.30698>:
      D.30700 = mono_memberref_is_method (image, token);
      if (D.30700 == 0) goto <D.30701>; else goto <D.30702>;
      <D.30701>:
      *error = 1;
      D.30691 = 0B;
      return D.30691;
      <D.30702>:
      <D.30699>:
      init_generic_context_from_args (&context, type_args, method_args);
      D.30691 = mono_lookup_dynamic_token_class (image, token, 0, 0B, &context);
      return D.30691;
      <D.30695>:
      if (index <= 0) goto <D.30703>; else goto <D.30705>;
      <D.30705>:
      D.30706 = image->tables[table].rows;
      D.30707 = (int) D.30706;
      if (D.30707 < index) goto <D.30703>; else goto <D.30704>;
      <D.30703>:
      *error = 0;
      D.30691 = 0B;
      return D.30691;
      <D.30704>:
      if (table == 10) goto <D.30708>; else goto <D.30709>;
      <D.30708>:
      D.30710 = mono_memberref_is_method (image, token);
      if (D.30710 == 0) goto <D.30711>; else goto <D.30712>;
      <D.30711>:
      *error = 1;
      D.30691 = 0B;
      return D.30691;
      <D.30712>:
      <D.30709>:
      init_generic_context_from_args (&context, type_args, method_args);
      method = mono_get_method_full (image, token, 0B, &context);
      D.30713 = mono_loader_get_last_error ();
      if (D.30713 != 0B) goto <D.30714>; else goto <D.30715>;
      <D.30714>:
      D.30716 = mono_loader_get_last_error ();
      D.30717 = mono_loader_error_prepare_exception (D.30716);
      mono_raise_exception (D.30717);
      <D.30715>:
      D.30691 = method;
      return D.30691;
    }
  finally
    {
      context = {CLOBBER};
    }
}


mono_memberref_is_method (struct MonoImage * image, guint32 token)
{
  unsigned char D.30720;
  unsigned char D.30721;
  struct MonoTableInfo * D.30724;
  unsigned int D.30725;
  unsigned int D.30726;
  int D.30727;
  unsigned int D.30728;
  const char * sig.130;
  const char * sig.131;
  gboolean D.30731;
  char D.30732;
  _Bool D.30733;
  void * D.30734;
  struct MonoClass * D.30737;
  struct MonoClass * handle_class.132;
  _Bool D.30739;

  D.30720 = BIT_FIELD_REF <*image, 8, 128>;
  D.30721 = D.30720 & 8;
  if (D.30721 == 0) goto <D.30722>; else goto <D.30723>;
  <D.30722>:
  {
    guint32 cols[3];
    const char * sig;

    try
      {
        D.30724 = &image->tables[10];
        D.30725 = token & 16777215;
        D.30726 = D.30725 + 4294967295;
        D.30727 = (int) D.30726;
        mono_metadata_decode_row (D.30724, D.30727, &cols, 3);
        D.30728 = cols[2];
        sig.130 = mono_metadata_blob_heap (image, D.30728);
        sig = sig.130;
        sig.131 = sig;
        mono_metadata_decode_blob_size (sig.131, &sig);
        sig.131 = sig;
        D.30732 = *sig.131;
        D.30733 = D.30732 != 6;
        D.30731 = (gboolean) D.30733;
        return D.30731;
      }
    finally
      {
        cols = {CLOBBER};
        sig = {CLOBBER};
      }
  }
  <D.30723>:
  {
    struct MonoClass * handle_class;

    try
      {
        D.30734 = mono_lookup_dynamic_token_class (image, token, 0, &handle_class, 0B);
        if (D.30734 == 0B) goto <D.30735>; else goto <D.30736>;
        <D.30735>:
        D.30731 = 0;
        return D.30731;
        <D.30736>:
        D.30737 = mono_defaults.methodhandle_class;
        handle_class.132 = handle_class;
        D.30739 = D.30737 == handle_class.132;
        D.30731 = (gboolean) D.30739;
        return D.30731;
      }
    finally
      {
        handle_class = {CLOBBER};
      }
  }
}


ves_icall_System_Reflection_Module_ResolveMemberToken (struct MonoImage * image, guint32 token, struct MonoArray * type_args, struct MonoArray * method_args, MonoResolveTokenError * error)
{
  unsigned int D.30743;
  struct MonoObject * D.30746;
  struct MonoDomain * D.30747;
  struct MonoDomain * D.30750;
  struct MonoClass * D.30751;
  struct MonoDomain * D.30754;
  struct MonoClass * D.30755;
  int D.30756;
  struct MonoDomain * D.30761;
  struct MonoClass * D.30762;
  struct MonoDomain * D.30765;
  struct MonoClass * D.30766;
  int table;

  D.30743 = token >> 24;
  table = (int) D.30743;
  *error = 2;
  switch (table) <default: <D.25206>, case 1: <D.25195>, case 2: <D.25194>, case 4: <D.25201>, case 6: <D.25198>, case 10: <D.25203>, case 27: <D.25196>, case 43: <D.25199>>
  <D.25194>:
  <D.25195>:
  <D.25196>:
  {
    struct MonoType * t;

    t = ves_icall_System_Reflection_Module_ResolveTypeToken (image, token, type_args, method_args, error);
    if (t != 0B) goto <D.30744>; else goto <D.30745>;
    <D.30744>:
    D.30747 = mono_domain_get ();
    D.30746 = mono_type_get_object (D.30747, t);
    return D.30746;
    <D.30745>:
    D.30746 = 0B;
    return D.30746;
  }
  <D.25198>:
  <D.25199>:
  {
    struct MonoMethod * m;

    m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
    if (m != 0B) goto <D.30748>; else goto <D.30749>;
    <D.30748>:
    D.30750 = mono_domain_get ();
    D.30751 = m->klass;
    D.30746 = mono_method_get_object (D.30750, m, D.30751);
    return D.30746;
    <D.30749>:
    D.30746 = 0B;
    return D.30746;
  }
  <D.25201>:
  {
    struct MonoClassField * f;

    f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
    if (f != 0B) goto <D.30752>; else goto <D.30753>;
    <D.30752>:
    D.30754 = mono_domain_get ();
    D.30755 = f->parent;
    D.30746 = mono_field_get_object (D.30754, D.30755, f);
    return D.30746;
    <D.30753>:
    D.30746 = 0B;
    return D.30746;
  }
  <D.25203>:
  D.30756 = mono_memberref_is_method (image, token);
  if (D.30756 != 0) goto <D.30757>; else goto <D.30758>;
  <D.30757>:
  {
    struct MonoMethod * m;

    m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
    if (m != 0B) goto <D.30759>; else goto <D.30760>;
    <D.30759>:
    D.30761 = mono_domain_get ();
    D.30762 = m->klass;
    D.30746 = mono_method_get_object (D.30761, m, D.30762);
    return D.30746;
    <D.30760>:
    D.30746 = 0B;
    return D.30746;
  }
  <D.30758>:
  {
    struct MonoClassField * f;

    f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
    if (f != 0B) goto <D.30763>; else goto <D.30764>;
    <D.30763>:
    D.30765 = mono_domain_get ();
    D.30766 = f->parent;
    D.30746 = mono_field_get_object (D.30765, D.30766, f);
    return D.30746;
    <D.30764>:
    D.30746 = 0B;
    return D.30746;
  }
  <D.25206>:
  *error = 1;
  D.30746 = 0B;
  return D.30746;
}


ves_icall_System_Reflection_Module_ResolveFieldToken (struct MonoImage * image, guint32 token, struct MonoArray * type_args, struct MonoArray * method_args, MonoResolveTokenError * error)
{
  unsigned int D.30768;
  int token.133;
  _Bool D.30770;
  _Bool D.30771;
  _Bool D.30772;
  struct MonoClassField * D.30775;
  unsigned char D.30776;
  unsigned char D.30777;
  int D.30782;
  <unnamed-unsigned:24> D.30788;
  int D.30789;
  int D.30792;
  struct MonoLoaderError * D.30795;
  struct MonoLoaderError * D.30798;
  struct MonoException * D.30799;
  struct MonoClass * klass;
  int table;
  int index;
  struct MonoGenericContext context;
  struct MonoClassField * field;

  try
    {
      D.30768 = token >> 24;
      table = (int) D.30768;
      token.133 = (int) token;
      index = token.133 & 16777215;
      *error = 2;
      D.30770 = table != 4;
      D.30771 = table != 10;
      D.30772 = D.30770 & D.30771;
      if (D.30772 != 0) goto <D.30773>; else goto <D.30774>;
      <D.30773>:
      *error = 1;
      D.30775 = 0B;
      return D.30775;
      <D.30774>:
      D.30776 = BIT_FIELD_REF <*image, 8, 128>;
      D.30777 = D.30776 & 8;
      if (D.30777 != 0) goto <D.30778>; else goto <D.30779>;
      <D.30778>:
      if (table == 4) goto <D.30780>; else goto <D.30781>;
      <D.30780>:
      D.30775 = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
      return D.30775;
      <D.30781>:
      D.30782 = mono_memberref_is_method (image, token);
      if (D.30782 != 0) goto <D.30783>; else goto <D.30784>;
      <D.30783>:
      *error = 1;
      D.30775 = 0B;
      return D.30775;
      <D.30784>:
      init_generic_context_from_args (&context, type_args, method_args);
      D.30775 = mono_lookup_dynamic_token_class (image, token, 0, 0B, &context);
      return D.30775;
      <D.30779>:
      if (index <= 0) goto <D.30785>; else goto <D.30787>;
      <D.30787>:
      D.30788 = image->tables[table].rows;
      D.30789 = (int) D.30788;
      if (D.30789 < index) goto <D.30785>; else goto <D.30786>;
      <D.30785>:
      *error = 0;
      D.30775 = 0B;
      return D.30775;
      <D.30786>:
      if (table == 10) goto <D.30790>; else goto <D.30791>;
      <D.30790>:
      D.30792 = mono_memberref_is_method (image, token);
      if (D.30792 != 0) goto <D.30793>; else goto <D.30794>;
      <D.30793>:
      *error = 1;
      D.30775 = 0B;
      return D.30775;
      <D.30794>:
      <D.30791>:
      init_generic_context_from_args (&context, type_args, method_args);
      field = mono_field_from_token (image, token, &klass, &context);
      D.30795 = mono_loader_get_last_error ();
      if (D.30795 != 0B) goto <D.30796>; else goto <D.30797>;
      <D.30796>:
      D.30798 = mono_loader_get_last_error ();
      D.30799 = mono_loader_error_prepare_exception (D.30798);
      mono_raise_exception (D.30799);
      <D.30797>:
      D.30775 = field;
      return D.30775;
    }
  finally
    {
      klass = {CLOBBER};
      context = {CLOBBER};
    }
}


ves_icall_System_Reflection_Module_InternalGetTypes (struct MonoReflectionModule * module)
{
  struct MonoImage * D.30802;
  struct MonoArray * D.30805;
  struct MonoVTable * D.30806;
  struct MonoDomain * D.30807;
  struct MonoClass * D.30808;
  struct MonoArray * exceptions.134;
  unsigned int i.135;
  char * D.30811;
  unsigned int D.30814;
  struct MonoArray * exceptions;
  int i;

  try
    {
      D.30802 = module->image;
      if (D.30802 == 0B) goto <D.30803>; else goto <D.30804>;
      <D.30803>:
      D.30806 = MEM[(struct MonoObject *)module].vtable;
      D.30807 = D.30806->domain;
      D.30808 = mono_defaults.monotype_class;
      D.30805 = mono_array_new (D.30807, D.30808, 0);
      return D.30805;
      <D.30804>:
      {
        struct MonoArray * res;

        D.30806 = MEM[(struct MonoObject *)module].vtable;
        D.30807 = D.30806->domain;
        D.30802 = module->image;
        res = mono_module_get_types (D.30807, D.30802, &exceptions, 0);
        i = 0;
        goto <D.25132>;
        <D.25131>:
        {
          struct MonoException * ex;

          exceptions.134 = exceptions;
          i.135 = (unsigned int) i;
          D.30811 = mono_array_addr_with_size (exceptions.134, 4, i.135);
          ex = MEM[(struct MonoException * *)D.30811];
          if (ex != 0B) goto <D.30812>; else goto <D.30813>;
          <D.30812>:
          mono_raise_exception (ex);
          <D.30813>:
        }
        i = i + 1;
        <D.25132>:
        i.135 = (unsigned int) i;
        exceptions.134 = exceptions;
        D.30814 = mono_array_length (exceptions.134);
        if (i.135 < D.30814) goto <D.25131>; else goto <D.25133>;
        <D.25133>:
        D.30805 = res;
        return D.30805;
      }
    }
  finally
    {
      exceptions = {CLOBBER};
    }
}


mono_module_get_types (struct MonoDomain * domain, struct MonoImage * image, struct MonoArray * * exceptions, MonoBoolean exportedOnly)
{
  unsigned int D.30819;
  <unnamed-unsigned:24> D.30822;
  int D.30823;
  struct MonoClass * D.30825;
  unsigned int count.136;
  struct MonoClass * D.30827;
  struct MonoArray * D.30828;
  int D.30832;
  int D.30833;
  unsigned int D.30834;
  struct MonoType * D.30837;
  struct MonoReflectionType * D.30838;
  _Bool D.30840;
  long int D.30841;
  long int D.30842;
  struct MonoArray * D.30845;
  struct MonoLoaderError * D.30846;
  struct MonoArray * D.30849;
  struct MonoArray * res;
  struct MonoClass * klass;
  struct MonoTableInfo * tdef;
  int i;
  int count;
  guint32 attrs;
  guint32 visibility;

  tdef = &image->tables[2];
  if (exportedOnly != 0) goto <D.30817>; else goto <D.30818>;
  <D.30817>:
  count = 0;
  i = 1;
  goto <D.25030>;
  <D.25029>:
  attrs = mono_metadata_decode_row_col (tdef, i, 0);
  visibility = attrs & 7;
  D.30819 = visibility + 4294967295;
  if (D.30819 <= 1) goto <D.30820>; else goto <D.30821>;
  <D.30820>:
  count = count + 1;
  <D.30821>:
  i = i + 1;
  <D.25030>:
  D.30822 = tdef->rows;
  D.30823 = (int) D.30822;
  if (D.30823 > i) goto <D.25029>; else goto <D.25031>;
  <D.25031>:
  goto <D.30824>;
  <D.30818>:
  D.30822 = tdef->rows;
  D.30823 = (int) D.30822;
  count = D.30823 + -1;
  <D.30824>:
  D.30825 = mono_defaults.monotype_class;
  count.136 = (unsigned int) count;
  res = mono_array_new (domain, D.30825, count.136);
  D.30827 = mono_defaults.exception_class;
  count.136 = (unsigned int) count;
  D.30828 = mono_array_new (domain, D.30827, count.136);
  *exceptions = D.30828;
  count = 0;
  i = 1;
  goto <D.25037>;
  <D.25036>:
  attrs = mono_metadata_decode_row_col (tdef, i, 0);
  visibility = attrs & 7;
  if (exportedOnly == 0) goto <D.30829>; else goto <D.30831>;
  <D.30831>:
  D.30819 = visibility + 4294967295;
  if (D.30819 <= 1) goto <D.30829>; else goto <D.30830>;
  <D.30829>:
  D.30832 = i + 1;
  D.30833 = D.30832 | 33554432;
  D.30834 = (unsigned int) D.30833;
  klass = mono_class_get (image, D.30834);
  if (klass != 0B) goto <D.30835>; else goto <D.30836>;
  <D.30835>:
  {
    void * * __p;

    count.136 = (unsigned int) count;
    __p = mono_array_addr_with_size (res, 4, count.136);
    D.30837 = &klass->byval_arg;
    D.30838 = mono_type_get_object (domain, D.30837);
    mono_gc_wbarrier_set_arrayref (res, __p, D.30838);
  }
  goto <D.30839>;
  <D.30836>:
  {
    struct MonoLoaderError * error;
    struct MonoException * ex;

    error = mono_loader_get_last_error ();
    D.30840 = error == 0B;
    D.30841 = (long int) D.30840;
    D.30842 = __builtin_expect (D.30841, 0);
    if (D.30842 != 0) goto <D.30843>; else goto <D.30844>;
    <D.30843>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5142, "error != NULL");
    <D.30844>:
    ex = mono_loader_error_prepare_exception (error);
    {
      void * * __p;

      D.30845 = *exceptions;
      count.136 = (unsigned int) count;
      __p = mono_array_addr_with_size (D.30845, 4, count.136);
      D.30845 = *exceptions;
      mono_gc_wbarrier_set_arrayref (D.30845, __p, ex);
    }
  }
  <D.30839>:
  D.30846 = mono_loader_get_last_error ();
  if (D.30846 != 0B) goto <D.30847>; else goto <D.30848>;
  <D.30847>:
  mono_loader_clear_error ();
  <D.30848>:
  count = count + 1;
  <D.30830>:
  i = i + 1;
  <D.25037>:
  D.30822 = tdef->rows;
  D.30823 = (int) D.30822;
  if (D.30823 > i) goto <D.25036>; else goto <D.25038>;
  <D.25038>:
  D.30849 = res;
  return D.30849;
}


ves_icall_System_Reflection_Module_GetPEKind (struct MonoImage * image, gint32 * pe_kind, gint32 * machine)
{
  unsigned char D.30851;
  unsigned char D.30852;
  unsigned int D.30855;
  int D.30856;
  unsigned int D.30857;
  int D.30858;
  void * D.30860;
  unsigned int D.30861;
  int D.30862;
  int D.30863;
  short unsigned int D.30864;
  int D.30865;

  D.30851 = BIT_FIELD_REF <*image, 8, 128>;
  D.30852 = D.30851 & 8;
  if (D.30852 != 0) goto <D.30853>; else goto <D.30854>;
  <D.30853>:
  {
    struct MonoDynamicImage * dyn;

    dyn = image;
    D.30855 = dyn->pe_kind;
    D.30856 = (int) D.30855;
    *pe_kind = D.30856;
    D.30857 = dyn->machine;
    D.30858 = (int) D.30857;
    *machine = D.30858;
  }
  goto <D.30859>;
  <D.30854>:
  D.30860 = image->image_info;
  D.30861 = MEM[(struct MonoCLIImageInfo *)D.30860].cli_cli_header.ch_flags;
  D.30862 = (int) D.30861;
  D.30863 = D.30862 & 3;
  *pe_kind = D.30863;
  D.30860 = image->image_info;
  D.30864 = MEM[(struct MonoCLIImageInfo *)D.30860].cli_header.coff.coff_machine;
  D.30865 = (int) D.30864;
  *machine = D.30865;
  <D.30859>:
}


ves_icall_System_Reflection_Module_GetMDStreamVersion (struct MonoImage * image)
{
  gint32 D.30866;
  short int D.30867;
  int D.30868;
  int D.30869;
  short int D.30870;
  int D.30871;

  D.30867 = image->md_version_major;
  D.30868 = (int) D.30867;
  D.30869 = D.30868 << 16;
  D.30870 = image->md_version_minor;
  D.30871 = (int) D.30870;
  D.30866 = D.30869 | D.30871;
  return D.30866;
}


ves_icall_System_Reflection_Module_GetHINSTANCE (struct MonoReflectionModule * module)
{
  void * D.30873;

  D.30873 = 4294967295B;
  return D.30873;
}


ves_icall_System_Reflection_Module_GetGuidInternal (struct MonoReflectionModule * module)
{
  struct MonoVTable * D.30875;
  struct MonoImage * D.30876;
  _Bool D.30877;
  long int D.30878;
  long int D.30879;
  struct MonoString * D.30882;
  char * D.30883;
  struct MonoDomain * domain;

  D.30875 = MEM[(struct MonoObject *)module].vtable;
  domain = D.30875->domain;
  D.30876 = module->image;
  D.30877 = D.30876 == 0B;
  D.30878 = (long int) D.30877;
  D.30879 = __builtin_expect (D.30878, 0);
  if (D.30879 != 0) goto <D.30880>; else goto <D.30881>;
  <D.30880>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5323, "module->image");
  <D.30881>:
  D.30876 = module->image;
  D.30883 = D.30876->guid;
  D.30882 = mono_string_new (domain, D.30883);
  return D.30882;
}


ves_icall_System_Reflection_Module_GetGlobalType (struct MonoReflectionModule * module)
{
  struct MonoVTable * D.30885;
  struct MonoImage * D.30886;
  _Bool D.30887;
  long int D.30888;
  long int D.30889;
  unsigned char D.30892;
  unsigned char D.30893;
  int D.30896;
  struct MonoReflectionType * D.30899;
  struct MonoType * D.30900;
  struct MonoDomain * domain;
  struct MonoClass * klass;

  D.30885 = MEM[(struct MonoObject *)module].vtable;
  domain = D.30885->domain;
  D.30886 = module->image;
  D.30887 = D.30886 == 0B;
  D.30888 = (long int) D.30887;
  D.30889 = __builtin_expect (D.30888, 0);
  if (D.30889 != 0) goto <D.30890>; else goto <D.30891>;
  <D.30890>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5299, "module->image");
  <D.30891>:
  D.30886 = module->image;
  D.30892 = BIT_FIELD_REF <*D.30886, 8, 128>;
  D.30893 = D.30892 & 8;
  if (D.30893 != 0) goto <D.30894>; else goto <D.30895>;
  <D.30894>:
  D.30886 = module->image;
  D.30896 = MEM[(struct MonoDynamicImage *)D.30886].initial_image;
  if (D.30896 != 0) goto <D.30897>; else goto <D.30898>;
  <D.30897>:
  D.30899 = 0B;
  return D.30899;
  <D.30898>:
  <D.30895>:
  D.30886 = module->image;
  klass = mono_class_get (D.30886, 33554433);
  D.30900 = &klass->byval_arg;
  D.30899 = mono_type_get_object (domain, D.30900);
  return D.30899;
}


ves_icall_System_Reflection_Module_Close (struct MonoReflectionModule * module)
{

}


ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType (struct MonoMethod * method, struct MonoType * type)
{
  struct MonoClass * D.30904;
  struct MonoClass * D.30905;
  struct MonoClass * D.30906;
  struct MonoReflectionMethod * D.30909;
  struct MonoDomain * D.30915;
  struct MonoClass * klass;

  if (type != 0B) goto <D.30902>; else goto <D.30903>;
  <D.30902>:
  klass = mono_class_from_mono_type (type);
  D.30904 = method->klass;
  D.30905 = mono_class_get_generic_type_definition (D.30904);
  D.30906 = mono_class_get_generic_type_definition (klass);
  if (D.30905 != D.30906) goto <D.30907>; else goto <D.30908>;
  <D.30907>:
  D.30909 = 0B;
  return D.30909;
  <D.30908>:
  D.30904 = method->klass;
  if (D.30904 != klass) goto <D.30910>; else goto <D.30911>;
  <D.30910>:
  method = mono_method_get_equivalent_method (method, klass);
  if (method == 0B) goto <D.30912>; else goto <D.30913>;
  <D.30912>:
  D.30909 = 0B;
  return D.30909;
  <D.30913>:
  <D.30911>:
  goto <D.30914>;
  <D.30903>:
  klass = method->klass;
  <D.30914>:
  D.30915 = mono_domain_get ();
  D.30909 = mono_method_get_object (D.30915, method, klass);
  return D.30909;
}


mono_method_get_equivalent_method (struct MonoMethod * method, struct MonoClass * klass)
{
  unsigned char D.30917;
  unsigned char D.30918;
  struct MonoGenericInst * D.30921;
  struct MonoGenericInst * D.30924;
  struct MonoGenericInst * D.30925;
  struct MonoGenericClass * D.30926;
  struct MonoGenericInst * D.30929;
  struct MonoGenericContainer * D.30931;
  struct MonoGenericInst * D.30934;
  struct MonoMethod * D.30935;
  struct MonoMethod * D.30936;
  struct MonoClass * D.30937;
  unsigned char D.30938;
  struct MonoMethod * * D.30941;
  unsigned int i.137;
  unsigned int D.30943;
  struct MonoMethod * * D.30944;
  struct MonoMethod * D.30945;
  unsigned int i.138;
  unsigned int D.30949;
  unsigned char D.30950;
  int iftmp.139;
  unsigned int offset.140;
  unsigned int D.30959;
  _Bool D.30960;
  long int D.30961;
  long int D.30962;
  struct MonoMethod * * D.30965;
  unsigned int offset.141;
  unsigned int D.30967;
  struct MonoMethod * * D.30968;
  int offset;
  int i;

  offset = -1;
  D.30917 = BIT_FIELD_REF <*method, 8, 168>;
  D.30918 = D.30917 & 16;
  if (D.30918 != 0) goto <D.30919>; else goto <D.30920>;
  <D.30919>:
  D.30921 = MEM[(struct MonoMethodInflated *)method].context.method_inst;
  if (D.30921 != 0B) goto <D.30922>; else goto <D.30923>;
  <D.30922>:
  {
    struct MonoMethodInflated * inflated;
    struct MonoGenericContext ctx;

    try
      {
        inflated = method;
        D.30924 = inflated->context.method_inst;
        ctx.method_inst = D.30924;
        D.30925 = inflated->context.class_inst;
        ctx.class_inst = D.30925;
        D.30926 = klass->generic_class;
        if (D.30926 != 0B) goto <D.30927>; else goto <D.30928>;
        <D.30927>:
        D.30926 = klass->generic_class;
        D.30929 = D.30926->context.class_inst;
        ctx.class_inst = D.30929;
        goto <D.30930>;
        <D.30928>:
        D.30931 = klass->generic_container;
        if (D.30931 != 0B) goto <D.30932>; else goto <D.30933>;
        <D.30932>:
        D.30931 = klass->generic_container;
        D.30934 = D.30931->context.class_inst;
        ctx.class_inst = D.30934;
        <D.30933>:
        <D.30930>:
        D.30936 = inflated->declaring;
        D.30935 = mono_class_inflate_generic_method_full (D.30936, klass, &ctx);
        return D.30935;
      }
    finally
      {
        ctx = {CLOBBER};
      }
  }
  <D.30923>:
  <D.30920>:
  D.30937 = method->klass;
  mono_class_setup_methods (D.30937);
  D.30937 = method->klass;
  D.30938 = D.30937->exception_type;
  if (D.30938 != 0) goto <D.30939>; else goto <D.30940>;
  <D.30939>:
  D.30935 = 0B;
  return D.30935;
  <D.30940>:
  i = 0;
  goto <D.24919>;
  <D.24918>:
  D.30937 = method->klass;
  D.30941 = D.30937->methods;
  i.137 = (unsigned int) i;
  D.30943 = i.137 * 4;
  D.30944 = D.30941 + D.30943;
  D.30945 = *D.30944;
  if (D.30945 == method) goto <D.30946>; else goto <D.30947>;
  <D.30946>:
  offset = i;
  goto <D.24917>;
  <D.30947>:
  i = i + 1;
  <D.24919>:
  i.138 = (unsigned int) i;
  D.30937 = method->klass;
  D.30949 = D.30937->method.count;
  if (i.138 < D.30949) goto <D.24918>; else goto <D.24917>;
  <D.24917>:
  mono_class_setup_methods (klass);
  D.30950 = klass->exception_type;
  if (D.30950 != 0) goto <D.30951>; else goto <D.30952>;
  <D.30951>:
  D.30935 = 0B;
  return D.30935;
  <D.30952>:
  if (offset < 0) goto <D.30954>; else goto <D.30957>;
  <D.30957>:
  offset.140 = (unsigned int) offset;
  D.30959 = klass->method.count;
  if (offset.140 >= D.30959) goto <D.30954>; else goto <D.30955>;
  <D.30954>:
  iftmp.139 = 1;
  goto <D.30956>;
  <D.30955>:
  iftmp.139 = 0;
  <D.30956>:
  D.30960 = iftmp.139 != 0;
  D.30961 = (long int) D.30960;
  D.30962 = __builtin_expect (D.30961, 0);
  if (D.30962 != 0) goto <D.30963>; else goto <D.30964>;
  <D.30963>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4779, "offset >= 0 && offset < klass->method.count");
  <D.30964>:
  D.30965 = klass->methods;
  offset.141 = (unsigned int) offset;
  D.30967 = offset.141 * 4;
  D.30968 = D.30965 + D.30967;
  D.30935 = *D.30968;
  return D.30935;
}


ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternal (struct MonoMethod * method)
{
  struct MonoReflectionMethod * D.30971;
  struct MonoDomain * D.30972;

  D.30972 = mono_domain_get ();
  D.30971 = mono_method_get_object (D.30972, method, 0B);
  return D.30971;
}


ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal (struct MonoMethod * method)
{
  struct MonoReflectionMethodBody * D.30974;
  struct MonoDomain * D.30975;

  D.30975 = mono_domain_get ();
  D.30974 = mono_method_body_get_object (D.30975, method);
  return D.30974;
}


ves_icall_GetCurrentMethod ()
{
  unsigned char D.30977;
  unsigned char D.30978;
  struct MonoReflectionMethod * D.30979;
  struct MonoDomain * D.30980;
  struct MonoMethod * m;

  m = mono_method_get_last_managed ();
  goto <D.24907>;
  <D.24906>:
  m = MEM[(struct MonoMethodInflated *)m].declaring;
  <D.24907>:
  D.30977 = BIT_FIELD_REF <*m, 8, 168>;
  D.30978 = D.30977 & 16;
  if (D.30978 != 0) goto <D.24906>; else goto <D.24908>;
  <D.24908>:
  D.30980 = mono_domain_get ();
  D.30979 = mono_method_get_object (D.30980, m, 0B);
  return D.30979;
}


ves_icall_System_Reflection_FieldInfo_internal_from_handle_type (struct MonoClassField * handle, struct MonoType * type)
{
  _Bool D.30982;
  long int D.30983;
  long int D.30984;
  struct MonoClass * D.30990;
  struct MonoReflectionField * D.30995;
  struct MonoDomain * D.30996;
  gboolean found;
  struct MonoClass * klass;
  struct MonoClass * k;

  found = 0;
  D.30982 = handle == 0B;
  D.30983 = (long int) D.30982;
  D.30984 = __builtin_expect (D.30983, 0);
  if (D.30984 != 0) goto <D.30985>; else goto <D.30986>;
  <D.30985>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1637, "handle");
  <D.30986>:
  if (type == 0B) goto <D.30987>; else goto <D.30988>;
  <D.30987>:
  klass = handle->parent;
  goto <D.30989>;
  <D.30988>:
  klass = mono_class_from_mono_type (type);
  k = klass;
  goto <D.23596>;
  <D.23595>:
  D.30990 = handle->parent;
  if (D.30990 == k) goto <D.30991>; else goto <D.30992>;
  <D.30991>:
  found = 1;
  goto <D.23594>;
  <D.30992>:
  k = k->parent;
  <D.23596>:
  if (k != 0B) goto <D.23595>; else goto <D.23594>;
  <D.23594>:
  if (found == 0) goto <D.30993>; else goto <D.30994>;
  <D.30993>:
  D.30995 = 0B;
  return D.30995;
  <D.30994>:
  <D.30989>:
  D.30996 = mono_domain_get ();
  D.30995 = mono_field_get_object (D.30996, klass, handle);
  return D.30995;
}


ves_icall_System_Reflection_FieldInfo_get_marshal_info (struct MonoReflectionField * field)
{
  struct MonoClassField * D.30998;
  struct MonoGenericContainer * D.31001;
  struct MonoGenericClass * D.31003;
  struct MonoGenericInst * D.31005;
  unsigned char D.31006;
  unsigned char D.31007;
  struct MonoReflectionMarshalAsAttribute * D.31008;
  struct MonoClassField * D.31009;
  struct MonoMarshalSpec * D.31012;
  struct MonoVTable * D.31015;
  struct MonoDomain * D.31016;
  unsigned int i.142;
  unsigned int D.31018;
  struct MonoClass * klass;
  struct MonoMarshalType * info;
  int i;

  D.30998 = field->field;
  klass = D.30998->parent;
  D.31001 = klass->generic_container;
  if (D.31001 != 0B) goto <D.30999>; else goto <D.31002>;
  <D.31002>:
  D.31003 = klass->generic_class;
  if (D.31003 != 0B) goto <D.31004>; else goto <D.31000>;
  <D.31004>:
  D.31003 = klass->generic_class;
  D.31005 = D.31003->context.class_inst;
  D.31006 = BIT_FIELD_REF <*D.31005, 8, 48>;
  D.31007 = D.31006 & 64;
  if (D.31007 != 0) goto <D.30999>; else goto <D.31000>;
  <D.30999>:
  D.31008 = 0B;
  return D.31008;
  <D.31000>:
  info = mono_marshal_load_type_info (klass);
  i = 0;
  goto <D.23585>;
  <D.23584>:
  D.31009 = info->fields[i].field;
  D.30998 = field->field;
  if (D.31009 == D.30998) goto <D.31010>; else goto <D.31011>;
  <D.31010>:
  D.31012 = info->fields[i].mspec;
  if (D.31012 == 0B) goto <D.31013>; else goto <D.31014>;
  <D.31013>:
  D.31008 = 0B;
  return D.31008;
  <D.31014>:
  D.31015 = field->object.vtable;
  D.31016 = D.31015->domain;
  D.31012 = info->fields[i].mspec;
  D.31008 = mono_reflection_marshal_as_attribute_from_marshal_spec (D.31016, klass, D.31012);
  return D.31008;
  <D.31011>:
  i = i + 1;
  <D.23585>:
  i.142 = (unsigned int) i;
  D.31018 = info->num_fields;
  if (i.142 < D.31018) goto <D.23584>; else goto <D.23586>;
  <D.23586>:
  D.31008 = 0B;
  return D.31008;
}


ves_icall_System_Reflection_FieldInfo_GetTypeModifiers (struct MonoReflectionField * field, MonoBoolean optional)
{
  struct MonoClassField * D.31020;
  int D.31021;
  struct MonoArray * D.31024;
  struct MonoClass * D.31025;
  struct MonoImage * D.31026;
  int D.31027;
  struct MonoError error;
  struct MonoType * type;

  try
    {
      D.31020 = field->field;
      type = mono_field_get_type_checked (D.31020, &error);
      D.31021 = mono_error_ok (&error);
      if (D.31021 == 0) goto <D.31022>; else goto <D.31023>;
      <D.31022>:
      mono_error_raise_exception (&error);
      <D.31023>:
      D.31020 = field->field;
      D.31025 = D.31020->parent;
      D.31026 = D.31025->image;
      D.31027 = (int) optional;
      D.31024 = type_array_from_modifiers (D.31026, type, D.31027);
      return D.31024;
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_TypeBuilder_get_IsGenericParameter (struct MonoReflectionTypeBuilder * tb)
{
  MonoBoolean D.31030;
  struct MonoType * D.31031;

  D.31031 = tb->type.type;
  D.31030 = is_generic_parameter (D.31031);
  return D.31030;
}


ves_icall_ModuleBuilder_getToken (struct MonoReflectionModuleBuilder * mb, struct MonoObject * obj, gboolean create_open_instance)
{
  _Bool D.31033;
  long int D.31034;
  long int D.31035;
  gint32 D.31040;
  struct MonoDynamicImage * D.31041;
  unsigned int D.31042;

  D.31033 = obj == 0B;
  D.31034 = (long int) D.31033;
  D.31035 = __builtin_expect (D.31034, 0);
  if (D.31035 != 0) goto <D.31036>; else goto <D.31037>;
  <D.31036>:
  {
    struct MonoException * ex;

    if (obj != 0B) goto <D.31038>; else goto <D.31039>;
    <D.31038>:
    <D.31039>:
    ex = mono_get_exception_argument_null ("obj");
    mono_raise_exception (ex);
  }
  <D.31037>:
  D.31041 = mb->dynamic_image;
  D.31042 = mono_image_create_token (D.31041, obj, create_open_instance, 1);
  D.31040 = (gint32) D.31042;
  return D.31040;
}


ves_icall_ModuleBuilder_getMethodToken (struct MonoReflectionModuleBuilder * mb, struct MonoReflectionMethod * method, struct MonoArray * opt_param_types)
{
  _Bool D.31044;
  long int D.31045;
  long int D.31046;
  gint32 D.31051;
  struct MonoDynamicImage * D.31052;
  unsigned int D.31053;

  D.31044 = method == 0B;
  D.31045 = (long int) D.31044;
  D.31046 = __builtin_expect (D.31045, 0);
  if (D.31046 != 0) goto <D.31047>; else goto <D.31048>;
  <D.31047>:
  {
    struct MonoException * ex;

    if (method != 0B) goto <D.31049>; else goto <D.31050>;
    <D.31049>:
    <D.31050>:
    ex = mono_get_exception_argument_null ("method");
    mono_raise_exception (ex);
  }
  <D.31048>:
  D.31052 = mb->dynamic_image;
  D.31053 = mono_image_create_method_token (D.31052, method, opt_param_types);
  D.31051 = (gint32) D.31053;
  return D.31051;
}


ves_icall_ModuleBuilder_create_modified_type (struct MonoReflectionTypeBuilder * tb, struct MonoString * smodifiers)
{
  struct MonoType * D.31055;
  char D.31056;
  int D.31057;
  struct MonoReflectionType * D.31060;
  struct MonoVTable * D.31061;
  struct MonoDomain * D.31062;
  struct MonoType * D.31063;
  struct MonoType * D.31064;
  unsigned int rank.143;
  struct MonoClass * klass;
  int isbyref;
  int rank;
  char * str;
  char * p;

  isbyref = 0;
  str = mono_string_to_utf8 (smodifiers);
  D.31055 = tb->type.type;
  klass = mono_class_from_mono_type (D.31055);
  p = str;
  goto <D.25237>;
  <D.25236>:
  D.31056 = *p;
  D.31057 = (int) D.31056;
  switch (D.31057) <default: <D.25235>, case 38: <D.25228>, case 42: <D.25229>, case 91: <D.25231>>
  <D.25228>:
  if (isbyref != 0) goto <D.31058>; else goto <D.31059>;
  <D.31058>:
  monoeg_g_free (str);
  D.31060 = 0B;
  return D.31060;
  <D.31059>:
  isbyref = 1;
  p = p + 1;
  monoeg_g_free (str);
  D.31061 = MEM[(struct MonoObject *)tb].vtable;
  D.31062 = D.31061->domain;
  D.31063 = &klass->this_arg;
  D.31060 = mono_type_get_object (D.31062, D.31063);
  return D.31060;
  <D.25229>:
  D.31064 = &klass->byval_arg;
  klass = mono_ptr_class_get (D.31064);
  mono_class_init (klass);
  p = p + 1;
  goto <D.25230>;
  <D.25231>:
  rank = 1;
  p = p + 1;
  goto <D.25234>;
  <D.25233>:
  D.31056 = *p;
  if (D.31056 == 93) goto <D.25232>; else goto <D.31065>;
  <D.31065>:
  D.31056 = *p;
  if (D.31056 == 44) goto <D.31066>; else goto <D.31067>;
  <D.31066>:
  rank = rank + 1;
  goto <D.31068>;
  <D.31067>:
  D.31056 = *p;
  if (D.31056 != 42) goto <D.31069>; else goto <D.31070>;
  <D.31069>:
  monoeg_g_free (str);
  D.31060 = 0B;
  return D.31060;
  <D.31070>:
  <D.31068>:
  p = p + 1;
  <D.25234>:
  D.31056 = *p;
  if (D.31056 != 0) goto <D.25233>; else goto <D.25232>;
  <D.25232>:
  D.31056 = *p;
  if (D.31056 != 93) goto <D.31071>; else goto <D.31072>;
  <D.31071>:
  monoeg_g_free (str);
  D.31060 = 0B;
  return D.31060;
  <D.31072>:
  p = p + 1;
  rank.143 = (unsigned int) rank;
  klass = mono_array_class_get (klass, rank.143);
  mono_class_init (klass);
  goto <D.25230>;
  <D.25235>:
  goto <D.25230>;
  <D.25230>:
  <D.25237>:
  D.31056 = *p;
  if (D.31056 != 0) goto <D.25236>; else goto <D.25238>;
  <D.25238>:
  monoeg_g_free (str);
  D.31061 = MEM[(struct MonoObject *)tb].vtable;
  D.31062 = D.31061->domain;
  D.31064 = &klass->byval_arg;
  D.31060 = mono_type_get_object (D.31062, D.31064);
  return D.31060;
}


ves_icall_ModuleBuilder_build_metadata (struct MonoReflectionModuleBuilder * mb)
{
  mono_image_build_metadata (mb);
}


ves_icall_ModuleBuilder_WriteToFile (struct MonoReflectionModuleBuilder * mb, void * file)
{
  mono_image_create_pefile (mb, file);
}


ves_icall_ModuleBuilder_RegisterToken (struct MonoReflectionModuleBuilder * mb, struct MonoObject * obj, guint32 token)
{
  struct MonoDynamicImage * D.31076;

  D.31076 = mb->dynamic_image;
  mono_image_register_token (D.31076, token, obj);
}


ves_icall_EnumBuilder_setup_enum_type (struct MonoReflectionType * enumtype, struct MonoReflectionType * t)
{
  struct MonoType * D.31077;

  D.31077 = t->type;
  enumtype->type = D.31077;
}


ves_icall_System_Reflection_AssemblyName_ParseName (struct MonoReflectionAssemblyName * name, struct MonoString * assname)
{
  struct MonoVTable * D.31078;
  int D.31079;
  const mono_byte * D.31082;
  gboolean D.31083;
  int is_version_defined.144;
  int is_token_defined.145;
  struct MonoAssemblyName aname;
  struct MonoDomain * domain;
  char * val;
  gboolean is_version_defined;
  gboolean is_token_defined;

  try
    {
      D.31078 = MEM[(struct MonoObject *)name].vtable;
      domain = D.31078->domain;
      aname.public_key = 0B;
      val = mono_string_to_utf8 (assname);
      D.31079 = mono_assembly_name_parse_full (val, &aname, 1, &is_version_defined, &is_token_defined);
      if (D.31079 == 0) goto <D.31080>; else goto <D.31081>;
      <D.31080>:
      D.31082 = aname.public_key;
      monoeg_g_free (D.31082);
      monoeg_g_free (val);
      D.31083 = 0;
      return D.31083;
      <D.31081>:
      is_version_defined.144 = is_version_defined;
      is_token_defined.145 = is_token_defined;
      fill_reflection_assembly_name (domain, name, &aname, "", is_version_defined.144, 0, is_token_defined.145);
      mono_assembly_name_free (&aname);
      D.31082 = aname.public_key;
      monoeg_g_free (D.31082);
      monoeg_g_free (val);
      D.31083 = 1;
      return D.31083;
    }
  finally
    {
      aname = {CLOBBER};
      is_version_defined = {CLOBBER};
      is_token_defined = {CLOBBER};
    }
}


fill_reflection_assembly_name (struct MonoDomain * domain, struct MonoReflectionAssemblyName * aname, struct MonoAssemblyName * name, const char * absolute, gboolean by_default_version, gboolean default_publickey, gboolean default_token)
{
  struct MonoString * * D.31088;
  const char * D.31089;
  struct MonoString * D.31090;
  short unsigned int D.31091;
  int D.31092;
  short unsigned int D.31093;
  int D.31094;
  short unsigned int D.31095;
  int D.31096;
  unsigned int D.31097;
  short unsigned int D.31098;
  int D.31099;
  unsigned int D.31100;
  short unsigned int D.31101;
  unsigned int D.31102;
  struct MonoObject * * D.31105;
  unsigned int D.31106;
  unsigned int D.31107;
  unsigned int D.31108;
  unsigned int D.31109;
  struct MonoObject * D.31110;
  char D.31113;
  struct MonoString * * D.31118;
  struct MonoString * D.31119;
  struct MonoMethod * create_culture.146;
  struct MonoImage * D.31123;
  struct MonoMethod * create_culture.147;
  _Bool D.31125;
  long int D.31126;
  long int D.31127;
  const char * D.31130;
  struct MonoString * D.31133;
  struct MonoObject * * D.31134;
  struct MonoObject * D.31135;
  const mono_byte * pkey_ptr.148;
  const char * pkey_ptr.149;
  struct MonoArray * * D.31140;
  struct MonoClass * D.31141;
  struct MonoArray * D.31142;
  struct MonoArray * D.31143;
  char * D.31144;
  unsigned int D.31145;
  unsigned int D.31146;
  struct MonoArray * D.31150;
  unsigned char D.31151;
  struct MonoArray * * D.31154;
  struct MonoArray * D.31155;
  struct MonoArray * D.31156;
  int j.150;
  unsigned char D.31158;
  int D.31159;
  char D.31160;
  char D.31161;
  int j.151;
  unsigned char D.31163;
  int D.31164;
  char D.31165;
  signed char D.31166;
  signed char D.31167;
  signed char D.31168;
  char D.31169;
  struct MonoArray * D.31173;
  static struct MonoMethod * create_culture = 0B;
  void * args[2];
  guint32 pkey_len;
  const char * pkey_ptr;
  gchar * codebase;
  MonoBoolean assembly_ref;

  try
    {
      assembly_ref = 0;
      D.31088 = &aname->name;
      D.31089 = name->name;
      D.31090 = mono_string_new (domain, D.31089);
      mono_gc_wbarrier_set_field (aname, D.31088, D.31090);
      D.31091 = name->major;
      D.31092 = (int) D.31091;
      aname->major = D.31092;
      D.31093 = name->minor;
      D.31094 = (int) D.31093;
      aname->minor = D.31094;
      D.31095 = name->build;
      D.31096 = (int) D.31095;
      aname->build = D.31096;
      D.31097 = name->flags;
      aname->flags = D.31097;
      D.31098 = name->revision;
      D.31099 = (int) D.31098;
      aname->revision = D.31099;
      D.31100 = name->hash_alg;
      aname->hashalg = D.31100;
      aname->versioncompat = 1;
      D.31101 = name->arch;
      D.31102 = (unsigned int) D.31101;
      aname->processor_architecture = D.31102;
      if (by_default_version != 0) goto <D.31103>; else goto <D.31104>;
      <D.31103>:
      D.31105 = &aname->version;
      D.31091 = name->major;
      D.31106 = (unsigned int) D.31091;
      D.31093 = name->minor;
      D.31107 = (unsigned int) D.31093;
      D.31095 = name->build;
      D.31108 = (unsigned int) D.31095;
      D.31098 = name->revision;
      D.31109 = (unsigned int) D.31098;
      D.31110 = create_version (domain, D.31106, D.31107, D.31108, D.31109);
      mono_gc_wbarrier_set_field (aname, D.31105, D.31110);
      <D.31104>:
      codebase = 0B;
      if (absolute != 0B) goto <D.31111>; else goto <D.31112>;
      <D.31111>:
      D.31113 = *absolute;
      if (D.31113 != 0) goto <D.31114>; else goto <D.31115>;
      <D.31114>:
      {
        const gchar * prepend;
        gchar * result;

        prepend = "file://";
        codebase = monoeg_strdup (absolute);
        result = monoeg_g_strconcat (prepend, codebase, 0B);
        monoeg_g_free (codebase);
        codebase = result;
      }
      <D.31115>:
      <D.31112>:
      if (codebase != 0B) goto <D.31116>; else goto <D.31117>;
      <D.31116>:
      D.31118 = &aname->codebase;
      D.31119 = mono_string_new (domain, codebase);
      mono_gc_wbarrier_set_field (aname, D.31118, D.31119);
      monoeg_g_free (codebase);
      <D.31117>:
      create_culture.146 = create_culture;
      if (create_culture.146 == 0B) goto <D.31121>; else goto <D.31122>;
      <D.31121>:
      {
        struct MonoMethodDesc * desc;

        desc = mono_method_desc_new ("System.Globalization.CultureInfo:CreateCulture(string,bool)", 1);
        D.31123 = mono_defaults.corlib;
        create_culture.147 = mono_method_desc_search_in_image (desc, D.31123);
        create_culture = create_culture.147;
        create_culture.146 = create_culture;
        D.31125 = create_culture.146 == 0B;
        D.31126 = (long int) D.31125;
        D.31127 = __builtin_expect (D.31126, 0);
        if (D.31127 != 0) goto <D.31128>; else goto <D.31129>;
        <D.31128>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4954, "create_culture");
        <D.31129>:
        mono_method_desc_free (desc);
      }
      <D.31122>:
      D.31130 = name->culture;
      if (D.31130 != 0B) goto <D.31131>; else goto <D.31132>;
      <D.31131>:
      D.31130 = name->culture;
      D.31133 = mono_string_new (domain, D.31130);
      args[0] = D.31133;
      args[1] = &assembly_ref;
      D.31134 = &aname->cultureInfo;
      create_culture.146 = create_culture;
      D.31135 = mono_runtime_invoke (create_culture.146, 0B, &args, 0B);
      mono_gc_wbarrier_set_field (aname, D.31134, D.31135);
      <D.31132>:
      pkey_ptr.148 = name->public_key;
      if (pkey_ptr.148 != 0B) goto <D.31137>; else goto <D.31138>;
      <D.31137>:
      pkey_ptr.148 = name->public_key;
      pkey_ptr = pkey_ptr.148;
      pkey_ptr.149 = pkey_ptr;
      pkey_len = mono_metadata_decode_blob_size (pkey_ptr.149, &pkey_ptr);
      D.31140 = &aname->publicKey;
      D.31141 = mono_defaults.byte_class;
      D.31142 = mono_array_new (domain, D.31141, pkey_len);
      mono_gc_wbarrier_set_field (aname, D.31140, D.31142);
      D.31143 = aname->publicKey;
      D.31144 = mono_array_addr_with_size (D.31143, 1, 0);
      pkey_ptr.149 = pkey_ptr;
      memcpy (D.31144, pkey_ptr.149, pkey_len);
      D.31145 = aname->flags;
      D.31146 = D.31145 | 1;
      aname->flags = D.31146;
      goto <D.31147>;
      <D.31138>:
      if (default_publickey != 0) goto <D.31148>; else goto <D.31149>;
      <D.31148>:
      D.31140 = &aname->publicKey;
      D.31141 = mono_defaults.byte_class;
      D.31150 = mono_array_new (domain, D.31141, 0);
      mono_gc_wbarrier_set_field (aname, D.31140, D.31150);
      D.31145 = aname->flags;
      D.31146 = D.31145 | 1;
      aname->flags = D.31146;
      <D.31149>:
      <D.31147>:
      D.31151 = name->public_key_token[0];
      if (D.31151 != 0) goto <D.31152>; else goto <D.31153>;
      <D.31152>:
      {
        int i;
        int j;
        char * p;

        D.31154 = &aname->keyToken;
        D.31141 = mono_defaults.byte_class;
        D.31155 = mono_array_new (domain, D.31141, 8);
        mono_gc_wbarrier_set_field (aname, D.31154, D.31155);
        D.31156 = aname->keyToken;
        p = mono_array_addr_with_size (D.31156, 1, 0);
        i = 0;
        j = 0;
        goto <D.24979>;
        <D.24978>:
        j.150 = j;
        j = j.150 + 1;
        D.31158 = name->public_key_token[j.150];
        D.31159 = monoeg_g_ascii_xdigit_value (D.31158);
        D.31160 = (char) D.31159;
        D.31161 = D.31160 << 4;
        *p = D.31161;
        j.151 = j;
        j = j.151 + 1;
        D.31163 = name->public_key_token[j.151];
        D.31164 = monoeg_g_ascii_xdigit_value (D.31163);
        D.31165 = *p;
        D.31166 = (signed char) D.31165;
        D.31167 = (signed char) D.31164;
        D.31168 = D.31166 | D.31167;
        D.31169 = (char) D.31168;
        *p = D.31169;
        p = p + 1;
        i = i + 1;
        <D.24979>:
        if (i <= 7) goto <D.24978>; else goto <D.24980>;
        <D.24980>:
      }
      goto <D.31170>;
      <D.31153>:
      if (default_token != 0) goto <D.31171>; else goto <D.31172>;
      <D.31171>:
      D.31154 = &aname->keyToken;
      D.31141 = mono_defaults.byte_class;
      D.31173 = mono_array_new (domain, D.31141, 0);
      mono_gc_wbarrier_set_field (aname, D.31154, D.31173);
      <D.31172>:
      <D.31170>:
    }
  finally
    {
      args = {CLOBBER};
      pkey_ptr = {CLOBBER};
      assembly_ref = {CLOBBER};
    }
}


create_version (struct MonoDomain * domain, guint32 major, guint32 minor, guint32 build, guint32 revision)
{
  struct MonoClass * System_Version.152;
  struct MonoImage * D.31177;
  struct MonoClass * System_Version.153;
  _Bool D.31179;
  long int D.31180;
  long int D.31181;
  struct MonoMethod * create_version.154;
  struct MonoMethod * create_version.155;
  _Bool D.31188;
  long int D.31189;
  long int D.31190;
  struct MonoObject * D.31193;
  static struct MonoClass * System_Version = 0B;
  static struct MonoMethod * create_version = 0B;
  struct MonoObject * result;
  void * args[4];

  try
    {
      System_Version.152 = System_Version;
      if (System_Version.152 == 0B) goto <D.31175>; else goto <D.31176>;
      <D.31175>:
      D.31177 = mono_defaults.corlib;
      System_Version.153 = mono_class_from_name (D.31177, "System", "Version");
      System_Version = System_Version.153;
      System_Version.152 = System_Version;
      D.31179 = System_Version.152 == 0B;
      D.31180 = (long int) D.31179;
      D.31181 = __builtin_expect (D.31180, 0);
      if (D.31181 != 0) goto <D.31182>; else goto <D.31183>;
      <D.31182>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4404, "System_Version");
      <D.31183>:
      <D.31176>:
      create_version.154 = create_version;
      if (create_version.154 == 0B) goto <D.31185>; else goto <D.31186>;
      <D.31185>:
      {
        struct MonoMethodDesc * desc;

        desc = mono_method_desc_new (":.ctor(int,int,int,int)", 0);
        System_Version.152 = System_Version;
        create_version.155 = mono_method_desc_search_in_class (desc, System_Version.152);
        create_version = create_version.155;
        create_version.154 = create_version;
        D.31188 = create_version.154 == 0B;
        D.31189 = (long int) D.31188;
        D.31190 = __builtin_expect (D.31189, 0);
        if (D.31190 != 0) goto <D.31191>; else goto <D.31192>;
        <D.31191>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4410, "create_version");
        <D.31192>:
        mono_method_desc_free (desc);
      }
      <D.31186>:
      args[0] = &major;
      args[1] = &minor;
      args[2] = &build;
      args[3] = &revision;
      System_Version.152 = System_Version;
      result = mono_object_new (domain, System_Version.152);
      create_version.154 = create_version;
      mono_runtime_invoke (create_version.154, result, &args, 0B);
      D.31193 = result;
      return D.31193;
    }
  finally
    {
      args = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_load_with_partial_name (struct MonoString * mname, struct MonoObject * evidence)
{
  struct MonoReflectionAssembly * D.31198;
  struct MonoDomain * D.31199;
  gchar * name;
  struct MonoAssembly * res;
  MonoImageOpenStatus status;

  try
    {
      name = mono_string_to_utf8 (mname);
      res = mono_assembly_load_with_partial_name (name, &status);
      monoeg_g_free (name);
      if (res == 0B) goto <D.31196>; else goto <D.31197>;
      <D.31196>:
      D.31198 = 0B;
      return D.31198;
      <D.31197>:
      D.31199 = mono_domain_get ();
      D.31198 = mono_assembly_get_object (D.31199, res);
      return D.31198;
    }
  finally
    {
      status = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_get_location (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.31202;
  struct MonoAssembly * D.31203;
  struct MonoImage * D.31204;
  const char * D.31205;
  struct MonoString * D.31206;
  struct MonoDomain * domain;
  struct MonoString * res;

  D.31202 = MEM[(struct MonoObject *)assembly].vtable;
  domain = D.31202->domain;
  D.31203 = assembly->assembly;
  D.31204 = D.31203->image;
  D.31205 = mono_image_get_filename (D.31204);
  res = mono_string_new (domain, D.31205);
  D.31206 = res;
  return D.31206;
}


ves_icall_System_Reflection_Assembly_get_global_assembly_cache (struct MonoReflectionAssembly * assembly)
{
  MonoBoolean D.31208;
  struct MonoAssembly * mass;

  mass = assembly->assembly;
  D.31208 = mass->in_gac;
  return D.31208;
}


ves_icall_System_Reflection_Assembly_get_fullName (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.31210;
  struct MonoAssemblyName * D.31211;
  struct MonoString * D.31212;
  struct MonoDomain * domain;
  struct MonoAssembly * mass;
  struct MonoString * res;
  gchar * name;

  D.31210 = MEM[(struct MonoObject *)assembly].vtable;
  domain = D.31210->domain;
  mass = assembly->assembly;
  D.31211 = &mass->aname;
  name = mono_stringify_assembly_name (D.31211);
  res = mono_string_new (domain, name);
  monoeg_g_free (name);
  D.31212 = res;
  return D.31212;
}


ves_icall_System_Reflection_Assembly_get_code_base (struct MonoReflectionAssembly * assembly, MonoBoolean escaped)
{
  struct MonoVTable * D.31214;
  struct MonoImage * D.31215;
  char * D.31216;
  int D.31217;
  gchar * absolute.156;
  gchar * absolute.157;
  char * D.31223;
  gchar * absolute.158;
  struct MonoString * D.31230;
  struct MonoDomain * domain;
  struct MonoAssembly * mass;
  struct MonoString * res;
  gchar * uri;
  gchar * absolute;
  gchar * dirname;

  try
    {
      D.31214 = MEM[(struct MonoObject *)assembly].vtable;
      domain = D.31214->domain;
      mass = assembly->assembly;
      res = 0B;
      D.31215 = mass->image;
      D.31216 = D.31215->name;
      D.31217 = monoeg_g_path_is_absolute (D.31216);
      if (D.31217 != 0) goto <D.31218>; else goto <D.31219>;
      <D.31218>:
      D.31215 = mass->image;
      D.31216 = D.31215->name;
      absolute.156 = monoeg_strdup (D.31216);
      absolute = absolute.156;
      absolute.157 = absolute;
      dirname = monoeg_g_path_get_dirname (absolute.157);
      goto <D.31222>;
      <D.31219>:
      D.31223 = mass->basedir;
      D.31215 = mass->image;
      D.31216 = D.31215->name;
      absolute.158 = monoeg_g_build_path ("/", D.31223, D.31216, 0B);
      absolute = absolute.158;
      D.31223 = mass->basedir;
      dirname = monoeg_strdup (D.31223);
      <D.31222>:
      replace_shadow_path (domain, dirname, &absolute);
      monoeg_g_free (dirname);
      if (escaped != 0) goto <D.31225>; else goto <D.31226>;
      <D.31225>:
      absolute.157 = absolute;
      uri = monoeg_g_filename_to_uri (absolute.157, 0B, 0B);
      goto <D.31227>;
      <D.31226>:
      {
        const char * prepend;

        prepend = "file://";
        absolute.157 = absolute;
        uri = monoeg_g_strconcat (prepend, absolute.157, 0B);
      }
      <D.31227>:
      if (uri != 0B) goto <D.31228>; else goto <D.31229>;
      <D.31228>:
      res = mono_string_new (domain, uri);
      monoeg_g_free (uri);
      <D.31229>:
      absolute.157 = absolute;
      monoeg_g_free (absolute.157);
      D.31230 = res;
      return D.31230;
    }
  finally
    {
      absolute = {CLOBBER};
    }
}


replace_shadow_path (struct MonoDomain * domain, gchar * dirname, gchar * * filename)
{
  int D.31233;
  int D.31238;
  gchar * content.159;
  int D.31241;
  gchar * D.31246;
  gboolean D.31249;
  gchar * content;
  gchar * shadow_ini_file;
  gsize len;

  try
    {
      D.31233 = mono_is_shadow_copy_enabled (domain, dirname);
      if (D.31233 != 0) goto <D.31234>; else goto <D.31235>;
      <D.31234>:
      shadow_ini_file = monoeg_g_build_path ("/", dirname, "__AssemblyInfo__.ini", 0B);
      content = 0B;
      D.31238 = monoeg_g_file_get_contents (shadow_ini_file, &content, &len, 0B);
      if (D.31238 == 0) goto <D.31236>; else goto <D.31239>;
      <D.31239>:
      content.159 = content;
      D.31241 = monoeg_g_file_test (content.159, 1);
      if (D.31241 == 0) goto <D.31236>; else goto <D.31237>;
      <D.31236>:
      content.159 = content;
      if (content.159 != 0B) goto <D.31242>; else goto <D.31243>;
      <D.31242>:
      content.159 = content;
      monoeg_g_free (content.159);
      content = 0B;
      <D.31243>:
      <D.31237>:
      monoeg_g_free (shadow_ini_file);
      content.159 = content;
      if (content.159 != 0B) goto <D.31244>; else goto <D.31245>;
      <D.31244>:
      D.31246 = *filename;
      if (D.31246 != 0B) goto <D.31247>; else goto <D.31248>;
      <D.31247>:
      D.31246 = *filename;
      monoeg_g_free (D.31246);
      <D.31248>:
      content.159 = content;
      *filename = content.159;
      D.31249 = 1;
      return D.31249;
      <D.31245>:
      <D.31235>:
      D.31249 = 0;
      return D.31249;
    }
  finally
    {
      content = {CLOBBER};
      len = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_get_ReflectionOnly (struct MonoReflectionAssembly * assembly)
{
  MonoBoolean D.31252;
  struct MonoAssembly * D.31253;
  int D.31254;

  D.31253 = assembly->assembly;
  D.31254 = D.31253->ref_only;
  D.31252 = (MonoBoolean) D.31254;
  return D.31252;
}


ves_icall_System_Reflection_Assembly_get_EntryPoint (struct MonoReflectionAssembly * assembly)
{
  struct MonoAssembly * D.31256;
  struct MonoImage * D.31257;
  struct MonoReflectionMethod * D.31260;
  struct MonoVTable * D.31261;
  struct MonoDomain * D.31262;
  struct MonoMethod * D.31263;
  guint32 token;

  D.31256 = assembly->assembly;
  D.31257 = D.31256->image;
  token = mono_image_get_entry_point (D.31257);
  if (token == 0) goto <D.31258>; else goto <D.31259>;
  <D.31258>:
  D.31260 = 0B;
  return D.31260;
  <D.31259>:
  D.31261 = MEM[(struct MonoObject *)assembly].vtable;
  D.31262 = D.31261->domain;
  D.31256 = assembly->assembly;
  D.31257 = D.31256->image;
  D.31263 = mono_get_method (D.31257, token, 0B);
  D.31260 = mono_method_get_object (D.31262, D.31263, 0B);
  return D.31260;
}


ves_icall_MonoDebugger_GetMethodToken (struct MonoReflectionMethod * method)
{
  gint32 D.31265;
  struct MonoMethod * D.31266;
  unsigned int D.31267;

  D.31266 = method->method;
  D.31267 = D.31266->token;
  D.31265 = (gint32) D.31267;
  return D.31265;
}


ves_icall_System_Reflection_Assembly_LoadPermissions (struct MonoReflectionAssembly * assembly, char * * minimum, guint32 * minLength, char * * optional, guint32 * optLength, char * * refused, guint32 * refLength)
{
  struct MonoAssembly * D.31269;
  unsigned char D.31270;
  char * D.31273;
  unsigned int D.31274;
  unsigned char D.31275;
  unsigned char D.31278;
  MonoBoolean D.31281;
  MonoBoolean result;
  struct MonoDeclSecurityEntry entry;

  try
    {
      result = 0;
      D.31269 = assembly->assembly;
      D.31270 = mono_declsec_get_assembly_action (D.31269, 8, &entry);
      if (D.31270 != 0) goto <D.31271>; else goto <D.31272>;
      <D.31271>:
      D.31273 = entry.blob;
      *minimum = D.31273;
      D.31274 = entry.size;
      *minLength = D.31274;
      result = 1;
      <D.31272>:
      D.31269 = assembly->assembly;
      D.31275 = mono_declsec_get_assembly_action (D.31269, 9, &entry);
      if (D.31275 != 0) goto <D.31276>; else goto <D.31277>;
      <D.31276>:
      D.31273 = entry.blob;
      *optional = D.31273;
      D.31274 = entry.size;
      *optLength = D.31274;
      result = 1;
      <D.31277>:
      D.31269 = assembly->assembly;
      D.31278 = mono_declsec_get_assembly_action (D.31269, 10, &entry);
      if (D.31278 != 0) goto <D.31279>; else goto <D.31280>;
      <D.31279>:
      D.31273 = entry.blob;
      *refused = D.31273;
      D.31274 = entry.size;
      *refLength = D.31274;
      result = 1;
      <D.31280>:
      D.31281 = result;
      return D.31281;
    }
  finally
    {
      entry = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_InternalImageRuntimeVersion (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.31284;
  struct MonoString * D.31285;
  struct MonoAssembly * D.31286;
  struct MonoImage * D.31287;
  char * D.31288;
  struct MonoDomain * domain;

  D.31284 = MEM[(struct MonoObject *)assembly].vtable;
  domain = D.31284->domain;
  D.31286 = assembly->assembly;
  D.31287 = D.31286->image;
  D.31288 = D.31287->version;
  D.31285 = mono_string_new (domain, D.31288);
  return D.31285;
}


ves_icall_System_Reflection_Assembly_InternalGetType (struct MonoReflectionAssembly * assembly, struct MonoReflectionModule * module, struct MonoString * name, MonoBoolean throwOnError, MonoBoolean ignoreCase)
{
  int D.31290;
  struct MonoException * D.31295;
  struct MonoReflectionType * D.31296;
  const char * D.31297;
  struct MonoClass * D.31302;
  struct MonoException * D.31305;
  struct MonoException * D.31307;
  struct MonoImage * D.31310;
  int D.31313;
  struct MonoAssembly * D.31316;
  unsigned char D.31317;
  struct MonoArray * D.31320;
  unsigned int i.160;
  char * D.31324;
  struct MonoDynamicImage * D.31325;
  struct MonoImage * D.31326;
  unsigned int D.31328;
  struct MonoArray * D.31331;
  char * D.31334;
  struct MonoImage * D.31335;
  unsigned int D.31337;
  struct MonoImage * D.31339;
  struct MonoLoaderError * D.31344;
  struct MonoLoaderError * D.31349;
  struct MonoLoaderError * D.31352;
  struct MonoLoaderError * D.31357;
  struct MonoException * D.31358;
  unsigned char D.31359;
  int D.31362;
  unsigned char D.31365;
  int D.31372;
  struct MonoVTable * D.31377;
  struct MonoDomain * D.31378;
  gchar * str;
  struct MonoType * type;
  struct MonoTypeNameParse info;
  gboolean type_resolve;

  try
    {
      type = 0B;
      type_resolve = 1;
      str = mono_string_to_utf8 (name);
      D.31290 = mono_reflection_parse_type (str, &info);
      if (D.31290 == 0) goto <D.31291>; else goto <D.31292>;
      <D.31291>:
      monoeg_g_free (str);
      mono_reflection_free_type_info (&info);
      if (throwOnError != 0) goto <D.31293>; else goto <D.31294>;
      <D.31293>:
      D.31295 = mono_get_exception_type_load (name, 0B);
      mono_raise_exception (D.31295);
      <D.31294>:
      D.31296 = 0B;
      return D.31296;
      <D.31292>:
      D.31297 = info.assembly.name;
      if (D.31297 != 0B) goto <D.31298>; else goto <D.31299>;
      <D.31298>:
      monoeg_g_free (str);
      mono_reflection_free_type_info (&info);
      if (throwOnError != 0) goto <D.31300>; else goto <D.31301>;
      <D.31300>:
      D.31302 = mono_defaults.generic_ilist_class;
      if (D.31302 != 0B) goto <D.31303>; else goto <D.31304>;
      <D.31303>:
      D.31305 = mono_get_exception_argument (0B, "Type names passed to Assembly.GetType() must not specify an assembly.");
      mono_raise_exception (D.31305);
      goto <D.31306>;
      <D.31304>:
      D.31307 = mono_get_exception_type_load (name, 0B);
      mono_raise_exception (D.31307);
      <D.31306>:
      <D.31301>:
      D.31296 = 0B;
      return D.31296;
      <D.31299>:
      if (module != 0B) goto <D.31308>; else goto <D.31309>;
      <D.31308>:
      D.31310 = module->image;
      if (D.31310 != 0B) goto <D.31311>; else goto <D.31312>;
      <D.31311>:
      D.31310 = module->image;
      D.31313 = (int) ignoreCase;
      type = mono_reflection_get_type (D.31310, &info, D.31313, &type_resolve);
      goto <D.31314>;
      <D.31312>:
      type = 0B;
      <D.31314>:
      goto <D.31315>;
      <D.31309>:
      D.31316 = assembly->assembly;
      D.31317 = D.31316->dynamic;
      if (D.31317 != 0) goto <D.31318>; else goto <D.31319>;
      <D.31318>:
      {
        struct MonoReflectionAssemblyBuilder * abuilder;
        int i;

        abuilder = assembly;
        type = 0B;
        D.31320 = abuilder->modules;
        if (D.31320 != 0B) goto <D.31321>; else goto <D.31322>;
        <D.31321>:
        i = 0;
        goto <D.24680>;
        <D.24679>:
        {
          struct MonoReflectionModuleBuilder * mb;

          D.31320 = abuilder->modules;
          i.160 = (unsigned int) i;
          D.31324 = mono_array_addr_with_size (D.31320, 4, i.160);
          mb = MEM[(struct MonoReflectionModuleBuilder * *)D.31324];
          D.31325 = mb->dynamic_image;
          D.31326 = &D.31325->image;
          D.31313 = (int) ignoreCase;
          type = mono_reflection_get_type (D.31326, &info, D.31313, &type_resolve);
          if (type != 0B) goto <D.24678>; else goto <D.31327>;
          <D.31327>:
        }
        i = i + 1;
        <D.24680>:
        i.160 = (unsigned int) i;
        D.31320 = abuilder->modules;
        D.31328 = mono_array_length (D.31320);
        if (i.160 < D.31328) goto <D.24679>; else goto <D.24678>;
        <D.24678>:
        <D.31322>:
        if (type == 0B) goto <D.31329>; else goto <D.31330>;
        <D.31329>:
        D.31331 = abuilder->loaded_modules;
        if (D.31331 != 0B) goto <D.31332>; else goto <D.31333>;
        <D.31332>:
        i = 0;
        goto <D.24684>;
        <D.24683>:
        {
          struct MonoReflectionModule * mod;

          D.31331 = abuilder->loaded_modules;
          i.160 = (unsigned int) i;
          D.31334 = mono_array_addr_with_size (D.31331, 4, i.160);
          mod = MEM[(struct MonoReflectionModule * *)D.31334];
          D.31335 = mod->image;
          D.31313 = (int) ignoreCase;
          type = mono_reflection_get_type (D.31335, &info, D.31313, &type_resolve);
          if (type != 0B) goto <D.24682>; else goto <D.31336>;
          <D.31336>:
        }
        i = i + 1;
        <D.24684>:
        i.160 = (unsigned int) i;
        D.31331 = abuilder->loaded_modules;
        D.31337 = mono_array_length (D.31331);
        if (i.160 < D.31337) goto <D.24683>; else goto <D.24682>;
        <D.24682>:
        <D.31333>:
        <D.31330>:
      }
      goto <D.31338>;
      <D.31319>:
      D.31316 = assembly->assembly;
      D.31339 = D.31316->image;
      D.31313 = (int) ignoreCase;
      type = mono_reflection_get_type (D.31339, &info, D.31313, &type_resolve);
      <D.31338>:
      <D.31315>:
      monoeg_g_free (str);
      mono_reflection_free_type_info (&info);
      if (type == 0B) goto <D.31340>; else goto <D.31341>;
      <D.31340>:
      {
        struct MonoException * e;

        e = 0B;
        if (throwOnError != 0) goto <D.31342>; else goto <D.31343>;
        <D.31342>:
        e = mono_get_exception_type_load (name, 0B);
        <D.31343>:
        D.31344 = mono_loader_get_last_error ();
        if (D.31344 != 0B) goto <D.31345>; else goto <D.31346>;
        <D.31345>:
        D.31302 = mono_defaults.generic_ilist_class;
        if (D.31302 != 0B) goto <D.31347>; else goto <D.31348>;
        <D.31347>:
        D.31349 = mono_loader_get_last_error ();
        e = mono_loader_error_prepare_exception (D.31349);
        <D.31348>:
        <D.31346>:
        mono_loader_clear_error ();
        if (e != 0B) goto <D.31350>; else goto <D.31351>;
        <D.31350>:
        mono_raise_exception (e);
        <D.31351>:
        D.31296 = 0B;
        return D.31296;
      }
      <D.31341>:
      D.31352 = mono_loader_get_last_error ();
      if (D.31352 != 0B) goto <D.31353>; else goto <D.31354>;
      <D.31353>:
      if (throwOnError != 0) goto <D.31355>; else goto <D.31356>;
      <D.31355>:
      D.31357 = mono_loader_get_last_error ();
      D.31358 = mono_loader_error_prepare_exception (D.31357);
      mono_raise_exception (D.31358);
      <D.31356>:
      mono_loader_clear_error ();
      <D.31354>:
      D.31359 = type->type;
      if (D.31359 == 18) goto <D.31360>; else goto <D.31361>;
      <D.31360>:
      {
        struct MonoClass * klass;

        klass = mono_type_get_class (type);
        D.31362 = mono_is_security_manager_active ();
        if (D.31362 != 0) goto <D.31363>; else goto <D.31364>;
        <D.31363>:
        D.31365 = klass->exception_type;
        if (D.31365 == 0) goto <D.31366>; else goto <D.31367>;
        <D.31366>:
        mono_class_setup_vtable (klass);
        <D.31367>:
        <D.31364>:
        if (throwOnError != 0) goto <D.31370>; else goto <D.31368>;
        <D.31370>:
        D.31365 = klass->exception_type;
        if (D.31365 != 0) goto <D.31371>; else goto <D.31368>;
        <D.31371>:
        {
          struct MonoException * exc;

          exc = mono_class_get_exception_for_failure (klass);
          mono_loader_clear_error ();
          mono_raise_exception (exc);
        }
        goto <D.31369>;
        <D.31368>:
        D.31372 = mono_is_security_manager_active ();
        if (D.31372 != 0) goto <D.31373>; else goto <D.31374>;
        <D.31373>:
        D.31365 = klass->exception_type;
        if (D.31365 == 2) goto <D.31375>; else goto <D.31376>;
        <D.31375>:
        D.31296 = 0B;
        return D.31296;
        <D.31376>:
        <D.31374>:
        <D.31369>:
      }
      <D.31361>:
      D.31377 = MEM[(struct MonoObject *)assembly].vtable;
      D.31378 = D.31377->domain;
      D.31296 = mono_type_get_object (D.31378, type);
      return D.31296;
    }
  finally
    {
      info = {CLOBBER};
      type_resolve = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (struct MonoString * fname, struct MonoReflectionAssemblyName * aname)
{
  char * filename.161;
  char * filename.162;
  struct MonoDomain * D.31383;
  <unnamed type> status.163;
  struct MonoException * D.31392;
  struct MonoDomain * D.31393;
  char * filename;
  MonoImageOpenStatus status;
  gboolean res;
  struct MonoImage * image;
  struct MonoAssemblyName name;
  char * dirname;

  try
    {
      status = 0;
      filename.161 = mono_string_to_utf8 (fname);
      filename = filename.161;
      filename.162 = filename;
      dirname = monoeg_g_path_get_dirname (filename.162);
      D.31383 = mono_domain_get ();
      replace_shadow_path (D.31383, dirname, &filename);
      monoeg_g_free (dirname);
      filename.162 = filename;
      image = mono_image_open (filename.162, &status);
      if (image == 0B) goto <D.31384>; else goto <D.31385>;
      <D.31384>:
      {
        struct MonoException * exc;

        filename.162 = filename;
        monoeg_g_free (filename.162);
        status.163 = status;
        if (status.163 == 3) goto <D.31387>; else goto <D.31388>;
        <D.31387>:
        exc = mono_get_exception_bad_image_format2 (0B, fname);
        goto <D.31389>;
        <D.31388>:
        exc = mono_get_exception_file_not_found2 (0B, fname);
        <D.31389>:
        mono_raise_exception (exc);
      }
      <D.31385>:
      res = mono_assembly_fill_assembly_name (image, &name);
      if (res == 0) goto <D.31390>; else goto <D.31391>;
      <D.31390>:
      mono_image_close (image);
      filename.162 = filename;
      monoeg_g_free (filename.162);
      D.31392 = mono_get_exception_argument ("assemblyFile", "The file does not contain a manifest");
      mono_raise_exception (D.31392);
      <D.31391>:
      D.31393 = mono_domain_get ();
      filename.162 = filename;
      fill_reflection_assembly_name (D.31393, aname, &name, filename.162, 1, 0, 1);
      filename.162 = filename;
      monoeg_g_free (filename.162);
      mono_image_close (image);
    }
  finally
    {
      filename = {CLOBBER};
      status = {CLOBBER};
      name = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetTypes (struct MonoReflectionAssembly * assembly, MonoBoolean exportedOnly)
{
  struct MonoVTable * D.31394;
  struct MonoAssembly * D.31395;
  unsigned char D.31396;
  _Bool D.31397;
  long int D.31398;
  long int D.31399;
  unsigned int D.31402;
  unsigned int D.31403;
  struct MonoAssembly * D.31406;
  int D.31407;
  unsigned int D.31408;
  unsigned int D.31411;
  struct MonoClass * D.31414;
  unsigned int D.31415;
  int len1.164;
  int len2.165;
  struct MonoArray * exceptions.166;
  struct MonoArray * ex2.167;
  <unnamed-unsigned:24> D.31420;
  int D.31421;
  unsigned int D.31422;
  unsigned int i.168;
  char * D.31424;
  struct MonoType * D.31427;
  unsigned char D.31430;
  _Bool D.31434;
  _Bool D.31435;
  _Bool D.31436;
  unsigned int D.31439;
  unsigned int ex_count.169;
  unsigned int D.31441;
  struct MonoClass * D.31442;
  unsigned int length.170;
  void * D.31444;
  unsigned int j.171;
  char * D.31446;
  _Bool D.31449;
  long int D.31450;
  long int D.31451;
  unsigned int D.31454;
  struct MonoArray * D.31455;
  struct MonoArray * res;
  struct MonoArray * exceptions;
  struct MonoImage * image;
  struct MonoTableInfo * table;
  struct MonoDomain * domain;
  struct GList * list;
  int i;
  int len;
  int ex_count;

  try
    {
      res = 0B;
      exceptions = 0B;
      image = 0B;
      table = 0B;
      list = 0B;
      D.31394 = MEM[(struct MonoObject *)assembly].vtable;
      domain = D.31394->domain;
      D.31395 = assembly->assembly;
      D.31396 = D.31395->dynamic;
      D.31397 = D.31396 != 0;
      D.31398 = (long int) D.31397;
      D.31399 = __builtin_expect (D.31398, 0);
      if (D.31399 != 0) goto <D.31400>; else goto <D.31401>;
      <D.31400>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5171, "!assembly->assembly->dynamic");
      <D.31401>:
      D.31395 = assembly->assembly;
      image = D.31395->image;
      table = &image->tables[38];
      res = mono_module_get_types (domain, image, &exceptions, exportedOnly);
      i = 0;
      goto <D.25068>;
      <D.25067>:
      D.31402 = mono_metadata_decode_row_col (table, i, 0);
      D.31403 = D.31402 & 1;
      if (D.31403 == 0) goto <D.31404>; else goto <D.31405>;
      <D.31404>:
      {
        struct MonoImage * loaded_image;

        D.31406 = image->assembly;
        D.31407 = i + 1;
        D.31408 = (unsigned int) D.31407;
        loaded_image = mono_assembly_load_module (D.31406, D.31408);
        if (loaded_image != 0B) goto <D.31409>; else goto <D.31410>;
        <D.31409>:
        {
          struct MonoArray * ex2;
          struct MonoArray * res2;

          try
            {
              res2 = mono_module_get_types (domain, loaded_image, &ex2, exportedOnly);
              D.31411 = mono_array_length (res2);
              if (D.31411 != 0) goto <D.31412>; else goto <D.31413>;
              <D.31412>:
              {
                guint32 len1;
                guint32 len2;
                struct MonoArray * res3;
                struct MonoArray * ex3;

                len1 = mono_array_length (res);
                len2 = mono_array_length (res2);
                D.31414 = mono_defaults.monotype_class;
                D.31415 = len1 + len2;
                res3 = mono_array_new (domain, D.31414, D.31415);
                {
                  void * * __p;
                  void * * __s;

                  __p = mono_array_addr_with_size (res3, 4, 0);
                  __s = mono_array_addr_with_size (res, 4, 0);
                  len1.164 = (int) len1;
                  mono_gc_wbarrier_arrayref_copy (__p, __s, len1.164);
                }
                {
                  void * * __p;
                  void * * __s;

                  __p = mono_array_addr_with_size (res3, 4, len1);
                  __s = mono_array_addr_with_size (res2, 4, 0);
                  len2.165 = (int) len2;
                  mono_gc_wbarrier_arrayref_copy (__p, __s, len2.165);
                }
                res = res3;
                D.31414 = mono_defaults.monotype_class;
                D.31415 = len1 + len2;
                ex3 = mono_array_new (domain, D.31414, D.31415);
                {
                  void * * __p;
                  void * * __s;

                  __p = mono_array_addr_with_size (ex3, 4, 0);
                  exceptions.166 = exceptions;
                  __s = mono_array_addr_with_size (exceptions.166, 4, 0);
                  len1.164 = (int) len1;
                  mono_gc_wbarrier_arrayref_copy (__p, __s, len1.164);
                }
                {
                  void * * __p;
                  void * * __s;

                  __p = mono_array_addr_with_size (ex3, 4, len1);
                  ex2.167 = ex2;
                  __s = mono_array_addr_with_size (ex2.167, 4, 0);
                  len2.165 = (int) len2;
                  mono_gc_wbarrier_arrayref_copy (__p, __s, len2.165);
                }
                exceptions = ex3;
              }
              <D.31413>:
            }
          finally
            {
              ex2 = {CLOBBER};
            }
        }
        <D.31410>:
      }
      <D.31405>:
      i = i + 1;
      <D.25068>:
      D.31420 = table->rows;
      D.31421 = (int) D.31420;
      if (D.31421 > i) goto <D.25067>; else goto <D.25069>;
      <D.25069>:
      D.31422 = mono_array_length (res);
      len = (int) D.31422;
      ex_count = 0;
      i = 0;
      goto <D.25074>;
      <D.25073>:
      {
        struct MonoReflectionType * t;
        struct MonoClass * klass;

        i.168 = (unsigned int) i;
        D.31424 = mono_array_addr_with_size (res, 4, i.168);
        t = MEM[(void * *)D.31424];
        if (t != 0B) goto <D.31425>; else goto <D.31426>;
        <D.31425>:
        D.31427 = t->type;
        klass = mono_type_get_class (D.31427);
        if (klass != 0B) goto <D.31428>; else goto <D.31429>;
        <D.31428>:
        D.31430 = klass->exception_type;
        if (D.31430 != 0) goto <D.31431>; else goto <D.31432>;
        <D.31431>:
        list = monoeg_g_list_append (list, klass);
        {
          void * * __p;

          i.168 = (unsigned int) i;
          __p = mono_array_addr_with_size (res, 4, i.168);
          mono_gc_wbarrier_set_arrayref (res, __p, 0B);
        }
        <D.31432>:
        <D.31429>:
        goto <D.31433>;
        <D.31426>:
        ex_count = ex_count + 1;
        <D.31433>:
      }
      i = i + 1;
      <D.25074>:
      if (i < len) goto <D.25073>; else goto <D.25075>;
      <D.25075>:
      D.31434 = list != 0B;
      D.31435 = ex_count != 0;
      D.31436 = D.31434 | D.31435;
      if (D.31436 != 0) goto <D.31437>; else goto <D.31438>;
      <D.31437>:
      {
        struct GList * tmp;
        struct MonoException * exc;
        struct MonoArray * exl;
        int j;
        int length;

        tmp = 0B;
        exc = 0B;
        exl = 0B;
        D.31439 = monoeg_g_list_length (list);
        ex_count.169 = (unsigned int) ex_count;
        D.31441 = D.31439 + ex_count.169;
        length = (int) D.31441;
        mono_loader_clear_error ();
        D.31442 = mono_defaults.exception_class;
        length.170 = (unsigned int) length;
        exl = mono_array_new (domain, D.31442, length.170);
        i = 0;
        tmp = list;
        goto <D.25084>;
        <D.25083>:
        {
          struct MonoException * exc;

          D.31444 = tmp->data;
          exc = mono_class_get_exception_for_failure (D.31444);
          {
            void * * __p;

            i.168 = (unsigned int) i;
            __p = mono_array_addr_with_size (exl, 4, i.168);
            mono_gc_wbarrier_set_arrayref (exl, __p, exc);
          }
        }
        i = i + 1;
        tmp = tmp->next;
        <D.25084>:
        if (tmp != 0B) goto <D.25083>; else goto <D.25085>;
        <D.25085>:
        j = 0;
        goto <D.25089>;
        <D.25088>:
        {
          struct MonoException * exc;

          exceptions.166 = exceptions;
          j.171 = (unsigned int) j;
          D.31446 = mono_array_addr_with_size (exceptions.166, 4, j.171);
          exc = MEM[(struct MonoException * *)D.31446];
          if (exc != 0B) goto <D.31447>; else goto <D.31448>;
          <D.31447>:
          D.31449 = i >= length;
          D.31450 = (long int) D.31449;
          D.31451 = __builtin_expect (D.31450, 0);
          if (D.31451 != 0) goto <D.31452>; else goto <D.31453>;
          <D.31452>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5248, "i < length");
          <D.31453>:
          {
            void * * __p;

            i.168 = (unsigned int) i;
            __p = mono_array_addr_with_size (exl, 4, i.168);
            mono_gc_wbarrier_set_arrayref (exl, __p, exc);
          }
          i = i + 1;
          <D.31448>:
        }
        j = j + 1;
        <D.25089>:
        j.171 = (unsigned int) j;
        exceptions.166 = exceptions;
        D.31454 = mono_array_length (exceptions.166);
        if (j.171 < D.31454) goto <D.25088>; else goto <D.25090>;
        <D.25090>:
        monoeg_g_list_free (list);
        list = 0B;
        exc = mono_get_exception_reflection_type_load (res, exl);
        mono_loader_clear_error ();
        mono_raise_exception (exc);
      }
      <D.31438>:
      D.31455 = res;
      return D.31455;
    }
  finally
    {
      exceptions = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.31458;
  struct MonoAssembly * D.31459;
  struct MonoClass * System_Reflection_AssemblyName.172;
  struct MonoImage * D.31463;
  struct MonoClass * System_Reflection_AssemblyName.173;
  struct MonoImage * D.31465;
  <unnamed-unsigned:24> D.31466;
  unsigned int count.174;
  struct MonoMethod * create_culture.175;
  struct MonoMethod * create_culture.176;
  _Bool D.31474;
  long int D.31475;
  long int D.31476;
  struct MonoString * * D.31479;
  unsigned int D.31480;
  const char * D.31481;
  struct MonoString * D.31482;
  unsigned int D.31483;
  int D.31484;
  unsigned int D.31485;
  int D.31486;
  unsigned int D.31487;
  int D.31488;
  unsigned int D.31489;
  int D.31490;
  unsigned int D.31491;
  struct MonoObject * * D.31492;
  int D.31493;
  unsigned int D.31494;
  int D.31495;
  unsigned int D.31496;
  int D.31497;
  unsigned int D.31498;
  int D.31499;
  unsigned int D.31500;
  struct MonoObject * D.31501;
  unsigned int D.31504;
  const char * D.31505;
  struct MonoString * D.31506;
  struct MonoObject * * D.31507;
  struct MonoObject * D.31508;
  unsigned int D.31509;
  const char * pkey_ptr.177;
  const gchar * pkey_ptr.178;
  unsigned int D.31514;
  struct MonoArray * * D.31517;
  struct MonoClass * D.31518;
  struct MonoArray * D.31519;
  struct MonoArray * D.31520;
  char * D.31521;
  struct MonoArray * * D.31523;
  struct MonoArray * D.31524;
  struct MonoArray * D.31525;
  char * D.31526;
  struct MonoArray * D.31528;
  unsigned int i.179;
  struct MonoArray * D.31530;
  static struct MonoClass * System_Reflection_AssemblyName;
  struct MonoArray * result;
  struct MonoDomain * domain;
  int i;
  int count;
  static struct MonoMethod * create_culture = 0B;
  struct MonoImage * image;
  struct MonoTableInfo * t;

  D.31458 = MEM[(struct MonoObject *)assembly].vtable;
  domain = D.31458->domain;
  count = 0;
  D.31459 = assembly->assembly;
  image = D.31459->image;
  System_Reflection_AssemblyName.172 = System_Reflection_AssemblyName;
  if (System_Reflection_AssemblyName.172 == 0B) goto <D.31461>; else goto <D.31462>;
  <D.31461>:
  D.31463 = mono_defaults.corlib;
  System_Reflection_AssemblyName.173 = mono_class_from_name (D.31463, "System.Reflection", "AssemblyName");
  System_Reflection_AssemblyName = System_Reflection_AssemblyName.173;
  <D.31462>:
  D.31459 = assembly->assembly;
  D.31465 = D.31459->image;
  t = &D.31465->tables[35];
  D.31466 = t->rows;
  count = (int) D.31466;
  System_Reflection_AssemblyName.172 = System_Reflection_AssemblyName;
  count.174 = (unsigned int) count;
  result = mono_array_new (domain, System_Reflection_AssemblyName.172, count.174);
  if (count > 0) goto <D.31468>; else goto <D.31469>;
  <D.31468>:
  create_culture.175 = create_culture;
  if (create_culture.175 == 0B) goto <D.31471>; else goto <D.31472>;
  <D.31471>:
  {
    struct MonoMethodDesc * desc;

    desc = mono_method_desc_new ("System.Globalization.CultureInfo:CreateCulture(string,bool)", 1);
    D.31463 = mono_defaults.corlib;
    create_culture.176 = mono_method_desc_search_in_image (desc, D.31463);
    create_culture = create_culture.176;
    create_culture.175 = create_culture;
    D.31474 = create_culture.175 == 0B;
    D.31475 = (long int) D.31474;
    D.31476 = __builtin_expect (D.31475, 0);
    if (D.31476 != 0) goto <D.31477>; else goto <D.31478>;
    <D.31477>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4450, "create_culture");
    <D.31478>:
    mono_method_desc_free (desc);
  }
  <D.31472>:
  <D.31469>:
  i = 0;
  goto <D.24780>;
  <D.24779>:
  {
    struct MonoReflectionAssemblyName * aname;
    guint32 cols[9];

    try
      {
        mono_metadata_decode_row (t, i, &cols, 9);
        System_Reflection_AssemblyName.172 = System_Reflection_AssemblyName;
        aname = mono_object_new (domain, System_Reflection_AssemblyName.172);
        D.31479 = &aname->name;
        D.31480 = cols[6];
        D.31481 = mono_metadata_string_heap (image, D.31480);
        D.31482 = mono_string_new (domain, D.31481);
        mono_gc_wbarrier_set_field (aname, D.31479, D.31482);
        D.31483 = cols[0];
        D.31484 = (int) D.31483;
        aname->major = D.31484;
        D.31485 = cols[1];
        D.31486 = (int) D.31485;
        aname->minor = D.31486;
        D.31487 = cols[2];
        D.31488 = (int) D.31487;
        aname->build = D.31488;
        D.31489 = cols[3];
        D.31490 = (int) D.31489;
        aname->revision = D.31490;
        D.31491 = cols[4];
        aname->flags = D.31491;
        aname->versioncompat = 1;
        aname->hashalg = 32772;
        D.31492 = &aname->version;
        D.31493 = aname->major;
        D.31494 = (unsigned int) D.31493;
        D.31495 = aname->minor;
        D.31496 = (unsigned int) D.31495;
        D.31497 = aname->build;
        D.31498 = (unsigned int) D.31497;
        D.31499 = aname->revision;
        D.31500 = (unsigned int) D.31499;
        D.31501 = create_version (domain, D.31494, D.31496, D.31498, D.31500);
        mono_gc_wbarrier_set_field (aname, D.31492, D.31501);
        create_culture.175 = create_culture;
        if (create_culture.175 != 0B) goto <D.31502>; else goto <D.31503>;
        <D.31502>:
        {
          void * args[2];
          MonoBoolean assembly_ref;

          try
            {
              assembly_ref = 1;
              D.31504 = cols[7];
              D.31505 = mono_metadata_string_heap (image, D.31504);
              D.31506 = mono_string_new (domain, D.31505);
              args[0] = D.31506;
              args[1] = &assembly_ref;
              D.31507 = &aname->cultureInfo;
              create_culture.175 = create_culture;
              D.31508 = mono_runtime_invoke (create_culture.175, 0B, &args, 0B);
              mono_gc_wbarrier_set_field (aname, D.31507, D.31508);
            }
          finally
            {
              args = {CLOBBER};
              assembly_ref = {CLOBBER};
            }
        }
        <D.31503>:
        D.31509 = cols[5];
        if (D.31509 != 0) goto <D.31510>; else goto <D.31511>;
        <D.31510>:
        {
          const gchar * pkey_ptr;
          guint32 pkey_len;

          try
            {
              D.31509 = cols[5];
              pkey_ptr.177 = mono_metadata_blob_heap (image, D.31509);
              pkey_ptr = pkey_ptr.177;
              pkey_ptr.178 = pkey_ptr;
              pkey_len = mono_metadata_decode_blob_size (pkey_ptr.178, &pkey_ptr);
              D.31491 = cols[4];
              D.31514 = D.31491 & 1;
              if (D.31514 != 0) goto <D.31515>; else goto <D.31516>;
              <D.31515>:
              D.31517 = &aname->publicKey;
              D.31518 = mono_defaults.byte_class;
              D.31519 = mono_array_new (domain, D.31518, pkey_len);
              mono_gc_wbarrier_set_field (aname, D.31517, D.31519);
              D.31520 = aname->publicKey;
              D.31521 = mono_array_addr_with_size (D.31520, 1, 0);
              pkey_ptr.178 = pkey_ptr;
              memcpy (D.31521, pkey_ptr.178, pkey_len);
              goto <D.31522>;
              <D.31516>:
              D.31523 = &aname->keyToken;
              D.31518 = mono_defaults.byte_class;
              D.31524 = mono_array_new (domain, D.31518, pkey_len);
              mono_gc_wbarrier_set_field (aname, D.31523, D.31524);
              D.31525 = aname->keyToken;
              D.31526 = mono_array_addr_with_size (D.31525, 1, 0);
              pkey_ptr.178 = pkey_ptr;
              memcpy (D.31526, pkey_ptr.178, pkey_len);
              <D.31522>:
            }
          finally
            {
              pkey_ptr = {CLOBBER};
            }
        }
        goto <D.31527>;
        <D.31511>:
        D.31523 = &aname->keyToken;
        D.31518 = mono_defaults.byte_class;
        D.31528 = mono_array_new (domain, D.31518, 0);
        mono_gc_wbarrier_set_field (aname, D.31523, D.31528);
        <D.31527>:
        {
          void * * __p;

          i.179 = (unsigned int) i;
          __p = mono_array_addr_with_size (result, 4, i.179);
          mono_gc_wbarrier_set_arrayref (result, __p, aname);
        }
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.24780>:
  if (i < count) goto <D.24779>; else goto <D.24781>;
  <D.24781>:
  D.31530 = result;
  return D.31530;
}


ves_icall_System_Reflection_Assembly_GetModulesInternal (struct MonoReflectionAssembly * assembly)
{
  struct MonoAssembly * D.31532;
  _Bool D.31533;
  long int D.31534;
  long int D.31535;
  unsigned char D.31538;
  _Bool D.31539;
  long int D.31540;
  long int D.31541;
  <unnamed-unsigned:24> D.31544;
  unsigned int i.180;
  unsigned int D.31546;
  struct MonoImage * * D.31547;
  struct MonoImage * D.31548;
  unsigned int i.181;
  struct MonoImage * D.31552;
  unsigned int file_count.182;
  unsigned int D.31554;
  unsigned int D.31555;
  struct MonoReflectionModule * D.31556;
  unsigned int j.183;
  struct MonoReflectionModule * D.31560;
  unsigned int D.31561;
  struct MonoReflectionModule * D.31564;
  int D.31566;
  struct MonoDomain * D.31569;
  unsigned int D.31570;
  const char * D.31571;
  struct MonoException * D.31572;
  struct MonoReflectionModule * D.31573;
  struct MonoArray * D.31574;
  struct MonoDomain * domain;
  struct MonoArray * res;
  struct MonoClass * klass;
  int i;
  int j;
  int file_count;
  struct MonoImage * * modules;
  guint32 module_count;
  guint32 real_module_count;
  struct MonoTableInfo * table;
  guint32 cols[3];
  struct MonoImage * image;

  try
    {
      domain = mono_domain_get ();
      file_count = 0;
      D.31532 = assembly->assembly;
      image = D.31532->image;
      D.31533 = image == 0B;
      D.31534 = (long int) D.31533;
      D.31535 = __builtin_expect (D.31534, 0);
      if (D.31535 != 0) goto <D.31536>; else goto <D.31537>;
      <D.31536>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4696, "image != NULL");
      <D.31537>:
      D.31532 = assembly->assembly;
      D.31538 = D.31532->dynamic;
      D.31539 = D.31538 != 0;
      D.31540 = (long int) D.31539;
      D.31541 = __builtin_expect (D.31540, 0);
      if (D.31541 != 0) goto <D.31542>; else goto <D.31543>;
      <D.31542>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4697, "!assembly->assembly->dynamic");
      <D.31543>:
      table = &image->tables[38];
      D.31544 = table->rows;
      file_count = (int) D.31544;
      modules = image->modules;
      module_count = image->module_count;
      real_module_count = 0;
      i = 0;
      goto <D.24888>;
      <D.24887>:
      i.180 = (unsigned int) i;
      D.31546 = i.180 * 4;
      D.31547 = modules + D.31546;
      D.31548 = *D.31547;
      if (D.31548 != 0B) goto <D.31549>; else goto <D.31550>;
      <D.31549>:
      real_module_count = real_module_count + 1;
      <D.31550>:
      i = i + 1;
      <D.24888>:
      i.181 = (unsigned int) i;
      if (i.181 < module_count) goto <D.24887>; else goto <D.24889>;
      <D.24889>:
      D.31552 = mono_defaults.corlib;
      klass = mono_class_from_name (D.31552, "System.Reflection", "Module");
      file_count.182 = (unsigned int) file_count;
      D.31554 = real_module_count + file_count.182;
      D.31555 = D.31554 + 1;
      res = mono_array_new (domain, klass, D.31555);
      {
        void * * __p;

        __p = mono_array_addr_with_size (res, 4, 0);
        D.31556 = mono_module_get_object (domain, image);
        mono_gc_wbarrier_set_arrayref (res, __p, D.31556);
      }
      j = 1;
      i = 0;
      goto <D.24893>;
      <D.24892>:
      i.180 = (unsigned int) i;
      D.31546 = i.180 * 4;
      D.31547 = modules + D.31546;
      D.31548 = *D.31547;
      if (D.31548 != 0B) goto <D.31557>; else goto <D.31558>;
      <D.31557>:
      {
        void * * __p;

        j.183 = (unsigned int) j;
        __p = mono_array_addr_with_size (res, 4, j.183);
        i.180 = (unsigned int) i;
        D.31546 = i.180 * 4;
        D.31547 = modules + D.31546;
        D.31548 = *D.31547;
        D.31560 = mono_module_get_object (domain, D.31548);
        mono_gc_wbarrier_set_arrayref (res, __p, D.31560);
      }
      j = j + 1;
      <D.31558>:
      i = i + 1;
      <D.24893>:
      i.181 = (unsigned int) i;
      if (i.181 < module_count) goto <D.24892>; else goto <D.24894>;
      <D.24894>:
      i = 0;
      goto <D.24900>;
      <D.24899>:
      mono_metadata_decode_row (table, i, &cols, 3);
      D.31561 = cols[0];
      if (D.31561 != 0) goto <D.31562>; else goto <D.31563>;
      <D.31562>:
      {
        void * * __p;

        j.183 = (unsigned int) j;
        __p = mono_array_addr_with_size (res, 4, j.183);
        D.31564 = mono_module_file_get_object (domain, image, i);
        mono_gc_wbarrier_set_arrayref (res, __p, D.31564);
      }
      goto <D.31565>;
      <D.31563>:
      {
        struct MonoImage * m;

        D.31566 = i + 1;
        m = mono_image_load_file_for_image (image, D.31566);
        if (m == 0B) goto <D.31567>; else goto <D.31568>;
        <D.31567>:
        {
          struct MonoString * fname;

          D.31569 = mono_domain_get ();
          D.31570 = cols[1];
          D.31571 = mono_metadata_string_heap (image, D.31570);
          fname = mono_string_new (D.31569, D.31571);
          D.31572 = mono_get_exception_file_not_found2 (0B, fname);
          mono_raise_exception (D.31572);
        }
        <D.31568>:
        {
          void * * __p;

          j.183 = (unsigned int) j;
          __p = mono_array_addr_with_size (res, 4, j.183);
          D.31573 = mono_module_get_object (domain, m);
          mono_gc_wbarrier_set_arrayref (res, __p, D.31573);
        }
      }
      <D.31565>:
      i = i + 1;
      j = j + 1;
      <D.24900>:
      if (i < file_count) goto <D.24899>; else goto <D.24901>;
      <D.24901>:
      D.31574 = res;
      return D.31574;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetManifestResourceNames (struct MonoReflectionAssembly * assembly)
{
  struct MonoAssembly * D.31577;
  struct MonoImage * D.31578;
  struct MonoVTable * D.31579;
  struct MonoDomain * D.31580;
  struct MonoClass * D.31581;
  <unnamed-unsigned:24> D.31582;
  unsigned int D.31583;
  unsigned int D.31584;
  unsigned int i.184;
  struct MonoString * D.31586;
  int D.31587;
  struct MonoArray * D.31588;
  struct MonoTableInfo * table;
  struct MonoArray * result;
  int i;
  const char * val;

  D.31577 = assembly->assembly;
  D.31578 = D.31577->image;
  table = &D.31578->tables[40];
  D.31579 = MEM[(struct MonoObject *)assembly].vtable;
  D.31580 = D.31579->domain;
  D.31581 = mono_defaults.string_class;
  D.31582 = table->rows;
  D.31583 = (unsigned int) D.31582;
  result = mono_array_new (D.31580, D.31581, D.31583);
  i = 0;
  goto <D.24746>;
  <D.24745>:
  D.31577 = assembly->assembly;
  D.31578 = D.31577->image;
  D.31584 = mono_metadata_decode_row_col (table, i, 2);
  val = mono_metadata_string_heap (D.31578, D.31584);
  {
    void * * __p;

    i.184 = (unsigned int) i;
    __p = mono_array_addr_with_size (result, 4, i.184);
    D.31579 = MEM[(struct MonoObject *)assembly].vtable;
    D.31580 = D.31579->domain;
    D.31586 = mono_string_new (D.31580, val);
    mono_gc_wbarrier_set_arrayref (result, __p, D.31586);
  }
  i = i + 1;
  <D.24746>:
  D.31582 = table->rows;
  D.31587 = (int) D.31582;
  if (D.31587 > i) goto <D.24745>; else goto <D.24747>;
  <D.24747>:
  D.31588 = result;
  return D.31588;
}


ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (struct MonoReflectionAssembly * assembly, struct MonoString * name, gint32 * size, struct MonoReflectionModule * * ref_module)
{
  struct MonoAssembly * D.31590;
  struct MonoImage * D.31591;
  int i.185;
  unsigned int D.31593;
  int D.24808;
  <unnamed-unsigned:24> D.31595;
  unsigned int D.31596;
  void * D.31599;
  unsigned int D.31602;
  _Bool D.31603;
  long int D.31604;
  long int D.31605;
  int file_idx.186;
  struct MonoDomain * D.31612;
  struct MonoReflectionModule * D.31613;
  unsigned int D.31614;
  char * n;
  struct MonoTableInfo * table;
  guint32 i;
  guint32 cols[4];
  guint32 impl;
  guint32 file_idx;
  const char * val;
  struct MonoImage * module;

  try
    {
      n = mono_string_to_utf8 (name);
      D.31590 = assembly->assembly;
      D.31591 = D.31590->image;
      table = &D.31591->tables[40];
      i = 0;
      goto <D.24811>;
      <D.24810>:
      i.185 = (int) i;
      mono_metadata_decode_row (table, i.185, &cols, 4);
      D.31590 = assembly->assembly;
      D.31591 = D.31590->image;
      D.31593 = cols[2];
      val = mono_metadata_string_heap (D.31591, D.31593);
      {
        size_t __s1_len;
        size_t __s2_len;

        D.24808 = __builtin_strcmp (val, n);
      }
      if (D.24808 == 0) goto <D.24809>; else goto <D.31594>;
      <D.31594>:
      i = i + 1;
      <D.24811>:
      D.31595 = table->rows;
      D.31596 = (unsigned int) D.31595;
      if (D.31596 > i) goto <D.24810>; else goto <D.24809>;
      <D.24809>:
      monoeg_g_free (n);
      D.31595 = table->rows;
      D.31596 = (unsigned int) D.31595;
      if (D.31596 == i) goto <D.31597>; else goto <D.31598>;
      <D.31597>:
      D.31599 = 0B;
      return D.31599;
      <D.31598>:
      impl = cols[3];
      if (impl != 0) goto <D.31600>; else goto <D.31601>;
      <D.31600>:
      D.31602 = impl & 3;
      D.31603 = D.31602 != 0;
      D.31604 = (long int) D.31603;
      D.31605 = __builtin_expect (D.31604, 0);
      if (D.31605 != 0) goto <D.31606>; else goto <D.31607>;
      <D.31606>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4553, "(impl & MONO_IMPLEMENTATION_MASK) == MONO_IMPLEMENTATION_FILE");
      <D.31607>:
      file_idx = impl >> 2;
      D.31590 = assembly->assembly;
      D.31591 = D.31590->image;
      file_idx.186 = (int) file_idx;
      module = mono_image_load_file_for_image (D.31591, file_idx.186);
      if (module == 0B) goto <D.31609>; else goto <D.31610>;
      <D.31609>:
      D.31599 = 0B;
      return D.31599;
      <D.31610>:
      goto <D.31611>;
      <D.31601>:
      D.31590 = assembly->assembly;
      module = D.31590->image;
      <D.31611>:
      D.31612 = mono_domain_get ();
      D.31613 = mono_module_get_object (D.31612, module);
      mono_gc_wbarrier_generic_store (ref_module, D.31613);
      D.31614 = cols[0];
      D.31599 = mono_image_get_resource (module, D.31614, size);
      return D.31599;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (struct MonoReflectionAssembly * assembly, struct MonoString * name, struct MonoManifestResourceInfo * info)
{
  struct MonoAssembly * D.31617;
  struct MonoImage * D.31618;
  unsigned int D.31619;
  int D.24831;
  <unnamed-unsigned:24> D.31621;
  int D.31622;
  gboolean D.31625;
  unsigned int D.31626;
  unsigned int D.31630;
  unsigned int D.31631;
  int D.31632;
  unsigned int D.31633;
  struct MonoString * * D.31634;
  struct MonoVTable * D.31635;
  struct MonoDomain * D.31636;
  struct MonoString * D.31637;
  unsigned int D.31638;
  struct MonoAssembly * * D.31642;
  sizetype i.187;
  sizetype D.31644;
  sizetype D.31645;
  struct MonoAssembly * * D.31646;
  struct MonoAssembly * D.31647;
  char * D.31650;
  struct MonoReflectionAssembly * * D.31651;
  struct MonoDomain * D.31652;
  struct MonoReflectionAssembly * D.31653;
  struct MonoReflectionAssembly * D.31654;
  unsigned int D.31655;
  unsigned int D.31656;
  struct MonoTableInfo * table;
  int i;
  guint32 cols[4];
  guint32 file_cols[3];
  const char * val;
  char * n;

  try
    {
      D.31617 = assembly->assembly;
      D.31618 = D.31617->image;
      table = &D.31618->tables[40];
      n = mono_string_to_utf8 (name);
      i = 0;
      goto <D.24834>;
      <D.24833>:
      mono_metadata_decode_row (table, i, &cols, 4);
      D.31617 = assembly->assembly;
      D.31618 = D.31617->image;
      D.31619 = cols[2];
      val = mono_metadata_string_heap (D.31618, D.31619);
      {
        size_t __s1_len;
        size_t __s2_len;

        D.24831 = __builtin_strcmp (val, n);
      }
      if (D.24831 == 0) goto <D.24832>; else goto <D.31620>;
      <D.31620>:
      i = i + 1;
      <D.24834>:
      D.31621 = table->rows;
      D.31622 = (int) D.31621;
      if (D.31622 > i) goto <D.24833>; else goto <D.24832>;
      <D.24832>:
      monoeg_g_free (n);
      D.31621 = table->rows;
      D.31622 = (int) D.31621;
      if (D.31622 == i) goto <D.31623>; else goto <D.31624>;
      <D.31623>:
      D.31625 = 0;
      return D.31625;
      <D.31624>:
      D.31626 = cols[3];
      if (D.31626 == 0) goto <D.31627>; else goto <D.31628>;
      <D.31627>:
      info->location = 5;
      goto <D.31629>;
      <D.31628>:
      D.31626 = cols[3];
      D.31630 = D.31626 & 3;
      switch (D.31630) <default: <D.31657>, case 0: <D.24835>, case 1: <D.24837>, case 2: <D.24840>>
      <D.24835>:
      D.31626 = cols[3];
      D.31631 = D.31626 >> 2;
      i = (int) D.31631;
      D.31617 = assembly->assembly;
      D.31618 = D.31617->image;
      table = &D.31618->tables[38];
      D.31632 = i + -1;
      mono_metadata_decode_row (table, D.31632, &file_cols, 3);
      D.31617 = assembly->assembly;
      D.31618 = D.31617->image;
      D.31633 = file_cols[1];
      val = mono_metadata_string_heap (D.31618, D.31633);
      D.31634 = &info->filename;
      D.31635 = MEM[(struct MonoObject *)assembly].vtable;
      D.31636 = D.31635->domain;
      D.31637 = mono_string_new (D.31636, val);
      mono_gc_wbarrier_set_field (info, D.31634, D.31637);
      D.31638 = file_cols[0];
      if (D.31638 != 0) goto <D.31639>; else goto <D.31640>;
      <D.31639>:
      info->location = 0;
      goto <D.31641>;
      <D.31640>:
      info->location = 1;
      <D.31641>:
      goto <D.24836>;
      <D.24837>:
      D.31626 = cols[3];
      D.31631 = D.31626 >> 2;
      i = (int) D.31631;
      D.31617 = assembly->assembly;
      D.31618 = D.31617->image;
      D.31632 = i + -1;
      mono_assembly_load_reference (D.31618, D.31632);
      D.31617 = assembly->assembly;
      D.31618 = D.31617->image;
      D.31642 = D.31618->references;
      i.187 = (sizetype) i;
      D.31644 = i.187 + 1073741823;
      D.31645 = D.31644 * 4;
      D.31646 = D.31642 + D.31645;
      D.31647 = *D.31646;
      if (D.31647 == 4294967295B) goto <D.31648>; else goto <D.31649>;
      <D.31648>:
      {
        char * msg;
        struct MonoException * ex;

        D.31632 = i + -1;
        D.31617 = assembly->assembly;
        D.31618 = D.31617->image;
        D.31650 = D.31618->name;
        msg = monoeg_g_strdup_printf ("Assembly %d referenced from assembly %s not found ", D.31632, D.31650);
        ex = mono_get_exception_file_not_found2 (msg, 0B);
        monoeg_g_free (msg);
        mono_raise_exception (ex);
      }
      <D.31649>:
      D.31651 = &info->assembly;
      D.31652 = mono_domain_get ();
      D.31617 = assembly->assembly;
      D.31618 = D.31617->image;
      D.31642 = D.31618->references;
      i.187 = (sizetype) i;
      D.31644 = i.187 + 1073741823;
      D.31645 = D.31644 * 4;
      D.31646 = D.31642 + D.31645;
      D.31647 = *D.31646;
      D.31653 = mono_assembly_get_object (D.31652, D.31647);
      mono_gc_wbarrier_set_field (info, D.31651, D.31653);
      D.31654 = info->assembly;
      ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (D.31654, name, info);
      D.31655 = info->location;
      D.31656 = D.31655 | 2;
      info->location = D.31656;
      goto <D.24836>;
      <D.24840>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 4625);
      <D.31657>:
      <D.24836>:
      <D.31629>:
      D.31625 = 1;
      return D.31625;
    }
  finally
    {
      cols = {CLOBBER};
      file_cols = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetManifestModuleInternal (struct MonoReflectionAssembly * assembly)
{
  struct MonoReflectionModule * D.31660;
  struct MonoVTable * D.31661;
  struct MonoDomain * D.31662;
  struct MonoAssembly * D.31663;
  struct MonoImage * D.31664;

  D.31661 = MEM[(struct MonoObject *)assembly].vtable;
  D.31662 = D.31661->domain;
  D.31663 = assembly->assembly;
  D.31664 = D.31663->image;
  D.31660 = mono_module_get_object (D.31662, D.31664);
  return D.31660;
}


ves_icall_System_Reflection_Assembly_GetFilesInternal (struct MonoReflectionAssembly * assembly, struct MonoString * name, MonoBoolean resource_modules)
{
  struct MonoAssembly * D.31666;
  struct MonoImage * D.31667;
  unsigned int D.31670;
  int D.24860;
  char * D.31673;
  struct MonoVTable * D.31674;
  struct MonoDomain * D.31675;
  struct MonoObject * D.31676;
  <unnamed-unsigned:24> D.31677;
  int D.31678;
  unsigned int D.31682;
  unsigned int D.31683;
  struct MonoClass * D.31684;
  unsigned int count.188;
  unsigned int D.31689;
  unsigned int D.31690;
  unsigned int D.31691;
  struct MonoString * D.31692;
  struct MonoTableInfo * table;
  struct MonoArray * result;
  int i;
  int count;
  const char * val;
  char * n;

  D.31666 = assembly->assembly;
  D.31667 = D.31666->image;
  table = &D.31667->tables[38];
  result = 0B;
  if (name != 0B) goto <D.31668>; else goto <D.31669>;
  <D.31668>:
  n = mono_string_to_utf8 (name);
  i = 0;
  goto <D.24863>;
  <D.24862>:
  D.31666 = assembly->assembly;
  D.31667 = D.31666->image;
  D.31670 = mono_metadata_decode_row_col (table, i, 1);
  val = mono_metadata_string_heap (D.31667, D.31670);
  {
    size_t __s1_len;
    size_t __s2_len;

    D.24860 = __builtin_strcmp (val, n);
  }
  if (D.24860 == 0) goto <D.31671>; else goto <D.31672>;
  <D.31671>:
  {
    struct MonoString * fn;

    monoeg_g_free (n);
    D.31666 = assembly->assembly;
    D.31673 = D.31666->basedir;
    n = g_concat_dir_and_file (D.31673, val);
    D.31674 = MEM[(struct MonoObject *)assembly].vtable;
    D.31675 = D.31674->domain;
    fn = mono_string_new (D.31675, n);
    monoeg_g_free (n);
    D.31676 = fn;
    return D.31676;
  }
  <D.31672>:
  i = i + 1;
  <D.24863>:
  D.31677 = table->rows;
  D.31678 = (int) D.31677;
  if (D.31678 > i) goto <D.24862>; else goto <D.24864>;
  <D.24864>:
  monoeg_g_free (n);
  D.31676 = 0B;
  return D.31676;
  <D.31669>:
  count = 0;
  i = 0;
  goto <D.24866>;
  <D.24865>:
  if (resource_modules != 0) goto <D.31679>; else goto <D.31681>;
  <D.31681>:
  D.31682 = mono_metadata_decode_row_col (table, i, 0);
  D.31683 = D.31682 & 1;
  if (D.31683 == 0) goto <D.31679>; else goto <D.31680>;
  <D.31679>:
  count = count + 1;
  <D.31680>:
  i = i + 1;
  <D.24866>:
  D.31677 = table->rows;
  D.31678 = (int) D.31677;
  if (D.31678 > i) goto <D.24865>; else goto <D.24867>;
  <D.24867>:
  D.31674 = MEM[(struct MonoObject *)assembly].vtable;
  D.31675 = D.31674->domain;
  D.31684 = mono_defaults.string_class;
  count.188 = (unsigned int) count;
  result = mono_array_new (D.31675, D.31684, count.188);
  count = 0;
  i = 0;
  goto <D.24870>;
  <D.24869>:
  if (resource_modules != 0) goto <D.31686>; else goto <D.31688>;
  <D.31688>:
  D.31689 = mono_metadata_decode_row_col (table, i, 0);
  D.31690 = D.31689 & 1;
  if (D.31690 == 0) goto <D.31686>; else goto <D.31687>;
  <D.31686>:
  D.31666 = assembly->assembly;
  D.31667 = D.31666->image;
  D.31691 = mono_metadata_decode_row_col (table, i, 1);
  val = mono_metadata_string_heap (D.31667, D.31691);
  D.31666 = assembly->assembly;
  D.31673 = D.31666->basedir;
  n = g_concat_dir_and_file (D.31673, val);
  {
    void * * __p;

    count.188 = (unsigned int) count;
    __p = mono_array_addr_with_size (result, 4, count.188);
    D.31674 = MEM[(struct MonoObject *)assembly].vtable;
    D.31675 = D.31674->domain;
    D.31692 = mono_string_new (D.31675, n);
    mono_gc_wbarrier_set_arrayref (result, __p, D.31692);
  }
  monoeg_g_free (n);
  count = count + 1;
  <D.31687>:
  i = i + 1;
  <D.24870>:
  D.31677 = table->rows;
  D.31678 = (int) D.31677;
  if (D.31678 > i) goto <D.24869>; else goto <D.24871>;
  <D.24871>:
  D.31676 = result;
  return D.31676;
}


g_concat_dir_and_file (const char * dir, const char * file)
{
  char * D.31696;
  unsigned int D.31699;
  sizetype D.31700;
  const char * D.31701;
  char D.31702;

  if (dir == 0B) goto <D.31694>; else goto <D.31695>;
  <D.31694>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "icall.c", 4511, "dir != NULL");
  D.31696 = 0B;
  return D.31696;
  <D.31695>:
  if (file == 0B) goto <D.31697>; else goto <D.31698>;
  <D.31697>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "icall.c", 4512, "file != NULL");
  D.31696 = 0B;
  return D.31696;
  <D.31698>:
  D.31699 = strlen (dir);
  D.31700 = D.31699 + 4294967295;
  D.31701 = dir + D.31700;
  D.31702 = *D.31701;
  if (D.31702 != 47) goto <D.31703>; else goto <D.31704>;
  <D.31703>:
  D.31696 = monoeg_g_strconcat (dir, "/", file, 0B);
  return D.31696;
  <D.31704>:
  D.31696 = monoeg_g_strconcat (dir, file, 0B);
  return D.31696;
}


ves_icall_System_Reflection_Assembly_GetExecutingAssembly ()
{
  struct MonoMethod * dest.189;
  _Bool D.31707;
  long int D.31708;
  long int D.31709;
  struct MonoReflectionAssembly * D.31712;
  struct MonoDomain * D.31713;
  struct MonoClass * D.31714;
  struct MonoImage * D.31715;
  struct MonoAssembly * D.31716;
  struct MonoMethod * dest;

  try
    {
      dest = 0B;
      mono_stack_walk_no_il (get_executing, &dest);
      dest.189 = dest;
      D.31707 = dest.189 == 0B;
      D.31708 = (long int) D.31707;
      D.31709 = __builtin_expect (D.31708, 0);
      if (D.31709 != 0) goto <D.31710>; else goto <D.31711>;
      <D.31710>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4821, "dest");
      <D.31711>:
      D.31713 = mono_domain_get ();
      dest.189 = dest;
      D.31714 = dest.189->klass;
      D.31715 = D.31714->image;
      D.31716 = D.31715->assembly;
      D.31712 = mono_assembly_get_object (D.31713, D.31716);
      return D.31712;
    }
  finally
    {
      dest = {CLOBBER};
    }
}


get_executing (struct MonoMethod * m, gint32 no, gint32 ilo, gboolean managed, void * data)
{
  gboolean D.31721;
  struct MonoMethod * D.31722;
  int D.23401;
  int iftmp.190;
  int D.23400;
  struct MonoClass * D.31728;
  const char[18] * D.31729;
  unsigned char D.31730;
  int D.31731;
  unsigned char D.31732;
  int D.31733;
  _Bool D.31734;
  _Bool D.31735;
  _Bool D.31736;
  const unsigned char * D.31739;
  unsigned char D.31740;
  int D.31741;
  const unsigned char * D.31742;
  unsigned char D.31743;
  int D.31744;
  _Bool D.31745;
  _Bool D.31746;
  const unsigned char * D.31749;
  unsigned char D.31750;
  int D.31751;
  const unsigned char * D.31752;
  unsigned char D.31753;
  int D.31754;
  _Bool D.31755;
  _Bool D.31756;
  const unsigned char * D.31759;
  unsigned char D.31760;
  int D.31761;
  const unsigned char * D.31762;
  unsigned char D.31763;
  int D.31764;
  const char * D.31766;
  struct MonoMethod * * dest;

  dest = data;
  if (managed == 0) goto <D.31719>; else goto <D.31720>;
  <D.31719>:
  D.31721 = 0;
  return D.31721;
  <D.31720>:
  D.31722 = *dest;
  if (D.31722 == 0B) goto <D.31723>; else goto <D.31724>;
  <D.31723>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 17;
    if (__s2_len <= 3) goto <D.31726>; else goto <D.31727>;
    <D.31726>:
    {
      const unsigned char * __s2;
      int __result;

      D.31728 = m->klass;
      __s2 = D.31728->name_space;
      D.31729 = "System.Reflection";
      D.31730 = MEM[(const unsigned char *)D.31729];
      D.31731 = (int) D.31730;
      D.31732 = *__s2;
      D.31733 = (int) D.31732;
      __result = D.31731 - D.31733;
      {
        D.31734 = __s2_len != 0;
        D.31735 = __result == 0;
        D.31736 = D.31734 & D.31735;
        if (D.31736 != 0) goto <D.31737>; else goto <D.31738>;
        <D.31737>:
        D.31739 = &MEM[(void *)"System.Reflection" + 1B];
        D.31740 = *D.31739;
        D.31741 = (int) D.31740;
        D.31742 = __s2 + 1;
        D.31743 = *D.31742;
        D.31744 = (int) D.31743;
        __result = D.31741 - D.31744;
        D.31745 = __s2_len > 1;
        D.31735 = __result == 0;
        D.31746 = D.31745 & D.31735;
        if (D.31746 != 0) goto <D.31747>; else goto <D.31748>;
        <D.31747>:
        D.31749 = &MEM[(void *)"System.Reflection" + 2B];
        D.31750 = *D.31749;
        D.31751 = (int) D.31750;
        D.31752 = __s2 + 2;
        D.31753 = *D.31752;
        D.31754 = (int) D.31753;
        __result = D.31751 - D.31754;
        D.31755 = __s2_len > 2;
        D.31735 = __result == 0;
        D.31756 = D.31755 & D.31735;
        if (D.31756 != 0) goto <D.31757>; else goto <D.31758>;
        <D.31757>:
        D.31759 = &MEM[(void *)"System.Reflection" + 3B];
        D.31760 = *D.31759;
        D.31761 = (int) D.31760;
        D.31762 = __s2 + 3;
        D.31763 = *D.31762;
        D.31764 = (int) D.31763;
        __result = D.31761 - D.31764;
        <D.31758>:
        <D.31748>:
        <D.31738>:
      }
      D.23400 = __result;
    }
    iftmp.190 = -D.23400;
    goto <D.31765>;
    <D.31727>:
    D.31728 = m->klass;
    D.31766 = D.31728->name_space;
    iftmp.190 = __builtin_strcmp (D.31766, "System.Reflection");
    <D.31765>:
    D.23401 = iftmp.190;
  }
  if (D.23401 == 0) goto <D.31767>; else goto <D.31768>;
  <D.31767>:
  D.31721 = 0;
  return D.31721;
  <D.31768>:
  *dest = m;
  D.31721 = 1;
  return D.31721;
  <D.31724>:
  D.31721 = 0;
  return D.31721;
}


ves_icall_System_Reflection_Assembly_GetEntryAssembly ()
{
  struct MonoAssembly * D.31770;
  struct MonoReflectionAssembly * D.31773;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.31770 = domain->entry_assembly;
  if (D.31770 == 0B) goto <D.31771>; else goto <D.31772>;
  <D.31771>:
  D.31773 = 0B;
  return D.31773;
  <D.31772>:
  D.31770 = domain->entry_assembly;
  D.31773 = mono_assembly_get_object (domain, D.31770);
  return D.31773;
}


ves_icall_System_Reflection_Assembly_GetCallingAssembly ()
{
  struct MonoMethod * dest.191;
  struct MonoReflectionAssembly * D.31778;
  struct MonoDomain * D.31779;
  struct MonoClass * D.31780;
  struct MonoImage * D.31781;
  struct MonoAssembly * D.31782;
  struct MonoMethod * m;
  struct MonoMethod * dest;

  try
    {
      dest = 0B;
      mono_stack_walk_no_il (get_executing, &dest);
      m = dest;
      mono_stack_walk_no_il (get_caller, &dest);
      dest.191 = dest;
      if (dest.191 == 0B) goto <D.31776>; else goto <D.31777>;
      <D.31776>:
      dest = m;
      <D.31777>:
      D.31779 = mono_domain_get ();
      dest.191 = dest;
      D.31780 = dest.191->klass;
      D.31781 = D.31780->image;
      D.31782 = D.31781->assembly;
      D.31778 = mono_assembly_get_object (D.31779, D.31782);
      return D.31778;
    }
  finally
    {
      dest = {CLOBBER};
    }
}


get_caller (struct MonoMethod * m, gint32 no, gint32 ilo, gboolean managed, void * data)
{
  gboolean D.31787;
  struct MonoMethod * D.31788;
  struct MonoMethod * * dest;

  dest = data;
  if (managed == 0) goto <D.31785>; else goto <D.31786>;
  <D.31785>:
  D.31787 = 0;
  return D.31787;
  <D.31786>:
  D.31788 = *dest;
  if (D.31788 == m) goto <D.31789>; else goto <D.31790>;
  <D.31789>:
  *dest = 0B;
  D.31787 = 0;
  return D.31787;
  <D.31790>:
  D.31788 = *dest;
  if (D.31788 == 0B) goto <D.31791>; else goto <D.31792>;
  <D.31791>:
  *dest = m;
  D.31787 = 1;
  return D.31787;
  <D.31792>:
  D.31787 = 0;
  return D.31787;
}


ves_icall_System_Reflection_Assembly_FillName (struct MonoReflectionAssembly * assembly, struct MonoReflectionAssemblyName * aname)
{
  struct MonoImage * D.31794;
  char * D.31795;
  int D.31796;
  struct MonoVTable * D.31799;
  struct MonoDomain * D.31800;
  struct MonoAssemblyName * D.31801;
  char * D.31802;
  gchar * absolute;
  struct MonoAssembly * mass;

  mass = assembly->assembly;
  D.31794 = mass->image;
  D.31795 = D.31794->name;
  D.31796 = monoeg_g_path_is_absolute (D.31795);
  if (D.31796 != 0) goto <D.31797>; else goto <D.31798>;
  <D.31797>:
  D.31799 = MEM[(struct MonoObject *)assembly].vtable;
  D.31800 = D.31799->domain;
  D.31801 = &mass->aname;
  D.31794 = mass->image;
  D.31795 = D.31794->name;
  fill_reflection_assembly_name (D.31800, aname, D.31801, D.31795, 1, 1, 1);
  return;
  <D.31798>:
  D.31802 = mass->basedir;
  D.31794 = mass->image;
  D.31795 = D.31794->name;
  absolute = monoeg_g_build_path ("/", D.31802, D.31795, 0B);
  D.31799 = MEM[(struct MonoObject *)assembly].vtable;
  D.31800 = D.31799->domain;
  D.31801 = &mass->aname;
  fill_reflection_assembly_name (D.31800, aname, D.31801, absolute, 1, 1, 1);
  monoeg_g_free (absolute);
}


ves_icall_System_Object_obj_address (struct MonoObject * this)
{
  void * D.31804;

  D.31804 = this;
  return D.31804;
}


ves_icall_System_Object_MemberwiseClone (struct MonoObject * this)
{
  struct MonoObject * D.31806;

  D.31806 = mono_object_clone (this);
  return D.31806;
}


ves_icall_System_Object_GetType (struct MonoObject * obj)
{
  struct MonoVTable * D.31808;
  struct MonoClass * D.31809;
  struct MonoClass * D.31810;
  struct MonoReflectionType * D.31813;
  struct MonoDomain * D.31814;
  struct MonoRemoteClass * D.31815;
  struct MonoClass * D.31816;
  struct MonoType * D.31817;
  struct MonoType * D.31818;

  D.31808 = obj->vtable;
  D.31809 = D.31808->klass;
  D.31810 = mono_defaults.transparent_proxy_class;
  if (D.31809 == D.31810) goto <D.31811>; else goto <D.31812>;
  <D.31811>:
  D.31808 = obj->vtable;
  D.31814 = D.31808->domain;
  D.31815 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
  D.31816 = D.31815->proxy_class;
  D.31817 = &D.31816->byval_arg;
  D.31813 = mono_type_get_object (D.31814, D.31817);
  return D.31813;
  <D.31812>:
  D.31808 = obj->vtable;
  D.31814 = D.31808->domain;
  D.31808 = obj->vtable;
  D.31809 = D.31808->klass;
  D.31818 = &D.31809->byval_arg;
  D.31813 = mono_type_get_object (D.31814, D.31818);
  return D.31813;
}


ves_icall_System_NumberFormatter_GetFormatterTables (const guint64 * * mantissas, const gint32 * * exponents, const gunichar2 * * digitLowerTable, const gunichar2 * * digitUpperTable, const gint64 * * tenPowersList, const gint32 * * decHexDigits)
{
  *mantissas = &Formatter_MantissaBitsTable;
  *exponents = &Formatter_TensExponentTable;
  *digitLowerTable = &Formatter_DigitLowerTable;
  *digitUpperTable = &Formatter_DigitUpperTable;
  *tenPowersList = &Formatter_TenPowersList;
  *decHexDigits = &Formatter_DecHexDigits;
}


mono_type_type_from_obj (struct MonoReflectionType * mtype, struct MonoObject * obj)
{
  struct MonoVTable * D.31820;
  struct MonoClass * D.31821;
  struct MonoType * D.31822;
  struct MonoType * D.31823;
  unsigned char D.31824;
  _Bool D.31825;
  long int D.31826;
  long int D.31827;

  D.31820 = obj->vtable;
  D.31821 = D.31820->klass;
  D.31822 = &D.31821->byval_arg;
  mtype->type = D.31822;
  D.31823 = mtype->type;
  D.31824 = D.31823->type;
  D.31825 = D.31824 == 0;
  D.31826 = (long int) D.31825;
  D.31827 = __builtin_expect (D.31826, 0);
  if (D.31827 != 0) goto <D.31828>; else goto <D.31829>;
  <D.31828>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1149, "mtype->type->type");
  <D.31829>:
}


vell_icall_MonoType_get_core_clr_security_level (struct MonoReflectionType * this)
{
  struct MonoType * D.31830;
  int D.31831;
  <unnamed type> D.31832;
  struct MonoClass * klass;

  D.31830 = this->type;
  klass = mono_class_from_mono_type (D.31830);
  mono_class_init_or_throw (klass);
  D.31832 = mono_security_core_clr_class_level (klass);
  D.31831 = (int) D.31832;
  return D.31831;
}


ves_icall_get_attributes (struct MonoReflectionType * type)
{
  struct MonoType * D.31834;
  guint32 D.31835;
  struct MonoClass * klass;

  D.31834 = type->type;
  klass = mono_class_from_mono_type (D.31834);
  D.31835 = klass->flags;
  return D.31835;
}


ves_icall_MonoType_get_Namespace (struct MonoReflectionType * type)
{
  struct MonoType * D.31837;
  struct MonoClass * D.31838;
  const char * D.31839;
  char D.31840;
  struct MonoString * D.31843;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.31837 = type->type;
  class = mono_class_from_mono_type (D.31837);
  goto <D.23871>;
  <D.23870>:
  class = class->nested_in;
  <D.23871>:
  D.31838 = class->nested_in;
  if (D.31838 != 0B) goto <D.23870>; else goto <D.23872>;
  <D.23872>:
  D.31839 = class->name_space;
  D.31840 = *D.31839;
  if (D.31840 == 0) goto <D.31841>; else goto <D.31842>;
  <D.31841>:
  D.31843 = 0B;
  return D.31843;
  <D.31842>:
  D.31839 = class->name_space;
  D.31843 = mono_string_new (domain, D.31839);
  return D.31843;
}


ves_icall_MonoType_get_Name (struct MonoReflectionType * type)
{
  struct MonoType * D.31845;
  unsigned char D.31846;
  unsigned char D.31847;
  const char * D.31850;
  struct MonoString * D.31851;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.31845 = type->type;
  class = mono_class_from_mono_type (D.31845);
  D.31845 = type->type;
  D.31846 = BIT_FIELD_REF <*D.31845, 8, 56>;
  D.31847 = D.31846 & 64;
  if (D.31847 != 0) goto <D.31848>; else goto <D.31849>;
  <D.31848>:
  {
    char * n;
    struct MonoString * res;

    D.31850 = class->name;
    n = monoeg_g_strdup_printf ("%s&", D.31850);
    res = mono_string_new (domain, n);
    monoeg_g_free (n);
    D.31851 = res;
    return D.31851;
  }
  <D.31849>:
  D.31850 = class->name;
  D.31851 = mono_string_new (domain, D.31850);
  return D.31851;
}


ves_icall_MonoType_get_Module (struct MonoReflectionType * type)
{
  struct MonoType * D.31853;
  struct MonoReflectionModule * D.31854;
  struct MonoVTable * D.31855;
  struct MonoDomain * D.31856;
  struct MonoImage * D.31857;
  struct MonoClass * class;

  D.31853 = type->type;
  class = mono_class_from_mono_type (D.31853);
  D.31855 = MEM[(struct MonoObject *)type].vtable;
  D.31856 = D.31855->domain;
  D.31857 = class->image;
  D.31854 = mono_module_get_object (D.31856, D.31857);
  return D.31854;
}


ves_icall_MonoType_get_IsGenericParameter (struct MonoReflectionType * type)
{
  MonoBoolean D.31859;
  struct MonoType * D.31860;

  D.31860 = type->type;
  D.31859 = is_generic_parameter (D.31860);
  return D.31859;
}


ves_icall_MonoType_get_DeclaringType (struct MonoReflectionType * type)
{
  struct MonoType * D.31862;
  unsigned char D.31863;
  unsigned char D.31864;
  struct MonoReflectionType * D.31867;
  unsigned char D.31868;
  struct MonoGenericParam * D.31871;
  struct MonoGenericContainer * D.31872;
  struct MonoMethod * D.31876;
  struct MonoClass * D.31878;
  struct MonoReflectionType * iftmp.192;
  struct MonoType * D.31882;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.31862 = type->type;
  D.31863 = BIT_FIELD_REF <*D.31862, 8, 56>;
  D.31864 = D.31863 & 64;
  if (D.31864 != 0) goto <D.31865>; else goto <D.31866>;
  <D.31865>:
  D.31867 = 0B;
  return D.31867;
  <D.31866>:
  D.31862 = type->type;
  D.31868 = D.31862->type;
  if (D.31868 == 19) goto <D.31869>; else goto <D.31870>;
  <D.31869>:
  D.31862 = type->type;
  D.31871 = D.31862->data.generic_param;
  D.31872 = D.31871->owner;
  class = D.31872->owner.klass;
  goto <D.31873>;
  <D.31870>:
  D.31862 = type->type;
  D.31868 = D.31862->type;
  if (D.31868 == 30) goto <D.31874>; else goto <D.31875>;
  <D.31874>:
  D.31862 = type->type;
  D.31871 = D.31862->data.generic_param;
  D.31872 = D.31871->owner;
  D.31876 = D.31872->owner.method;
  class = D.31876->klass;
  goto <D.31877>;
  <D.31875>:
  D.31862 = type->type;
  D.31878 = mono_class_from_mono_type (D.31862);
  class = D.31878->nested_in;
  <D.31877>:
  <D.31873>:
  if (class != 0B) goto <D.31880>; else goto <D.31881>;
  <D.31880>:
  D.31882 = &class->byval_arg;
  iftmp.192 = mono_type_get_object (domain, D.31882);
  goto <D.31883>;
  <D.31881>:
  iftmp.192 = 0B;
  <D.31883>:
  D.31867 = iftmp.192;
  return D.31867;
}


ves_icall_MonoType_get_DeclaringMethod (struct MonoReflectionType * ref_type)
{
  unsigned char D.31887;
  unsigned char D.31888;
  unsigned char D.31890;
  _Bool D.31891;
  _Bool D.31892;
  _Bool D.31893;
  struct MonoException * D.31894;
  unsigned char D.31895;
  struct MonoReflectionMethod * D.31898;
  struct MonoGenericParam * D.31899;
  struct MonoGenericContainer * D.31900;
  _Bool D.31901;
  long int D.31902;
  long int D.31903;
  struct MonoVTable * D.31906;
  struct MonoDomain * D.31907;
  struct MonoClass * D.31908;
  struct MonoMethod * method;
  struct MonoType * type;

  type = ref_type->type;
  D.31887 = BIT_FIELD_REF <*type, 8, 56>;
  D.31888 = D.31887 & 64;
  if (D.31888 != 0) goto <D.31885>; else goto <D.31889>;
  <D.31889>:
  D.31890 = type->type;
  D.31891 = D.31890 != 30;
  D.31892 = D.31890 != 19;
  D.31893 = D.31891 & D.31892;
  if (D.31893 != 0) goto <D.31885>; else goto <D.31886>;
  <D.31885>:
  D.31894 = mono_get_exception_invalid_operation ("DeclaringMethod can only be used on generic arguments");
  mono_raise_exception (D.31894);
  <D.31886>:
  D.31895 = type->type;
  if (D.31895 == 19) goto <D.31896>; else goto <D.31897>;
  <D.31896>:
  D.31898 = 0B;
  return D.31898;
  <D.31897>:
  D.31899 = type->data.generic_param;
  D.31900 = D.31899->owner;
  method = D.31900->owner.method;
  D.31901 = method == 0B;
  D.31902 = (long int) D.31901;
  D.31903 = __builtin_expect (D.31902, 0);
  if (D.31903 != 0) goto <D.31904>; else goto <D.31905>;
  <D.31904>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2570, "method");
  <D.31905>:
  D.31906 = MEM[(struct MonoObject *)ref_type].vtable;
  D.31907 = D.31906->domain;
  D.31908 = method->klass;
  D.31898 = mono_method_get_object (D.31907, method, D.31908);
  return D.31898;
}


ves_icall_get_type_parent (struct MonoReflectionType * type)
{
  struct MonoType * D.31910;
  struct MonoReflectionType * D.31911;
  struct MonoReflectionType * iftmp.193;
  struct MonoClass * D.31913;
  struct MonoVTable * D.31916;
  struct MonoDomain * D.31917;
  struct MonoType * D.31918;
  struct MonoClass * class;

  D.31910 = type->type;
  class = mono_class_from_mono_type (D.31910);
  D.31913 = class->parent;
  if (D.31913 != 0B) goto <D.31914>; else goto <D.31915>;
  <D.31914>:
  D.31916 = MEM[(struct MonoObject *)type].vtable;
  D.31917 = D.31916->domain;
  D.31913 = class->parent;
  D.31918 = &D.31913->byval_arg;
  iftmp.193 = mono_type_get_object (D.31917, D.31918);
  goto <D.31919>;
  <D.31915>:
  iftmp.193 = 0B;
  <D.31919>:
  D.31911 = iftmp.193;
  return D.31911;
}


ves_icall_MonoType_get_Assembly (struct MonoReflectionType * type)
{
  struct MonoType * D.31921;
  struct MonoReflectionAssembly * D.31922;
  struct MonoImage * D.31923;
  struct MonoAssembly * D.31924;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.31921 = type->type;
  class = mono_class_from_mono_type (D.31921);
  D.31923 = class->image;
  D.31924 = D.31923->assembly;
  D.31922 = mono_assembly_get_object (domain, D.31924);
  return D.31922;
}


ves_icall_System_MonoType_getFullName (struct MonoReflectionType * object, gboolean full_name, gboolean assembly_qualified)
{
  struct MonoVTable * D.31926;
  MonoTypeNameFormat iftmp.194;
  struct MonoType * D.31934;
  struct MonoString * D.31937;
  unsigned char D.31940;
  _Bool D.31941;
  _Bool D.31942;
  _Bool D.31943;
  struct MonoDomain * domain;
  MonoTypeNameFormat format;
  struct MonoString * res;
  gchar * name;

  D.31926 = MEM[(struct MonoObject *)object].vtable;
  domain = D.31926->domain;
  if (full_name != 0) goto <D.31927>; else goto <D.31928>;
  <D.31927>:
  if (assembly_qualified != 0) goto <D.31930>; else goto <D.31931>;
  <D.31930>:
  iftmp.194 = 3;
  goto <D.31932>;
  <D.31931>:
  iftmp.194 = 2;
  <D.31932>:
  format = iftmp.194;
  goto <D.31933>;
  <D.31928>:
  format = 1;
  <D.31933>:
  D.31934 = object->type;
  name = mono_type_get_name_full (D.31934, format);
  if (name == 0B) goto <D.31935>; else goto <D.31936>;
  <D.31935>:
  D.31937 = 0B;
  return D.31937;
  <D.31936>:
  if (full_name != 0) goto <D.31938>; else goto <D.31939>;
  <D.31938>:
  D.31934 = object->type;
  D.31940 = D.31934->type;
  D.31941 = D.31940 == 19;
  D.31942 = D.31940 == 30;
  D.31943 = D.31941 | D.31942;
  if (D.31943 != 0) goto <D.31944>; else goto <D.31945>;
  <D.31944>:
  monoeg_g_free (name);
  D.31937 = 0B;
  return D.31937;
  <D.31945>:
  <D.31939>:
  res = mono_string_new (domain, name);
  monoeg_g_free (name);
  D.31937 = res;
  return D.31937;
}


ves_icall_type_isprimitive (struct MonoReflectionType * type)
{
  MonoBoolean D.31947;
  int iftmp.195;
  struct MonoType * D.31952;
  unsigned char D.31953;
  unsigned char D.31954;
  unsigned char D.31956;
  unsigned char D.31957;
  _Bool D.31958;
  _Bool D.31959;
  _Bool D.31960;
  unsigned char D.31962;

  D.31952 = type->type;
  D.31953 = BIT_FIELD_REF <*D.31952, 8, 56>;
  D.31954 = D.31953 & 64;
  if (D.31954 == 0) goto <D.31955>; else goto <D.31949>;
  <D.31955>:
  D.31952 = type->type;
  D.31956 = D.31952->type;
  D.31957 = D.31956 + 254;
  D.31958 = D.31957 <= 11;
  D.31959 = D.31956 == 24;
  D.31960 = D.31958 | D.31959;
  if (D.31960 != 0) goto <D.31950>; else goto <D.31961>;
  <D.31961>:
  D.31952 = type->type;
  D.31962 = D.31952->type;
  if (D.31962 == 25) goto <D.31950>; else goto <D.31949>;
  <D.31950>:
  iftmp.195 = 1;
  goto <D.31951>;
  <D.31949>:
  iftmp.195 = 0;
  <D.31951>:
  D.31947 = (MonoBoolean) iftmp.195;
  return D.31947;
}


ves_icall_type_ispointer (struct MonoReflectionType * type)
{
  MonoBoolean D.31964;
  struct MonoType * D.31965;
  unsigned char D.31966;
  _Bool D.31967;

  D.31965 = type->type;
  D.31966 = D.31965->type;
  D.31967 = D.31966 == 15;
  D.31964 = (MonoBoolean) D.31967;
  return D.31964;
}


ves_icall_type_iscomobject (struct MonoReflectionType * type)
{
  struct MonoType * D.31969;
  MonoBoolean D.31970;
  <unnamed-unsigned:1> D.31971;
  struct MonoClass * klass;

  D.31969 = type->type;
  klass = mono_class_from_mono_type (D.31969);
  mono_class_init_or_throw (klass);
  D.31971 = klass->is_com_object;
  D.31970 = (MonoBoolean) D.31971;
  return D.31970;
}


ves_icall_type_isbyref (struct MonoReflectionType * type)
{
  MonoBoolean D.31973;
  struct MonoType * D.31974;
  <unnamed-unsigned:1> D.31975;

  D.31974 = type->type;
  D.31975 = D.31974->byref;
  D.31973 = (MonoBoolean) D.31975;
  return D.31973;
}


ves_icall_MonoType_GetEvent (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags)
{
  struct MonoType * D.31977;
  unsigned char D.31978;
  unsigned char D.31979;
  struct MonoReflectionEvent * D.31982;
  struct MonoVTable * D.31983;
  int (*<T43a0>) (const char *, const char *) iftmp.196;
  unsigned int D.31985;
  unsigned char D.31989;
  struct MonoException * D.31992;
  const char * D.31993;
  int D.31994;
  short unsigned int D.32003;
  int D.32004;
  int D.32005;
  unsigned int D.32008;
  unsigned int D.32012;
  int D.32019;
  unsigned int D.32022;
  unsigned int D.32025;
  unsigned int D.32031;
  unsigned int D.32037;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoClass * startklass;
  void * iter;
  struct MonoEvent * event;
  struct MonoMethod * method;
  gchar * event_name;
  int (*<T43a0>) (const char *, const char *) compare_func;
  void handle_parent = <<< error >>>;

  try
    {
      event_name = mono_string_to_utf8 (name);
      D.31977 = type->type;
      D.31978 = BIT_FIELD_REF <*D.31977, 8, 56>;
      D.31979 = D.31978 & 64;
      if (D.31979 != 0) goto <D.31980>; else goto <D.31981>;
      <D.31980>:
      D.31982 = 0B;
      return D.31982;
      <D.31981>:
      D.31977 = type->type;
      startklass = mono_class_from_mono_type (D.31977);
      klass = startklass;
      D.31983 = MEM[(struct MonoObject *)type].vtable;
      domain = D.31983->domain;
      mono_class_init_or_throw (klass);
      D.31985 = bflags & 1;
      if (D.31985 != 0) goto <D.31986>; else goto <D.31987>;
      <D.31986>:
      iftmp.196 = monoeg_ascii_strcasecmp;
      goto <D.31988>;
      <D.31987>:
      iftmp.196 = strcmp;
      <D.31988>:
      compare_func = iftmp.196;
      handle_parent:
      D.31989 = klass->exception_type;
      if (D.31989 != 0) goto <D.31990>; else goto <D.31991>;
      <D.31990>:
      D.31992 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.31992);
      <D.31991>:
      iter = 0B;
      goto <D.24583>;
      <D.24584>:
      D.31993 = event->name;
      D.31994 = compare_func (D.31993, event_name);
      if (D.31994 != 0) goto <D.31995>; else goto <D.31996>;
      <D.31995>:
      // predicted unlikely by continue predictor.
      goto <D.24583>;
      <D.31996>:
      method = event->add;
      if (method == 0B) goto <D.31997>; else goto <D.31998>;
      <D.31997>:
      method = event->remove;
      <D.31998>:
      if (method == 0B) goto <D.31999>; else goto <D.32000>;
      <D.31999>:
      method = event->raise;
      <D.32000>:
      if (method != 0B) goto <D.32001>; else goto <D.32002>;
      <D.32001>:
      D.32003 = method->flags;
      D.32004 = (int) D.32003;
      D.32005 = D.32004 & 7;
      if (D.32005 == 6) goto <D.32006>; else goto <D.32007>;
      <D.32006>:
      D.32008 = bflags & 16;
      if (D.32008 == 0) goto <D.32009>; else goto <D.32010>;
      <D.32009>:
      // predicted unlikely by continue predictor.
      goto <D.24583>;
      <D.32010>:
      goto <D.32011>;
      <D.32007>:
      D.32012 = bflags & 32;
      if (D.32012 == 0) goto <D.32013>; else goto <D.32014>;
      <D.32013>:
      // predicted unlikely by continue predictor.
      goto <D.24583>;
      <D.32014>:
      if (klass != startklass) goto <D.32015>; else goto <D.32016>;
      <D.32015>:
      D.32003 = method->flags;
      D.32004 = (int) D.32003;
      D.32005 = D.32004 & 7;
      if (D.32005 == 1) goto <D.32017>; else goto <D.32018>;
      <D.32017>:
      // predicted unlikely by continue predictor.
      goto <D.24583>;
      <D.32018>:
      <D.32016>:
      <D.32011>:
      D.32003 = method->flags;
      D.32004 = (int) D.32003;
      D.32019 = D.32004 & 16;
      if (D.32019 != 0) goto <D.32020>; else goto <D.32021>;
      <D.32020>:
      D.32022 = bflags & 8;
      if (D.32022 == 0) goto <D.32023>; else goto <D.32024>;
      <D.32023>:
      // predicted unlikely by continue predictor.
      goto <D.24583>;
      <D.32024>:
      D.32025 = bflags & 64;
      if (D.32025 == 0) goto <D.32026>; else goto <D.32027>;
      <D.32026>:
      if (klass != startklass) goto <D.32028>; else goto <D.32029>;
      <D.32028>:
      // predicted unlikely by continue predictor.
      goto <D.24583>;
      <D.32029>:
      <D.32027>:
      goto <D.32030>;
      <D.32021>:
      D.32031 = bflags & 4;
      if (D.32031 == 0) goto <D.32032>; else goto <D.32033>;
      <D.32032>:
      // predicted unlikely by continue predictor.
      goto <D.24583>;
      <D.32033>:
      <D.32030>:
      goto <D.32034>;
      <D.32002>:
      D.32012 = bflags & 32;
      if (D.32012 == 0) goto <D.32035>; else goto <D.32036>;
      <D.32035>:
      // predicted unlikely by continue predictor.
      goto <D.24583>;
      <D.32036>:
      <D.32034>:
      monoeg_g_free (event_name);
      D.31982 = mono_event_get_object (domain, startklass, event);
      return D.31982;
      <D.24583>:
      event = mono_class_get_events (klass, &iter);
      if (event != 0B) goto <D.24584>; else goto <D.24585>;
      <D.24585>:
      D.32037 = bflags & 2;
      if (D.32037 == 0) goto <D.32038>; else goto <D.32039>;
      <D.32038>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.32040>;
      <D.32040>:
      <D.32039>:
      monoeg_g_free (event_name);
      D.31982 = 0B;
      return D.31982;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetPropertiesByName (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags, MonoBoolean ignore_case, struct MonoReflectionType * reftype)
{
  void * D.32043;
  struct MonoClass * System_Reflection_PropertyInfo.197;
  struct MonoImage * D.32047;
  struct MonoClass * System_Reflection_PropertyInfo.198;
  struct MonoVTable * D.32049;
  struct MonoType * D.32050;
  unsigned char D.32051;
  unsigned char D.32052;
  struct MonoArray * D.32055;
  struct MonoClass * D.24554;
  struct MonoClass * tmp_klass.199;
  struct MonoClass * tmp_klass.200;
  _Bool D.32060;
  long int D.32061;
  long int D.32062;
  struct MonoVTable * D.32065;
  int (*<T43a0>) (const char *, const char *) iftmp.201;
  unsigned char D.32072;
  struct MonoLoaderError * D.32074;
  short unsigned int D.32080;
  struct MonoMethod * D.32086;
  short unsigned int D.32088;
  int D.32089;
  int D.32090;
  struct MonoMethod * D.32091;
  short unsigned int D.32093;
  int D.32094;
  int D.32095;
  unsigned int D.32096;
  unsigned int D.32099;
  _Bool D.32104;
  int D.32105;
  int D.32106;
  int D.32108;
  unsigned int D.32111;
  unsigned int D.32114;
  unsigned int D.32119;
  unsigned int D.32122;
  const char * D.32129;
  int D.32130;
  void * D.32133;
  int D.32136;
  int D.32137;
  unsigned int D.32140;
  unsigned int D.32141;
  int D.32142;
  void * D.32143;
  void * * D.32144;
  unsigned int D.32145;
  int D.32148;
  int D.32149;
  unsigned int D.32150;
  unsigned int D.32151;
  void * * D.32152;
  struct MonoReflectionProperty * D.32153;
  unsigned int D.32154;
  struct MonoClass * D.24562;
  struct MonoClass * tmp_klass.202;
  struct MonoClass * tmp_klass.203;
  _Bool D.32162;
  long int D.32163;
  long int D.32164;
  struct MonoVTable * D.32167;
  unsigned int D.32168;
  unsigned int i.204;
  unsigned int i.205;
  unsigned int D.32171;
  void * * D.32172;
  void * D.32173;
  struct MonoLoaderError * D.32185;
  struct MonoException * ex;
  struct MonoDomain * domain;
  static struct MonoClass * System_Reflection_PropertyInfo;
  struct MonoClass * startklass;
  struct MonoClass * klass;
  struct MonoArray * res;
  struct MonoMethod * method;
  struct MonoProperty * prop;
  int i;
  int match;
  guint32 flags;
  gchar * propname;
  int (*<T43a0>) (const char *, const char *) compare_func;
  void * iter;
  struct GHashTable * properties;
  struct MonoPtrArray tmp_array;
  void handle_parent = <<< error >>>;
  void loader_error = <<< error >>>;

  try
    {
      propname = 0B;
      compare_func = 0B;
      properties = 0B;
      tmp_array.size = 0;
      tmp_array.capacity = 16;
      D.32043 = __builtin_alloca (64);
      tmp_array.data = D.32043;
      System_Reflection_PropertyInfo.197 = System_Reflection_PropertyInfo;
      if (System_Reflection_PropertyInfo.197 == 0B) goto <D.32045>; else goto <D.32046>;
      <D.32045>:
      D.32047 = mono_defaults.corlib;
      System_Reflection_PropertyInfo.198 = mono_class_from_name (D.32047, "System.Reflection", "PropertyInfo");
      System_Reflection_PropertyInfo = System_Reflection_PropertyInfo.198;
      <D.32046>:
      D.32049 = MEM[(struct MonoObject *)type].vtable;
      domain = D.32049->domain;
      D.32050 = type->type;
      D.32051 = BIT_FIELD_REF <*D.32050, 8, 56>;
      D.32052 = D.32051 & 64;
      if (D.32052 != 0) goto <D.32053>; else goto <D.32054>;
      <D.32053>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.199 = tmp_klass;
          if (tmp_klass.199 == 0B) goto <D.32057>; else goto <D.32058>;
          <D.32057>:
          System_Reflection_PropertyInfo.197 = System_Reflection_PropertyInfo;
          tmp_klass.200 = mono_array_class_get (System_Reflection_PropertyInfo.197, 1);
          tmp_klass = tmp_klass.200;
          tmp_klass.199 = tmp_klass;
          D.32060 = tmp_klass.199 == 0B;
          D.32061 = (long int) D.32060;
          D.32062 = __builtin_expect (D.32061, 0);
          if (D.32062 != 0) goto <D.32063>; else goto <D.32064>;
          <D.32063>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3725, "tmp_klass");
          <D.32064>:
          <D.32058>:
        }
        D.24554 = tmp_klass;
      }
      D.32065 = mono_class_vtable (domain, D.24554);
      D.32055 = mono_array_new_specific (D.32065, 0);
      return D.32055;
      <D.32054>:
      D.32050 = type->type;
      startklass = mono_class_from_mono_type (D.32050);
      klass = startklass;
      if (name != 0B) goto <D.32066>; else goto <D.32067>;
      <D.32066>:
      propname = mono_string_to_utf8 (name);
      if (ignore_case != 0) goto <D.32069>; else goto <D.32070>;
      <D.32069>:
      iftmp.201 = monoeg_ascii_strcasecmp;
      goto <D.32071>;
      <D.32070>:
      iftmp.201 = strcmp;
      <D.32071>:
      compare_func = iftmp.201;
      <D.32067>:
      properties = monoeg_g_hash_table_new (property_hash, property_equal);
      handle_parent:
      mono_class_setup_vtable (klass);
      D.32072 = klass->exception_type;
      if (D.32072 != 0) goto loader_error; else goto <D.32073>;
      <D.32073>:
      D.32074 = mono_loader_get_last_error ();
      if (D.32074 != 0B) goto loader_error; else goto <D.32075>;
      <D.32075>:
      iter = 0B;
      goto <D.24557>;
      <D.24559>:
      match = 0;
      method = prop->get;
      if (method == 0B) goto <D.32076>; else goto <D.32077>;
      <D.32076>:
      method = prop->set;
      <D.32077>:
      if (method != 0B) goto <D.32078>; else goto <D.32079>;
      <D.32078>:
      D.32080 = method->flags;
      flags = (guint32) D.32080;
      goto <D.32081>;
      <D.32079>:
      flags = 0;
      <D.32081>:
      D.32086 = prop->get;
      if (D.32086 != 0B) goto <D.32087>; else goto <D.32082>;
      <D.32087>:
      D.32086 = prop->get;
      D.32088 = D.32086->flags;
      D.32089 = (int) D.32088;
      D.32090 = D.32089 & 7;
      if (D.32090 == 6) goto <D.32083>; else goto <D.32082>;
      <D.32082>:
      D.32091 = prop->set;
      if (D.32091 != 0B) goto <D.32092>; else goto <D.32084>;
      <D.32092>:
      D.32091 = prop->set;
      D.32093 = D.32091->flags;
      D.32094 = (int) D.32093;
      D.32095 = D.32094 & 7;
      if (D.32095 == 6) goto <D.32083>; else goto <D.32084>;
      <D.32083>:
      D.32096 = bflags & 16;
      if (D.32096 != 0) goto <D.32097>; else goto <D.32098>;
      <D.32097>:
      match = match + 1;
      <D.32098>:
      goto <D.32085>;
      <D.32084>:
      D.32099 = bflags & 32;
      if (D.32099 != 0) goto <D.32100>; else goto <D.32101>;
      <D.32100>:
      D.32086 = prop->get;
      D.32104 = startklass == klass;
      D.32105 = (int) D.32104;
      D.32106 = property_accessor_nonpublic (D.32086, D.32105);
      if (D.32106 != 0) goto <D.32102>; else goto <D.32107>;
      <D.32107>:
      D.32091 = prop->set;
      D.32104 = startklass == klass;
      D.32105 = (int) D.32104;
      D.32108 = property_accessor_nonpublic (D.32091, D.32105);
      if (D.32108 != 0) goto <D.32102>; else goto <D.32103>;
      <D.32102>:
      match = match + 1;
      <D.32103>:
      <D.32101>:
      <D.32085>:
      if (match == 0) goto <D.32109>; else goto <D.32110>;
      <D.32109>:
      // predicted unlikely by continue predictor.
      goto <D.24557>;
      <D.32110>:
      match = 0;
      D.32111 = flags & 16;
      if (D.32111 != 0) goto <D.32112>; else goto <D.32113>;
      <D.32112>:
      D.32114 = bflags & 8;
      if (D.32114 != 0) goto <D.32115>; else goto <D.32116>;
      <D.32115>:
      D.32119 = bflags & 64;
      if (D.32119 != 0) goto <D.32117>; else goto <D.32120>;
      <D.32120>:
      if (klass == startklass) goto <D.32117>; else goto <D.32118>;
      <D.32117>:
      match = match + 1;
      <D.32118>:
      <D.32116>:
      goto <D.32121>;
      <D.32113>:
      D.32122 = bflags & 4;
      if (D.32122 != 0) goto <D.32123>; else goto <D.32124>;
      <D.32123>:
      match = match + 1;
      <D.32124>:
      <D.32121>:
      if (match == 0) goto <D.32125>; else goto <D.32126>;
      <D.32125>:
      // predicted unlikely by continue predictor.
      goto <D.24557>;
      <D.32126>:
      match = 0;
      if (name != 0B) goto <D.32127>; else goto <D.32128>;
      <D.32127>:
      D.32129 = prop->name;
      D.32130 = compare_func (propname, D.32129);
      if (D.32130 != 0) goto <D.32131>; else goto <D.32132>;
      <D.32131>:
      // predicted unlikely by continue predictor.
      goto <D.24557>;
      <D.32132>:
      <D.32128>:
      D.32133 = monoeg_g_hash_table_lookup (properties, prop);
      if (D.32133 != 0B) goto <D.32134>; else goto <D.32135>;
      <D.32134>:
      // predicted unlikely by continue predictor.
      goto <D.24557>;
      <D.32135>:
      D.32136 = tmp_array.size;
      D.32137 = tmp_array.capacity;
      if (D.32136 >= D.32137) goto <D.32138>; else goto <D.32139>;
      <D.32138>:
      {
        void * __tmp;

        D.32137 = tmp_array.capacity;
        D.32140 = (unsigned int) D.32137;
        D.32141 = D.32140 * 8;
        D.32137 = tmp_array.capacity;
        D.32142 = D.32137 * 2;
        D.32143 = mono_gc_make_root_descr_all_refs (D.32142);
        __tmp = mono_gc_alloc_fixed (D.32141, D.32143);
        D.32144 = tmp_array.data;
        D.32137 = tmp_array.capacity;
        D.32140 = (unsigned int) D.32137;
        D.32145 = D.32140 * 4;
        mono_gc_memmove_aligned (__tmp, D.32144, D.32145);
        D.32137 = tmp_array.capacity;
        if (D.32137 > 16) goto <D.32146>; else goto <D.32147>;
        <D.32146>:
        D.32144 = tmp_array.data;
        mono_gc_free_fixed (D.32144);
        <D.32147>:
        tmp_array.data = __tmp;
        D.32137 = tmp_array.capacity;
        D.32142 = D.32137 * 2;
        tmp_array.capacity = D.32142;
      }
      <D.32139>:
      D.32144 = tmp_array.data;
      D.32136 = tmp_array.size;
      D.32148 = D.32136;
      D.32149 = D.32148 + 1;
      tmp_array.size = D.32149;
      D.32150 = (unsigned int) D.32148;
      D.32151 = D.32150 * 4;
      D.32152 = D.32144 + D.32151;
      D.32153 = mono_property_get_object (domain, startklass, prop);
      *D.32152 = D.32153;
      monoeg_g_hash_table_insert_replace (properties, prop, prop, 0);
      <D.24557>:
      prop = mono_class_get_properties (klass, &iter);
      if (prop != 0B) goto <D.24559>; else goto <D.24560>;
      <D.24560>:
      D.32154 = bflags & 2;
      if (D.32154 == 0) goto <D.32155>; else goto <D.32156>;
      <D.32155>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.32157>;
      <D.32157>:
      <D.32156>:
      monoeg_g_hash_table_destroy (properties);
      monoeg_g_free (propname);
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.202 = tmp_klass;
          if (tmp_klass.202 == 0B) goto <D.32159>; else goto <D.32160>;
          <D.32159>:
          System_Reflection_PropertyInfo.197 = System_Reflection_PropertyInfo;
          tmp_klass.203 = mono_array_class_get (System_Reflection_PropertyInfo.197, 1);
          tmp_klass = tmp_klass.203;
          tmp_klass.202 = tmp_klass;
          D.32162 = tmp_klass.202 == 0B;
          D.32163 = (long int) D.32162;
          D.32164 = __builtin_expect (D.32163, 0);
          if (D.32164 != 0) goto <D.32165>; else goto <D.32166>;
          <D.32165>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3793, "tmp_klass");
          <D.32166>:
          <D.32160>:
        }
        D.24562 = tmp_klass;
      }
      D.32167 = mono_class_vtable (domain, D.24562);
      D.32136 = tmp_array.size;
      D.32168 = (unsigned int) D.32136;
      res = mono_array_new_specific (D.32167, D.32168);
      i = 0;
      goto <D.24565>;
      <D.24564>:
      {
        void * * __p;

        i.204 = (unsigned int) i;
        __p = mono_array_addr_with_size (res, 4, i.204);
        D.32144 = tmp_array.data;
        i.205 = (unsigned int) i;
        D.32171 = i.205 * 4;
        D.32172 = D.32144 + D.32171;
        D.32173 = *D.32172;
        mono_gc_wbarrier_set_arrayref (res, __p, D.32173);
      }
      i = i + 1;
      <D.24565>:
      D.32136 = tmp_array.size;
      if (D.32136 > i) goto <D.24564>; else goto <D.24566>;
      <D.24566>:
      D.32137 = tmp_array.capacity;
      if (D.32137 > 16) goto <D.32174>; else goto <D.32175>;
      <D.32174>:
      D.32144 = tmp_array.data;
      mono_gc_free_fixed (D.32144);
      <D.32175>:
      D.32055 = res;
      return D.32055;
      loader_error:
      if (properties != 0B) goto <D.32176>; else goto <D.32177>;
      <D.32176>:
      monoeg_g_hash_table_destroy (properties);
      <D.32177>:
      if (name != 0B) goto <D.32178>; else goto <D.32179>;
      <D.32178>:
      monoeg_g_free (propname);
      <D.32179>:
      D.32137 = tmp_array.capacity;
      if (D.32137 > 16) goto <D.32180>; else goto <D.32181>;
      <D.32180>:
      D.32144 = tmp_array.data;
      mono_gc_free_fixed (D.32144);
      <D.32181>:
      D.32072 = klass->exception_type;
      if (D.32072 != 0) goto <D.32182>; else goto <D.32183>;
      <D.32182>:
      ex = mono_class_get_exception_for_failure (klass);
      goto <D.32184>;
      <D.32183>:
      D.32185 = mono_loader_get_last_error ();
      ex = mono_loader_error_prepare_exception (D.32185);
      mono_loader_clear_error ();
      <D.32184>:
      mono_raise_exception (ex);
      D.32055 = 0B;
      return D.32055;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


property_equal (struct MonoProperty * prop1, struct MonoProperty * prop2)
{
  const char * D.32188;
  const char * D.32189;
  int D.32190;
  gboolean D.32193;
  struct MonoMethod * D.32194;
  struct MonoMethod * D.32197;
  struct MonoMethodSignature * D.32200;
  struct MonoMethodSignature * D.32201;
  int D.32202;
  struct MonoMethod * D.32205;
  struct MonoMethod * D.32208;
  struct MonoMethodSignature * D.32211;
  struct MonoMethodSignature * D.32212;
  int D.32213;

  D.32188 = prop1->name;
  D.32189 = prop2->name;
  D.32190 = monoeg_g_str_equal (D.32188, D.32189);
  if (D.32190 == 0) goto <D.32191>; else goto <D.32192>;
  <D.32191>:
  D.32193 = 0;
  return D.32193;
  <D.32192>:
  D.32194 = prop1->get;
  if (D.32194 != 0B) goto <D.32195>; else goto <D.32196>;
  <D.32195>:
  D.32197 = prop2->get;
  if (D.32197 != 0B) goto <D.32198>; else goto <D.32199>;
  <D.32198>:
  D.32194 = prop1->get;
  D.32200 = mono_method_signature (D.32194);
  D.32197 = prop2->get;
  D.32201 = mono_method_signature (D.32197);
  D.32202 = mono_metadata_signature_equal (D.32200, D.32201);
  if (D.32202 == 0) goto <D.32203>; else goto <D.32204>;
  <D.32203>:
  D.32193 = 0;
  return D.32193;
  <D.32204>:
  <D.32199>:
  <D.32196>:
  D.32205 = prop1->set;
  if (D.32205 != 0B) goto <D.32206>; else goto <D.32207>;
  <D.32206>:
  D.32208 = prop2->set;
  if (D.32208 != 0B) goto <D.32209>; else goto <D.32210>;
  <D.32209>:
  D.32205 = prop1->set;
  D.32211 = mono_method_signature (D.32205);
  D.32208 = prop2->set;
  D.32212 = mono_method_signature (D.32208);
  D.32213 = mono_metadata_signature_equal (D.32211, D.32212);
  if (D.32213 == 0) goto <D.32214>; else goto <D.32215>;
  <D.32214>:
  D.32193 = 0;
  return D.32193;
  <D.32215>:
  <D.32210>:
  <D.32207>:
  D.32193 = 1;
  return D.32193;
}


property_hash (const void * data)
{
  guint D.32217;
  const char * D.32218;
  struct MonoProperty * prop;

  prop = data;
  D.32218 = prop->name;
  D.32217 = monoeg_g_str_hash (D.32218);
  return D.32217;
}


property_accessor_nonpublic (struct MonoMethod * accessor, gboolean start_klass)
{
  gboolean D.32222;

  if (accessor == 0B) goto <D.32220>; else goto <D.32221>;
  <D.32220>:
  D.32222 = 0;
  return D.32222;
  <D.32221>:
  D.32222 = method_nonpublic (accessor, start_klass);
  return D.32222;
}


ves_icall_Type_GetNestedTypes (struct MonoReflectionType * type, guint32 bflags)
{
  struct MonoVTable * D.32224;
  struct MonoType * D.32225;
  unsigned char D.32226;
  unsigned char D.32227;
  struct MonoArray * D.32230;
  struct MonoClass * D.32231;
  struct MonoGenericClass * D.32232;
  void * D.32235;
  unsigned int D.32236;
  unsigned int D.32237;
  unsigned int D.32240;
  unsigned int D.32244;
  struct MonoType * D.32249;
  int D.32250;
  int D.32251;
  unsigned int D.32254;
  unsigned int D.32255;
  int D.32256;
  void * D.32257;
  void * * D.32258;
  unsigned int D.32259;
  int D.32262;
  int D.32263;
  unsigned int D.32264;
  unsigned int D.32265;
  void * * D.32266;
  struct MonoClass * D.24659;
  struct MonoClass * tmp_klass.206;
  struct MonoClass * tmp_klass.207;
  _Bool D.32271;
  long int D.32272;
  long int D.32273;
  struct MonoVTable * D.32276;
  unsigned int D.32277;
  unsigned int i.208;
  unsigned int i.209;
  unsigned int D.32280;
  void * * D.32281;
  void * D.32282;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoArray * res;
  struct MonoObject * member;
  int i;
  int match;
  struct MonoClass * nested;
  void * iter;
  struct MonoPtrArray tmp_array;

  try
    {
      D.32224 = MEM[(struct MonoObject *)type].vtable;
      domain = D.32224->domain;
      D.32225 = type->type;
      D.32226 = BIT_FIELD_REF <*D.32225, 8, 56>;
      D.32227 = D.32226 & 64;
      if (D.32227 != 0) goto <D.32228>; else goto <D.32229>;
      <D.32228>:
      D.32231 = mono_defaults.monotype_class;
      D.32230 = mono_array_new (domain, D.32231, 0);
      return D.32230;
      <D.32229>:
      D.32225 = type->type;
      klass = mono_class_from_mono_type (D.32225);
      D.32232 = klass->generic_class;
      if (D.32232 != 0B) goto <D.32233>; else goto <D.32234>;
      <D.32233>:
      D.32232 = klass->generic_class;
      klass = D.32232->container_class;
      <D.32234>:
      tmp_array.size = 0;
      tmp_array.capacity = 16;
      D.32235 = __builtin_alloca (64);
      tmp_array.data = D.32235;
      iter = 0B;
      goto <D.24654>;
      <D.24656>:
      match = 0;
      D.32236 = nested->flags;
      D.32237 = D.32236 & 7;
      if (D.32237 == 2) goto <D.32238>; else goto <D.32239>;
      <D.32238>:
      D.32240 = bflags & 16;
      if (D.32240 != 0) goto <D.32241>; else goto <D.32242>;
      <D.32241>:
      match = match + 1;
      <D.32242>:
      goto <D.32243>;
      <D.32239>:
      D.32244 = bflags & 32;
      if (D.32244 != 0) goto <D.32245>; else goto <D.32246>;
      <D.32245>:
      match = match + 1;
      <D.32246>:
      <D.32243>:
      if (match == 0) goto <D.32247>; else goto <D.32248>;
      <D.32247>:
      // predicted unlikely by continue predictor.
      goto <D.24654>;
      <D.32248>:
      D.32249 = &nested->byval_arg;
      member = mono_type_get_object (domain, D.32249);
      D.32250 = tmp_array.size;
      D.32251 = tmp_array.capacity;
      if (D.32250 >= D.32251) goto <D.32252>; else goto <D.32253>;
      <D.32252>:
      {
        void * __tmp;

        D.32251 = tmp_array.capacity;
        D.32254 = (unsigned int) D.32251;
        D.32255 = D.32254 * 8;
        D.32251 = tmp_array.capacity;
        D.32256 = D.32251 * 2;
        D.32257 = mono_gc_make_root_descr_all_refs (D.32256);
        __tmp = mono_gc_alloc_fixed (D.32255, D.32257);
        D.32258 = tmp_array.data;
        D.32251 = tmp_array.capacity;
        D.32254 = (unsigned int) D.32251;
        D.32259 = D.32254 * 4;
        mono_gc_memmove_aligned (__tmp, D.32258, D.32259);
        D.32251 = tmp_array.capacity;
        if (D.32251 > 16) goto <D.32260>; else goto <D.32261>;
        <D.32260>:
        D.32258 = tmp_array.data;
        mono_gc_free_fixed (D.32258);
        <D.32261>:
        tmp_array.data = __tmp;
        D.32251 = tmp_array.capacity;
        D.32256 = D.32251 * 2;
        tmp_array.capacity = D.32256;
      }
      <D.32253>:
      D.32258 = tmp_array.data;
      D.32250 = tmp_array.size;
      D.32262 = D.32250;
      D.32263 = D.32262 + 1;
      tmp_array.size = D.32263;
      D.32264 = (unsigned int) D.32262;
      D.32265 = D.32264 * 4;
      D.32266 = D.32258 + D.32265;
      *D.32266 = member;
      <D.24654>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.24656>; else goto <D.24657>;
      <D.24657>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.206 = tmp_klass;
          if (tmp_klass.206 == 0B) goto <D.32268>; else goto <D.32269>;
          <D.32268>:
          D.32231 = mono_defaults.monotype_class;
          tmp_klass.207 = mono_array_class_get (D.32231, 1);
          tmp_klass = tmp_klass.207;
          tmp_klass.206 = tmp_klass;
          D.32271 = tmp_klass.206 == 0B;
          D.32272 = (long int) D.32271;
          D.32273 = __builtin_expect (D.32272, 0);
          if (D.32273 != 0) goto <D.32274>; else goto <D.32275>;
          <D.32274>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4094, "tmp_klass");
          <D.32275>:
          <D.32269>:
        }
        D.24659 = tmp_klass;
      }
      D.32276 = mono_class_vtable (domain, D.24659);
      D.32250 = tmp_array.size;
      D.32277 = (unsigned int) D.32250;
      res = mono_array_new_specific (D.32276, D.32277);
      i = 0;
      goto <D.24662>;
      <D.24661>:
      {
        void * * __p;

        i.208 = (unsigned int) i;
        __p = mono_array_addr_with_size (res, 4, i.208);
        D.32258 = tmp_array.data;
        i.209 = (unsigned int) i;
        D.32280 = i.209 * 4;
        D.32281 = D.32258 + D.32280;
        D.32282 = *D.32281;
        mono_gc_wbarrier_set_arrayref (res, __p, D.32282);
      }
      i = i + 1;
      <D.24662>:
      D.32250 = tmp_array.size;
      if (D.32250 > i) goto <D.24661>; else goto <D.24663>;
      <D.24663>:
      D.32251 = tmp_array.capacity;
      if (D.32251 > 16) goto <D.32283>; else goto <D.32284>;
      <D.32283>:
      D.32258 = tmp_array.data;
      mono_gc_free_fixed (D.32258);
      <D.32284>:
      D.32230 = res;
      return D.32230;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_Type_GetNestedType (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags)
{
  struct MonoException * D.32289;
  struct MonoVTable * D.32290;
  struct MonoType * D.32291;
  unsigned char D.32292;
  unsigned char D.32293;
  struct MonoReflectionType * D.32296;
  unsigned char D.32297;
  struct MonoException * D.32300;
  struct MonoGenericClass * D.32301;
  unsigned int D.32304;
  unsigned int D.32305;
  unsigned int D.32308;
  unsigned int D.32312;
  int D.24638;
  const char * D.32317;
  struct MonoType * D.32320;
  unsigned int D.32321;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoClass * nested;
  char * str;
  void * iter;
  void handle_parent = <<< error >>>;

  try
    {
      if (name == 0B) goto <D.32287>; else goto <D.32288>;
      <D.32287>:
      D.32289 = mono_get_exception_argument_null ("name");
      mono_raise_exception (D.32289);
      <D.32288>:
      D.32290 = MEM[(struct MonoObject *)type].vtable;
      domain = D.32290->domain;
      D.32291 = type->type;
      D.32292 = BIT_FIELD_REF <*D.32291, 8, 56>;
      D.32293 = D.32292 & 64;
      if (D.32293 != 0) goto <D.32294>; else goto <D.32295>;
      <D.32294>:
      D.32296 = 0B;
      return D.32296;
      <D.32295>:
      D.32291 = type->type;
      klass = mono_class_from_mono_type (D.32291);
      str = mono_string_to_utf8 (name);
      handle_parent:
      D.32297 = klass->exception_type;
      if (D.32297 != 0) goto <D.32298>; else goto <D.32299>;
      <D.32298>:
      D.32300 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.32300);
      <D.32299>:
      D.32301 = klass->generic_class;
      if (D.32301 != 0B) goto <D.32302>; else goto <D.32303>;
      <D.32302>:
      D.32301 = klass->generic_class;
      klass = D.32301->container_class;
      <D.32303>:
      iter = 0B;
      goto <D.24629>;
      <D.24639>:
      {
        int match;

        match = 0;
        D.32304 = nested->flags;
        D.32305 = D.32304 & 7;
        if (D.32305 == 2) goto <D.32306>; else goto <D.32307>;
        <D.32306>:
        D.32308 = bflags & 16;
        if (D.32308 != 0) goto <D.32309>; else goto <D.32310>;
        <D.32309>:
        match = match + 1;
        <D.32310>:
        goto <D.32311>;
        <D.32307>:
        D.32312 = bflags & 32;
        if (D.32312 != 0) goto <D.32313>; else goto <D.32314>;
        <D.32313>:
        match = match + 1;
        <D.32314>:
        <D.32311>:
        if (match == 0) goto <D.32315>; else goto <D.32316>;
        <D.32315>:
        // predicted unlikely by continue predictor.
        goto <D.24629>;
        <D.32316>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.32317 = nested->name;
          D.24638 = __builtin_strcmp (D.32317, str);
        }
        if (D.24638 == 0) goto <D.32318>; else goto <D.32319>;
        <D.32318>:
        monoeg_g_free (str);
        D.32320 = &nested->byval_arg;
        D.32296 = mono_type_get_object (domain, D.32320);
        return D.32296;
        <D.32319>:
      }
      <D.24629>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.24639>; else goto <D.24640>;
      <D.24640>:
      D.32321 = bflags & 2;
      if (D.32321 == 0) goto <D.32322>; else goto <D.32323>;
      <D.32322>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.32324>;
      <D.32324>:
      <D.32323>:
      monoeg_g_free (str);
      D.32296 = 0B;
      return D.32296;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetMethodsByName (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags, MonoBoolean ignore_case, struct MonoReflectionType * reftype)
{
  struct MonoClass * MethodInfo_array.210;
  struct MonoClass * D.32330;
  struct MonoType * D.32331;
  struct MonoType * D.32332;
  struct MonoVTable * D.32333;
  unsigned char D.32334;
  unsigned char D.32335;
  struct MonoArray * D.32338;
  int D.32341;
  struct MonoException * ex.211;
  unsigned int D.32345;
  void * * D.32346;
  unsigned int i.212;
  unsigned int D.32348;
  void * * D.32349;
  unsigned int i.213;
  struct MonoReflectionMethod * D.32351;
  unsigned int i.214;
  static struct MonoClass * MethodInfo_array;
  struct MonoDomain * domain;
  struct MonoArray * res;
  struct MonoVTable * array_vtable;
  struct MonoException * ex;
  const char * mname;
  struct GPtrArray * method_array;
  struct MonoClass * klass;
  struct MonoClass * refklass;
  int i;

  try
    {
      ex = 0B;
      mname = 0B;
      MethodInfo_array.210 = MethodInfo_array;
      if (MethodInfo_array.210 == 0B) goto <D.32328>; else goto <D.32329>;
      <D.32328>:
      {
        struct MonoClass * klass;

        D.32330 = mono_defaults.method_info_class;
        klass = mono_array_class_get (D.32330, 1);
        mono_memory_barrier ();
        MethodInfo_array = klass;
      }
      <D.32329>:
      D.32331 = type->type;
      klass = mono_class_from_mono_type (D.32331);
      D.32332 = reftype->type;
      refklass = mono_class_from_mono_type (D.32332);
      D.32333 = MEM[(struct MonoObject *)type].vtable;
      domain = D.32333->domain;
      MethodInfo_array.210 = MethodInfo_array;
      array_vtable = mono_class_vtable_full (domain, MethodInfo_array.210, 1);
      D.32331 = type->type;
      D.32334 = BIT_FIELD_REF <*D.32331, 8, 56>;
      D.32335 = D.32334 & 64;
      if (D.32335 != 0) goto <D.32336>; else goto <D.32337>;
      <D.32336>:
      D.32338 = mono_array_new_specific (array_vtable, 0);
      return D.32338;
      <D.32337>:
      if (name != 0B) goto <D.32339>; else goto <D.32340>;
      <D.32339>:
      mname = mono_string_to_utf8 (name);
      <D.32340>:
      D.32341 = (int) ignore_case;
      method_array = mono_class_get_methods_by_name (klass, mname, bflags, D.32341, 0, &ex);
      monoeg_g_free (mname);
      ex.211 = ex;
      if (ex.211 != 0B) goto <D.32343>; else goto <D.32344>;
      <D.32343>:
      ex.211 = ex;
      mono_raise_exception (ex.211);
      <D.32344>:
      D.32345 = method_array->len;
      res = mono_array_new_specific (array_vtable, D.32345);
      i = 0;
      goto <D.24467>;
      <D.24466>:
      {
        struct MonoMethod * method;

        D.32346 = method_array->pdata;
        i.212 = (unsigned int) i;
        D.32348 = i.212 * 4;
        D.32349 = D.32346 + D.32348;
        method = *D.32349;
        {
          void * * __p;

          i.213 = (unsigned int) i;
          __p = mono_array_addr_with_size (res, 4, i.213);
          D.32351 = mono_method_get_object (domain, method, refklass);
          mono_gc_wbarrier_set_arrayref (res, __p, D.32351);
        }
      }
      i = i + 1;
      <D.24467>:
      i.214 = (unsigned int) i;
      D.32345 = method_array->len;
      if (i.214 < D.32345) goto <D.24466>; else goto <D.24468>;
      <D.24468>:
      monoeg_g_ptr_array_free (method_array, 1);
      D.32338 = res;
      return D.32338;
    }
  finally
    {
      ex = {CLOBBER};
    }
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


ves_icall_Type_GetInterfaces (struct MonoReflectionType * type)
{
  struct MonoType * D.32355;
  struct MonoGenericClass * D.32356;
  struct MonoGenericInst * D.32359;
  unsigned char D.32360;
  unsigned char D.32361;
  struct MonoGenericContext * D.32364;
  int D.32365;
  int D.32367;
  struct MonoVTable * D.32369;
  struct MonoDomain * D.32370;
  unsigned int D.32371;
  struct MonoDomain * D.32374;
  struct MonoArray * D.32375;
  struct MonoClass * D.23792;
  struct MonoClass * tmp_klass.215;
  struct MonoClass * D.32381;
  struct MonoClass * tmp_klass.216;
  _Bool D.32383;
  long int D.32384;
  long int D.32385;
  struct MonoVTable * D.32388;
  struct MonoArray * D.32389;
  struct MonoArray * D.32390;
  struct MonoClass * D.23794;
  struct MonoClass * tmp_klass.217;
  struct MonoClass * tmp_klass.218;
  _Bool D.32395;
  long int D.32396;
  long int D.32397;
  struct MonoVTable * D.32400;
  unsigned int len.219;
  struct MonoArray * D.32402;
  int D.32403;
  struct MonoError error;
  struct MonoClass * class;
  struct MonoClass * parent;
  struct FillIfaceArrayData data;
  int len;
  struct GHashTable * iface_hash;
  void fail = <<< error >>>;

  try
    {
      D.32355 = type->type;
      class = mono_class_from_mono_type (D.32355);
      data = {};
      iface_hash = monoeg_g_hash_table_new (0B, 0B);
      D.32356 = class->generic_class;
      if (D.32356 != 0B) goto <D.32357>; else goto <D.32358>;
      <D.32357>:
      D.32356 = class->generic_class;
      D.32359 = D.32356->context.class_inst;
      D.32360 = BIT_FIELD_REF <*D.32359, 8, 48>;
      D.32361 = D.32360 & 64;
      if (D.32361 != 0) goto <D.32362>; else goto <D.32363>;
      <D.32362>:
      D.32364 = mono_class_get_context (class);
      data.context = D.32364;
      D.32356 = class->generic_class;
      class = D.32356->container_class;
      <D.32363>:
      <D.32358>:
      parent = class;
      goto <D.23789>;
      <D.23788>:
      mono_class_setup_interfaces (parent, &error);
      D.32365 = mono_error_ok (&error);
      if (D.32365 == 0) goto fail; else goto <D.32366>;
      <D.32366>:
      collect_interfaces (parent, iface_hash, &error);
      D.32367 = mono_error_ok (&error);
      if (D.32367 == 0) goto fail; else goto <D.32368>;
      <D.32368>:
      parent = parent->parent;
      <D.23789>:
      if (parent != 0B) goto <D.23788>; else goto <D.23790>;
      <D.23790>:
      data.error = &error;
      D.32369 = MEM[(struct MonoObject *)type].vtable;
      D.32370 = D.32369->domain;
      data.domain = D.32370;
      D.32371 = monoeg_g_hash_table_size (iface_hash);
      len = (int) D.32371;
      if (len == 0) goto <D.32372>; else goto <D.32373>;
      <D.32372>:
      monoeg_g_hash_table_destroy (iface_hash);
      D.32374 = data.domain;
      D.32375 = D.32374->empty_types;
      if (D.32375 == 0B) goto <D.32376>; else goto <D.32377>;
      <D.32376>:
      D.32374 = data.domain;
      D.32374 = data.domain;
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.215 = tmp_klass;
          if (tmp_klass.215 == 0B) goto <D.32379>; else goto <D.32380>;
          <D.32379>:
          D.32381 = mono_defaults.monotype_class;
          tmp_klass.216 = mono_array_class_get (D.32381, 1);
          tmp_klass = tmp_klass.216;
          tmp_klass.215 = tmp_klass;
          D.32383 = tmp_klass.215 == 0B;
          D.32384 = (long int) D.32383;
          D.32385 = __builtin_expect (D.32384, 0);
          if (D.32385 != 0) goto <D.32386>; else goto <D.32387>;
          <D.32386>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2107, "tmp_klass");
          <D.32387>:
          <D.32380>:
        }
        D.23792 = tmp_klass;
      }
      D.32388 = mono_class_vtable (D.32374, D.23792);
      D.32389 = mono_array_new_specific (D.32388, 0);
      D.32374->empty_types = D.32389;
      <D.32377>:
      D.32374 = data.domain;
      D.32390 = D.32374->empty_types;
      return D.32390;
      <D.32373>:
      D.32374 = data.domain;
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.217 = tmp_klass;
          if (tmp_klass.217 == 0B) goto <D.32392>; else goto <D.32393>;
          <D.32392>:
          D.32381 = mono_defaults.monotype_class;
          tmp_klass.218 = mono_array_class_get (D.32381, 1);
          tmp_klass = tmp_klass.218;
          tmp_klass.217 = tmp_klass;
          D.32395 = tmp_klass.217 == 0B;
          D.32396 = (long int) D.32395;
          D.32397 = __builtin_expect (D.32396, 0);
          if (D.32397 != 0) goto <D.32398>; else goto <D.32399>;
          <D.32398>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2111, "tmp_klass");
          <D.32399>:
          <D.32393>:
        }
        D.23794 = tmp_klass;
      }
      D.32400 = mono_class_vtable (D.32374, D.23794);
      len.219 = (unsigned int) len;
      D.32402 = mono_array_new_specific (D.32400, len.219);
      data.iface_array = D.32402;
      monoeg_g_hash_table_foreach (iface_hash, fill_iface_array, &data);
      D.32403 = mono_error_ok (&error);
      if (D.32403 == 0) goto fail; else goto <D.32404>;
      <D.32404>:
      monoeg_g_hash_table_destroy (iface_hash);
      D.32390 = data.iface_array;
      return D.32390;
      fail:
      monoeg_g_hash_table_destroy (iface_hash);
      mono_error_raise_exception (&error);
      D.32390 = 0B;
      return D.32390;
    }
  finally
    {
      error = {CLOBBER};
      data = {CLOBBER};
    }
}


fill_iface_array (void * key, void * value, void * user_data)
{
  struct MonoError * D.32407;
  int D.32408;
  struct MonoGenericContext * D.32411;
  struct MonoGenericClass * D.32414;
  struct MonoGenericInst * D.32417;
  unsigned char D.32418;
  unsigned char D.32419;
  int D.32422;
  struct MonoArray * D.32425;
  int D.32426;
  int D.32427;
  int D.32428;
  unsigned int D.32429;
  struct MonoDomain * D.32430;
  struct MonoReflectionType * D.32431;
  struct FillIfaceArrayData * data;
  struct MonoClass * ic;
  struct MonoType * ret;
  struct MonoType * inflated;

  data = user_data;
  ic = key;
  ret = &ic->byval_arg;
  inflated = 0B;
  D.32407 = data->error;
  D.32408 = mono_error_ok (D.32407);
  if (D.32408 == 0) goto <D.32409>; else goto <D.32410>;
  <D.32409>:
  return;
  <D.32410>:
  D.32411 = data->context;
  if (D.32411 != 0B) goto <D.32412>; else goto <D.32413>;
  <D.32412>:
  D.32414 = ic->generic_class;
  if (D.32414 != 0B) goto <D.32415>; else goto <D.32416>;
  <D.32415>:
  D.32414 = ic->generic_class;
  D.32417 = D.32414->context.class_inst;
  D.32418 = BIT_FIELD_REF <*D.32417, 8, 48>;
  D.32419 = D.32418 & 64;
  if (D.32419 != 0) goto <D.32420>; else goto <D.32421>;
  <D.32420>:
  D.32411 = data->context;
  D.32407 = data->error;
  ret = mono_class_inflate_generic_type_checked (ret, D.32411, D.32407);
  inflated = ret;
  D.32407 = data->error;
  D.32422 = mono_error_ok (D.32407);
  if (D.32422 == 0) goto <D.32423>; else goto <D.32424>;
  <D.32423>:
  return;
  <D.32424>:
  <D.32421>:
  <D.32416>:
  <D.32413>:
  {
    void * * __p;

    D.32425 = data->iface_array;
    D.32426 = data->next_idx;
    D.32427 = D.32426;
    D.32428 = D.32427 + 1;
    data->next_idx = D.32428;
    D.32429 = (unsigned int) D.32427;
    __p = mono_array_addr_with_size (D.32425, 4, D.32429);
    D.32425 = data->iface_array;
    D.32430 = data->domain;
    D.32431 = mono_type_get_object (D.32430, ret);
    mono_gc_wbarrier_set_arrayref (D.32425, __p, D.32431);
  }
  if (inflated != 0B) goto <D.32432>; else goto <D.32433>;
  <D.32432>:
  mono_metadata_free_type (inflated);
  <D.32433>:
}


collect_interfaces (struct MonoClass * klass, struct GHashTable * ifaces, struct MonoError * error)
{
  int D.32435;
  struct MonoClass * * D.32438;
  unsigned int i.220;
  unsigned int D.32440;
  struct MonoClass * * D.32441;
  int D.32442;
  short unsigned int D.32445;
  int D.32446;
  int i;
  struct MonoClass * ic;

  mono_class_setup_interfaces (klass, error);
  D.32435 = mono_error_ok (error);
  if (D.32435 == 0) goto <D.32436>; else goto <D.32437>;
  <D.32436>:
  return;
  <D.32437>:
  i = 0;
  goto <D.23759>;
  <D.23758>:
  D.32438 = klass->interfaces;
  i.220 = (unsigned int) i;
  D.32440 = i.220 * 4;
  D.32441 = D.32438 + D.32440;
  ic = *D.32441;
  monoeg_g_hash_table_insert_replace (ifaces, ic, ic, 0);
  collect_interfaces (ic, ifaces, error);
  D.32442 = mono_error_ok (error);
  if (D.32442 == 0) goto <D.32443>; else goto <D.32444>;
  <D.32443>:
  return;
  <D.32444>:
  i = i + 1;
  <D.23759>:
  D.32445 = klass->interface_count;
  D.32446 = (int) D.32445;
  if (D.32446 > i) goto <D.23758>; else goto <D.23760>;
  <D.23760>:
}


ves_icall_MonoType_GetGenericArguments (struct MonoReflectionType * type)
{
  struct MonoVTable * D.32448;
  struct MonoClass * D.23886;
  struct MonoClass * tmp_klass.221;
  struct MonoClass * D.32452;
  struct MonoClass * tmp_klass.222;
  _Bool D.32454;
  long int D.32455;
  long int D.32456;
  struct MonoType * D.32459;
  struct MonoGenericContainer * D.32460;
  <unnamed-signed:31> D.32463;
  unsigned int D.32464;
  struct MonoGenericParamFull * D.32465;
  unsigned int i.223;
  unsigned int D.32467;
  struct MonoGenericParam * D.32468;
  struct MonoImage * D.32469;
  unsigned int i.224;
  struct MonoType * D.32471;
  struct MonoReflectionType * D.32472;
  int D.32473;
  struct MonoGenericClass * D.32475;
  <unnamed-unsigned:22> D.32478;
  unsigned int D.32479;
  struct MonoType * D.32480;
  struct MonoReflectionType * D.32481;
  int D.32482;
  struct MonoArray * D.32484;
  struct MonoArray * res;
  struct MonoClass * klass;
  struct MonoClass * pklass;
  struct MonoDomain * domain;
  struct MonoVTable * array_vtable;
  int i;

  D.32448 = MEM[(struct MonoObject *)type].vtable;
  domain = D.32448->domain;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.221 = tmp_klass;
      if (tmp_klass.221 == 0B) goto <D.32450>; else goto <D.32451>;
      <D.32450>:
      D.32452 = mono_defaults.systemtype_class;
      tmp_klass.222 = mono_array_class_get (D.32452, 1);
      tmp_klass = tmp_klass.222;
      tmp_klass.221 = tmp_klass;
      D.32454 = tmp_klass.221 == 0B;
      D.32455 = (long int) D.32454;
      D.32456 = __builtin_expect (D.32455, 0);
      if (D.32456 != 0) goto <D.32457>; else goto <D.32458>;
      <D.32457>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2329, "tmp_klass");
      <D.32458>:
      <D.32451>:
    }
    D.23886 = tmp_klass;
  }
  array_vtable = mono_class_vtable_full (domain, D.23886, 1);
  D.32459 = type->type;
  klass = mono_class_from_mono_type (D.32459);
  D.32460 = klass->generic_container;
  if (D.32460 != 0B) goto <D.32461>; else goto <D.32462>;
  <D.32461>:
  {
    struct MonoGenericContainer * container;

    container = klass->generic_container;
    D.32463 = container->type_argc;
    D.32464 = (unsigned int) D.32463;
    res = mono_array_new_specific (array_vtable, D.32464);
    i = 0;
    goto <D.23891>;
    <D.23890>:
    D.32465 = container->type_params;
    i.223 = (unsigned int) i;
    D.32467 = i.223 * 32;
    D.32468 = D.32465 + D.32467;
    D.32469 = klass->image;
    pklass = mono_class_from_generic_parameter (D.32468, D.32469, 0);
    {
      void * * __p;

      i.224 = (unsigned int) i;
      __p = mono_array_addr_with_size (res, 4, i.224);
      D.32471 = &pklass->byval_arg;
      D.32472 = mono_type_get_object (domain, D.32471);
      mono_gc_wbarrier_set_arrayref (res, __p, D.32472);
    }
    i = i + 1;
    <D.23891>:
    D.32463 = container->type_argc;
    D.32473 = (int) D.32463;
    if (D.32473 > i) goto <D.23890>; else goto <D.23892>;
    <D.23892>:
  }
  goto <D.32474>;
  <D.32462>:
  D.32475 = klass->generic_class;
  if (D.32475 != 0B) goto <D.32476>; else goto <D.32477>;
  <D.32476>:
  {
    struct MonoGenericInst * inst;

    D.32475 = klass->generic_class;
    inst = D.32475->context.class_inst;
    D.32478 = inst->type_argc;
    D.32479 = (unsigned int) D.32478;
    res = mono_array_new_specific (array_vtable, D.32479);
    i = 0;
    goto <D.23896>;
    <D.23895>:
    {
      void * * __p;

      i.224 = (unsigned int) i;
      __p = mono_array_addr_with_size (res, 4, i.224);
      D.32480 = inst->type_argv[i];
      D.32481 = mono_type_get_object (domain, D.32480);
      mono_gc_wbarrier_set_arrayref (res, __p, D.32481);
    }
    i = i + 1;
    <D.23896>:
    D.32478 = inst->type_argc;
    D.32482 = (int) D.32478;
    if (D.32482 > i) goto <D.23895>; else goto <D.23897>;
    <D.23897>:
  }
  goto <D.32483>;
  <D.32477>:
  res = mono_array_new_specific (array_vtable, 0);
  <D.32483>:
  <D.32474>:
  D.32484 = res;
  return D.32484;
}


ves_icall_Type_GetFields_internal (struct MonoReflectionType * type, guint32 bflags, struct MonoReflectionType * reftype)
{
  struct MonoVTable * D.32486;
  struct MonoType * D.32487;
  unsigned char D.32488;
  unsigned char D.32489;
  struct MonoArray * D.32492;
  struct MonoClass * D.32493;
  struct MonoType * D.32494;
  void * D.32495;
  unsigned char D.32496;
  int D.32499;
  void * * D.32502;
  struct MonoException * D.32503;
  unsigned int D.32504;
  int D.24375;
  int iftmp.225;
  int D.24374;
  const char[9] * D.32510;
  unsigned char D.32511;
  int D.32512;
  unsigned char D.32513;
  int D.32514;
  _Bool D.32515;
  _Bool D.32516;
  _Bool D.32517;
  const unsigned char * D.32520;
  unsigned char D.32521;
  int D.32522;
  const unsigned char * D.32523;
  unsigned char D.32524;
  int D.32525;
  _Bool D.32526;
  _Bool D.32527;
  const unsigned char * D.32530;
  unsigned char D.32531;
  int D.32532;
  const unsigned char * D.32533;
  unsigned char D.32534;
  int D.32535;
  _Bool D.32536;
  _Bool D.32537;
  const unsigned char * D.32540;
  unsigned char D.32541;
  int D.32542;
  const unsigned char * D.32543;
  unsigned char D.32544;
  int D.32545;
  const char * D.32547;
  unsigned int D.32550;
  unsigned int D.32553;
  unsigned int D.32560;
  unsigned int D.32565;
  unsigned int D.32568;
  unsigned int D.32573;
  unsigned int D.32576;
  int D.32581;
  unsigned int D.32584;
  unsigned int D.32585;
  int D.32586;
  void * D.32587;
  unsigned int D.32588;
  int D.32591;
  int D.32592;
  unsigned int D.32593;
  unsigned int D.32594;
  void * * D.32595;
  unsigned int D.32596;
  struct MonoClass * D.24381;
  struct MonoClass * tmp_klass.226;
  struct MonoClass * tmp_klass.227;
  _Bool D.32604;
  long int D.32605;
  long int D.32606;
  struct MonoVTable * D.32609;
  unsigned int D.32610;
  unsigned int i.228;
  unsigned int i.229;
  unsigned int D.32613;
  void * * D.32614;
  void * D.32615;
  struct MonoDomain * domain;
  struct MonoClass * startklass;
  struct MonoClass * klass;
  struct MonoClass * refklass;
  struct MonoArray * res;
  struct MonoObject * member;
  int i;
  int match;
  void * iter;
  struct MonoClassField * field;
  struct MonoPtrArray tmp_array;
  void handle_parent = <<< error >>>;

  try
    {
      D.32486 = MEM[(struct MonoObject *)type].vtable;
      domain = D.32486->domain;
      D.32487 = type->type;
      D.32488 = BIT_FIELD_REF <*D.32487, 8, 56>;
      D.32489 = D.32488 & 64;
      if (D.32489 != 0) goto <D.32490>; else goto <D.32491>;
      <D.32490>:
      D.32493 = mono_defaults.field_info_class;
      D.32492 = mono_array_new (domain, D.32493, 0);
      return D.32492;
      <D.32491>:
      D.32487 = type->type;
      startklass = mono_class_from_mono_type (D.32487);
      klass = startklass;
      D.32494 = reftype->type;
      refklass = mono_class_from_mono_type (D.32494);
      tmp_array.size = 0;
      tmp_array.capacity = 16;
      D.32495 = __builtin_alloca (64);
      tmp_array.data = D.32495;
      handle_parent:
      D.32496 = klass->exception_type;
      if (D.32496 != 0) goto <D.32497>; else goto <D.32498>;
      <D.32497>:
      D.32499 = tmp_array.capacity;
      if (D.32499 > 16) goto <D.32500>; else goto <D.32501>;
      <D.32500>:
      D.32502 = tmp_array.data;
      mono_gc_free_fixed (D.32502);
      <D.32501>:
      D.32503 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.32503);
      <D.32498>:
      iter = 0B;
      goto <D.24376>;
      <D.24378>:
      {
        guint32 flags;

        flags = mono_field_get_flags (field);
        match = 0;
        D.32504 = flags & 1536;
        if (D.32504 != 0) goto <D.32505>; else goto <D.32506>;
        <D.32505>:
        {
          size_t __s1_len;
          size_t __s2_len;

          __s2_len = 8;
          if (__s2_len <= 3) goto <D.32508>; else goto <D.32509>;
          <D.32508>:
          {
            const unsigned char * __s2;
            int __result;

            __s2 = mono_field_get_name (field);
            D.32510 = "_Deleted";
            D.32511 = MEM[(const unsigned char *)D.32510];
            D.32512 = (int) D.32511;
            D.32513 = *__s2;
            D.32514 = (int) D.32513;
            __result = D.32512 - D.32514;
            {
              D.32515 = __s2_len != 0;
              D.32516 = __result == 0;
              D.32517 = D.32515 & D.32516;
              if (D.32517 != 0) goto <D.32518>; else goto <D.32519>;
              <D.32518>:
              D.32520 = &MEM[(void *)"_Deleted" + 1B];
              D.32521 = *D.32520;
              D.32522 = (int) D.32521;
              D.32523 = __s2 + 1;
              D.32524 = *D.32523;
              D.32525 = (int) D.32524;
              __result = D.32522 - D.32525;
              D.32526 = __s2_len > 1;
              D.32516 = __result == 0;
              D.32527 = D.32526 & D.32516;
              if (D.32527 != 0) goto <D.32528>; else goto <D.32529>;
              <D.32528>:
              D.32530 = &MEM[(void *)"_Deleted" + 2B];
              D.32531 = *D.32530;
              D.32532 = (int) D.32531;
              D.32533 = __s2 + 2;
              D.32534 = *D.32533;
              D.32535 = (int) D.32534;
              __result = D.32532 - D.32535;
              D.32536 = __s2_len > 2;
              D.32516 = __result == 0;
              D.32537 = D.32536 & D.32516;
              if (D.32537 != 0) goto <D.32538>; else goto <D.32539>;
              <D.32538>:
              D.32540 = &MEM[(void *)"_Deleted" + 3B];
              D.32541 = *D.32540;
              D.32542 = (int) D.32541;
              D.32543 = __s2 + 3;
              D.32544 = *D.32543;
              D.32545 = (int) D.32544;
              __result = D.32542 - D.32545;
              <D.32539>:
              <D.32529>:
              <D.32519>:
            }
            D.24374 = __result;
          }
          iftmp.225 = -D.24374;
          goto <D.32546>;
          <D.32509>:
          D.32547 = mono_field_get_name (field);
          iftmp.225 = __builtin_strcmp (D.32547, "_Deleted");
          <D.32546>:
          D.24375 = iftmp.225;
        }
        if (D.24375 == 0) goto <D.32548>; else goto <D.32549>;
        <D.32548>:
        // predicted unlikely by continue predictor.
        goto <D.24376>;
        <D.32549>:
        <D.32506>:
        D.32550 = flags & 7;
        if (D.32550 == 6) goto <D.32551>; else goto <D.32552>;
        <D.32551>:
        D.32553 = bflags & 16;
        if (D.32553 != 0) goto <D.32554>; else goto <D.32555>;
        <D.32554>:
        match = match + 1;
        <D.32555>:
        goto <D.32556>;
        <D.32552>:
        if (klass == startklass) goto <D.32557>; else goto <D.32559>;
        <D.32559>:
        D.32550 = flags & 7;
        if (D.32550 != 1) goto <D.32557>; else goto <D.32558>;
        <D.32557>:
        D.32560 = bflags & 32;
        if (D.32560 != 0) goto <D.32561>; else goto <D.32562>;
        <D.32561>:
        match = match + 1;
        <D.32562>:
        <D.32558>:
        <D.32556>:
        if (match == 0) goto <D.32563>; else goto <D.32564>;
        <D.32563>:
        // predicted unlikely by continue predictor.
        goto <D.24376>;
        <D.32564>:
        match = 0;
        D.32565 = flags & 16;
        if (D.32565 != 0) goto <D.32566>; else goto <D.32567>;
        <D.32566>:
        D.32568 = bflags & 8;
        if (D.32568 != 0) goto <D.32569>; else goto <D.32570>;
        <D.32569>:
        D.32573 = bflags & 64;
        if (D.32573 != 0) goto <D.32571>; else goto <D.32574>;
        <D.32574>:
        if (klass == startklass) goto <D.32571>; else goto <D.32572>;
        <D.32571>:
        match = match + 1;
        <D.32572>:
        <D.32570>:
        goto <D.32575>;
        <D.32567>:
        D.32576 = bflags & 4;
        if (D.32576 != 0) goto <D.32577>; else goto <D.32578>;
        <D.32577>:
        match = match + 1;
        <D.32578>:
        <D.32575>:
        if (match == 0) goto <D.32579>; else goto <D.32580>;
        <D.32579>:
        // predicted unlikely by continue predictor.
        goto <D.24376>;
        <D.32580>:
        member = mono_field_get_object (domain, refklass, field);
        D.32581 = tmp_array.size;
        D.32499 = tmp_array.capacity;
        if (D.32581 >= D.32499) goto <D.32582>; else goto <D.32583>;
        <D.32582>:
        {
          void * __tmp;

          D.32499 = tmp_array.capacity;
          D.32584 = (unsigned int) D.32499;
          D.32585 = D.32584 * 8;
          D.32499 = tmp_array.capacity;
          D.32586 = D.32499 * 2;
          D.32587 = mono_gc_make_root_descr_all_refs (D.32586);
          __tmp = mono_gc_alloc_fixed (D.32585, D.32587);
          D.32502 = tmp_array.data;
          D.32499 = tmp_array.capacity;
          D.32584 = (unsigned int) D.32499;
          D.32588 = D.32584 * 4;
          mono_gc_memmove_aligned (__tmp, D.32502, D.32588);
          D.32499 = tmp_array.capacity;
          if (D.32499 > 16) goto <D.32589>; else goto <D.32590>;
          <D.32589>:
          D.32502 = tmp_array.data;
          mono_gc_free_fixed (D.32502);
          <D.32590>:
          tmp_array.data = __tmp;
          D.32499 = tmp_array.capacity;
          D.32586 = D.32499 * 2;
          tmp_array.capacity = D.32586;
        }
        <D.32583>:
        D.32502 = tmp_array.data;
        D.32581 = tmp_array.size;
        D.32591 = D.32581;
        D.32592 = D.32591 + 1;
        tmp_array.size = D.32592;
        D.32593 = (unsigned int) D.32591;
        D.32594 = D.32593 * 4;
        D.32595 = D.32502 + D.32594;
        *D.32595 = member;
      }
      <D.24376>:
      field = mono_class_get_fields_lazy (klass, &iter);
      if (field != 0B) goto <D.24378>; else goto <D.24379>;
      <D.24379>:
      D.32596 = bflags & 2;
      if (D.32596 == 0) goto <D.32597>; else goto <D.32598>;
      <D.32597>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.32599>;
      <D.32599>:
      <D.32598>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.226 = tmp_klass;
          if (tmp_klass.226 == 0B) goto <D.32601>; else goto <D.32602>;
          <D.32601>:
          D.32493 = mono_defaults.field_info_class;
          tmp_klass.227 = mono_array_class_get (D.32493, 1);
          tmp_klass = tmp_klass.227;
          tmp_klass.226 = tmp_klass;
          D.32604 = tmp_klass.226 == 0B;
          D.32605 = (long int) D.32604;
          D.32606 = __builtin_expect (D.32605, 0);
          if (D.32606 != 0) goto <D.32607>; else goto <D.32608>;
          <D.32607>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3414, "tmp_klass");
          <D.32608>:
          <D.32602>:
        }
        D.24381 = tmp_klass;
      }
      D.32609 = mono_class_vtable (domain, D.24381);
      D.32581 = tmp_array.size;
      D.32610 = (unsigned int) D.32581;
      res = mono_array_new_specific (D.32609, D.32610);
      i = 0;
      goto <D.24384>;
      <D.24383>:
      {
        void * * __p;

        i.228 = (unsigned int) i;
        __p = mono_array_addr_with_size (res, 4, i.228);
        D.32502 = tmp_array.data;
        i.229 = (unsigned int) i;
        D.32613 = i.229 * 4;
        D.32614 = D.32502 + D.32613;
        D.32615 = *D.32614;
        mono_gc_wbarrier_set_arrayref (res, __p, D.32615);
      }
      i = i + 1;
      <D.24384>:
      D.32581 = tmp_array.size;
      if (D.32581 > i) goto <D.24383>; else goto <D.24385>;
      <D.24385>:
      D.32499 = tmp_array.capacity;
      if (D.32499 > 16) goto <D.32616>; else goto <D.32617>;
      <D.32616>:
      D.32502 = tmp_array.data;
      mono_gc_free_fixed (D.32502);
      <D.32617>:
      D.32492 = res;
      return D.32492;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_Type_GetField (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags)
{
  struct MonoVTable * D.32620;
  struct MonoType * D.32621;
  struct MonoException * D.32624;
  unsigned char D.32625;
  unsigned char D.32626;
  struct MonoReflectionField * D.32629;
  int (*<T43a0>) (const char *, const char *) iftmp.230;
  unsigned int D.32631;
  unsigned char D.32635;
  struct MonoException * D.32638;
  unsigned int D.32639;
  int D.24345;
  int iftmp.231;
  int D.24344;
  const char[9] * D.32645;
  unsigned char D.32646;
  int D.32647;
  unsigned char D.32648;
  int D.32649;
  _Bool D.32650;
  _Bool D.32651;
  _Bool D.32652;
  const unsigned char * D.32655;
  unsigned char D.32656;
  int D.32657;
  const unsigned char * D.32658;
  unsigned char D.32659;
  int D.32660;
  _Bool D.32661;
  _Bool D.32662;
  const unsigned char * D.32665;
  unsigned char D.32666;
  int D.32667;
  const unsigned char * D.32668;
  unsigned char D.32669;
  int D.32670;
  _Bool D.32671;
  _Bool D.32672;
  const unsigned char * D.32675;
  unsigned char D.32676;
  int D.32677;
  const unsigned char * D.32678;
  unsigned char D.32679;
  int D.32680;
  const char * D.32682;
  unsigned int D.32685;
  unsigned int D.32688;
  unsigned int D.32695;
  unsigned int D.32700;
  unsigned int D.32703;
  unsigned int D.32708;
  unsigned int D.32711;
  const char * D.32716;
  int D.32717;
  unsigned int D.32720;
  struct MonoDomain * domain;
  struct MonoClass * startklass;
  struct MonoClass * klass;
  int match;
  struct MonoClassField * field;
  void * iter;
  char * utf8_name;
  int (*<T43a0>) (const char *, const char *) compare_func;
  void handle_parent = <<< error >>>;

  try
    {
      compare_func = 0B;
      D.32620 = MEM[(struct MonoObject *)type].vtable;
      domain = D.32620->domain;
      D.32621 = type->type;
      startklass = mono_class_from_mono_type (D.32621);
      klass = startklass;
      if (name == 0B) goto <D.32622>; else goto <D.32623>;
      <D.32622>:
      D.32624 = mono_get_exception_argument_null ("name");
      mono_raise_exception (D.32624);
      <D.32623>:
      D.32621 = type->type;
      D.32625 = BIT_FIELD_REF <*D.32621, 8, 56>;
      D.32626 = D.32625 & 64;
      if (D.32626 != 0) goto <D.32627>; else goto <D.32628>;
      <D.32627>:
      D.32629 = 0B;
      return D.32629;
      <D.32628>:
      D.32631 = bflags & 1;
      if (D.32631 != 0) goto <D.32632>; else goto <D.32633>;
      <D.32632>:
      iftmp.230 = monoeg_ascii_strcasecmp;
      goto <D.32634>;
      <D.32633>:
      iftmp.230 = strcmp;
      <D.32634>:
      compare_func = iftmp.230;
      handle_parent:
      D.32635 = klass->exception_type;
      if (D.32635 != 0) goto <D.32636>; else goto <D.32637>;
      <D.32636>:
      D.32638 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.32638);
      <D.32637>:
      iter = 0B;
      goto <D.24346>;
      <D.24347>:
      {
        guint32 flags;

        flags = mono_field_get_flags (field);
        match = 0;
        D.32639 = flags & 1536;
        if (D.32639 != 0) goto <D.32640>; else goto <D.32641>;
        <D.32640>:
        {
          size_t __s1_len;
          size_t __s2_len;

          __s2_len = 8;
          if (__s2_len <= 3) goto <D.32643>; else goto <D.32644>;
          <D.32643>:
          {
            const unsigned char * __s2;
            int __result;

            __s2 = mono_field_get_name (field);
            D.32645 = "_Deleted";
            D.32646 = MEM[(const unsigned char *)D.32645];
            D.32647 = (int) D.32646;
            D.32648 = *__s2;
            D.32649 = (int) D.32648;
            __result = D.32647 - D.32649;
            {
              D.32650 = __s2_len != 0;
              D.32651 = __result == 0;
              D.32652 = D.32650 & D.32651;
              if (D.32652 != 0) goto <D.32653>; else goto <D.32654>;
              <D.32653>:
              D.32655 = &MEM[(void *)"_Deleted" + 1B];
              D.32656 = *D.32655;
              D.32657 = (int) D.32656;
              D.32658 = __s2 + 1;
              D.32659 = *D.32658;
              D.32660 = (int) D.32659;
              __result = D.32657 - D.32660;
              D.32661 = __s2_len > 1;
              D.32651 = __result == 0;
              D.32662 = D.32661 & D.32651;
              if (D.32662 != 0) goto <D.32663>; else goto <D.32664>;
              <D.32663>:
              D.32665 = &MEM[(void *)"_Deleted" + 2B];
              D.32666 = *D.32665;
              D.32667 = (int) D.32666;
              D.32668 = __s2 + 2;
              D.32669 = *D.32668;
              D.32670 = (int) D.32669;
              __result = D.32667 - D.32670;
              D.32671 = __s2_len > 2;
              D.32651 = __result == 0;
              D.32672 = D.32671 & D.32651;
              if (D.32672 != 0) goto <D.32673>; else goto <D.32674>;
              <D.32673>:
              D.32675 = &MEM[(void *)"_Deleted" + 3B];
              D.32676 = *D.32675;
              D.32677 = (int) D.32676;
              D.32678 = __s2 + 3;
              D.32679 = *D.32678;
              D.32680 = (int) D.32679;
              __result = D.32677 - D.32680;
              <D.32674>:
              <D.32664>:
              <D.32654>:
            }
            D.24344 = __result;
          }
          iftmp.231 = -D.24344;
          goto <D.32681>;
          <D.32644>:
          D.32682 = mono_field_get_name (field);
          iftmp.231 = __builtin_strcmp (D.32682, "_Deleted");
          <D.32681>:
          D.24345 = iftmp.231;
        }
        if (D.24345 == 0) goto <D.32683>; else goto <D.32684>;
        <D.32683>:
        // predicted unlikely by continue predictor.
        goto <D.24346>;
        <D.32684>:
        <D.32641>:
        D.32685 = flags & 7;
        if (D.32685 == 6) goto <D.32686>; else goto <D.32687>;
        <D.32686>:
        D.32688 = bflags & 16;
        if (D.32688 != 0) goto <D.32689>; else goto <D.32690>;
        <D.32689>:
        match = match + 1;
        <D.32690>:
        goto <D.32691>;
        <D.32687>:
        if (klass == startklass) goto <D.32692>; else goto <D.32694>;
        <D.32694>:
        D.32685 = flags & 7;
        if (D.32685 != 1) goto <D.32692>; else goto <D.32693>;
        <D.32692>:
        D.32695 = bflags & 32;
        if (D.32695 != 0) goto <D.32696>; else goto <D.32697>;
        <D.32696>:
        match = match + 1;
        <D.32697>:
        <D.32693>:
        <D.32691>:
        if (match == 0) goto <D.32698>; else goto <D.32699>;
        <D.32698>:
        // predicted unlikely by continue predictor.
        goto <D.24346>;
        <D.32699>:
        match = 0;
        D.32700 = flags & 16;
        if (D.32700 != 0) goto <D.32701>; else goto <D.32702>;
        <D.32701>:
        D.32703 = bflags & 8;
        if (D.32703 != 0) goto <D.32704>; else goto <D.32705>;
        <D.32704>:
        D.32708 = bflags & 64;
        if (D.32708 != 0) goto <D.32706>; else goto <D.32709>;
        <D.32709>:
        if (klass == startklass) goto <D.32706>; else goto <D.32707>;
        <D.32706>:
        match = match + 1;
        <D.32707>:
        <D.32705>:
        goto <D.32710>;
        <D.32702>:
        D.32711 = bflags & 4;
        if (D.32711 != 0) goto <D.32712>; else goto <D.32713>;
        <D.32712>:
        match = match + 1;
        <D.32713>:
        <D.32710>:
        if (match == 0) goto <D.32714>; else goto <D.32715>;
        <D.32714>:
        // predicted unlikely by continue predictor.
        goto <D.24346>;
        <D.32715>:
        utf8_name = mono_string_to_utf8 (name);
        D.32716 = mono_field_get_name (field);
        D.32717 = compare_func (D.32716, utf8_name);
        if (D.32717 != 0) goto <D.32718>; else goto <D.32719>;
        <D.32718>:
        monoeg_g_free (utf8_name);
        // predicted unlikely by continue predictor.
        goto <D.24346>;
        <D.32719>:
        monoeg_g_free (utf8_name);
        D.32629 = mono_field_get_object (domain, klass, field);
        return D.32629;
      }
      <D.24346>:
      field = mono_class_get_fields_lazy (klass, &iter);
      if (field != 0B) goto <D.24347>; else goto <D.24348>;
      <D.24348>:
      D.32720 = bflags & 2;
      if (D.32720 == 0) goto <D.32721>; else goto <D.32722>;
      <D.32721>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.32723>;
      <D.32723>:
      <D.32722>:
      D.32629 = 0B;
      return D.32629;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetEvents_internal (struct MonoReflectionType * type, guint32 bflags, struct MonoReflectionType * reftype)
{
  void * D.32726;
  struct MonoClass * System_Reflection_EventInfo.232;
  struct MonoImage * D.32730;
  struct MonoClass * System_Reflection_EventInfo.233;
  struct MonoVTable * D.32732;
  struct MonoType * D.32733;
  unsigned char D.32734;
  unsigned char D.32735;
  struct MonoArray * D.32738;
  struct MonoClass * D.24604;
  struct MonoClass * tmp_klass.234;
  struct MonoClass * tmp_klass.235;
  _Bool D.32743;
  long int D.32744;
  long int D.32745;
  struct MonoVTable * D.32748;
  unsigned char D.32749;
  struct MonoLoaderError * D.32751;
  short unsigned int D.32759;
  int D.32760;
  int D.32761;
  unsigned int D.32764;
  unsigned int D.32771;
  int D.32781;
  unsigned int D.32784;
  unsigned int D.32789;
  unsigned int D.32792;
  int D.32800;
  int D.32801;
  unsigned int D.32804;
  unsigned int D.32805;
  int D.32806;
  void * D.32807;
  void * * D.32808;
  unsigned int D.32809;
  int D.32812;
  int D.32813;
  unsigned int D.32814;
  unsigned int D.32815;
  void * * D.32816;
  struct MonoReflectionEvent * D.32817;
  unsigned int D.32818;
  struct MonoClass * D.24612;
  struct MonoClass * tmp_klass.236;
  struct MonoClass * tmp_klass.237;
  _Bool D.32826;
  long int D.32827;
  long int D.32828;
  struct MonoVTable * D.32831;
  unsigned int D.32832;
  unsigned int i.238;
  unsigned int i.239;
  unsigned int D.32835;
  void * * D.32836;
  void * D.32837;
  struct MonoLoaderError * D.32845;
  struct MonoException * ex;
  struct MonoDomain * domain;
  static struct MonoClass * System_Reflection_EventInfo;
  struct MonoClass * startklass;
  struct MonoClass * klass;
  struct MonoArray * res;
  struct MonoMethod * method;
  struct MonoEvent * event;
  int i;
  int match;
  void * iter;
  struct MonoPtrArray tmp_array;
  void handle_parent = <<< error >>>;
  void loader_error = <<< error >>>;

  try
    {
      tmp_array.size = 0;
      tmp_array.capacity = 16;
      D.32726 = __builtin_alloca (64);
      tmp_array.data = D.32726;
      System_Reflection_EventInfo.232 = System_Reflection_EventInfo;
      if (System_Reflection_EventInfo.232 == 0B) goto <D.32728>; else goto <D.32729>;
      <D.32728>:
      D.32730 = mono_defaults.corlib;
      System_Reflection_EventInfo.233 = mono_class_from_name (D.32730, "System.Reflection", "EventInfo");
      System_Reflection_EventInfo = System_Reflection_EventInfo.233;
      <D.32729>:
      D.32732 = MEM[(struct MonoObject *)type].vtable;
      domain = D.32732->domain;
      D.32733 = type->type;
      D.32734 = BIT_FIELD_REF <*D.32733, 8, 56>;
      D.32735 = D.32734 & 64;
      if (D.32735 != 0) goto <D.32736>; else goto <D.32737>;
      <D.32736>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.234 = tmp_klass;
          if (tmp_klass.234 == 0B) goto <D.32740>; else goto <D.32741>;
          <D.32740>:
          System_Reflection_EventInfo.232 = System_Reflection_EventInfo;
          tmp_klass.235 = mono_array_class_get (System_Reflection_EventInfo.232, 1);
          tmp_klass = tmp_klass.235;
          tmp_klass.234 = tmp_klass;
          D.32743 = tmp_klass.234 == 0B;
          D.32744 = (long int) D.32743;
          D.32745 = __builtin_expect (D.32744, 0);
          if (D.32745 != 0) goto <D.32746>; else goto <D.32747>;
          <D.32746>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3914, "tmp_klass");
          <D.32747>:
          <D.32741>:
        }
        D.24604 = tmp_klass;
      }
      D.32748 = mono_class_vtable (domain, D.24604);
      D.32738 = mono_array_new_specific (D.32748, 0);
      return D.32738;
      <D.32737>:
      D.32733 = type->type;
      startklass = mono_class_from_mono_type (D.32733);
      klass = startklass;
      handle_parent:
      mono_class_setup_vtable (klass);
      D.32749 = klass->exception_type;
      if (D.32749 != 0) goto loader_error; else goto <D.32750>;
      <D.32750>:
      D.32751 = mono_loader_get_last_error ();
      if (D.32751 != 0B) goto loader_error; else goto <D.32752>;
      <D.32752>:
      iter = 0B;
      goto <D.24607>;
      <D.24609>:
      match = 0;
      method = event->add;
      if (method == 0B) goto <D.32753>; else goto <D.32754>;
      <D.32753>:
      method = event->remove;
      <D.32754>:
      if (method == 0B) goto <D.32755>; else goto <D.32756>;
      <D.32755>:
      method = event->raise;
      <D.32756>:
      if (method != 0B) goto <D.32757>; else goto <D.32758>;
      <D.32757>:
      D.32759 = method->flags;
      D.32760 = (int) D.32759;
      D.32761 = D.32760 & 7;
      if (D.32761 == 6) goto <D.32762>; else goto <D.32763>;
      <D.32762>:
      D.32764 = bflags & 16;
      if (D.32764 != 0) goto <D.32765>; else goto <D.32766>;
      <D.32765>:
      match = match + 1;
      <D.32766>:
      goto <D.32767>;
      <D.32763>:
      if (klass == startklass) goto <D.32768>; else goto <D.32770>;
      <D.32770>:
      D.32759 = method->flags;
      D.32760 = (int) D.32759;
      D.32761 = D.32760 & 7;
      if (D.32761 != 1) goto <D.32768>; else goto <D.32769>;
      <D.32768>:
      D.32771 = bflags & 32;
      if (D.32771 != 0) goto <D.32772>; else goto <D.32773>;
      <D.32772>:
      match = match + 1;
      <D.32773>:
      <D.32769>:
      <D.32767>:
      goto <D.32774>;
      <D.32758>:
      D.32771 = bflags & 32;
      if (D.32771 != 0) goto <D.32775>; else goto <D.32776>;
      <D.32775>:
      match = match + 1;
      <D.32776>:
      <D.32774>:
      if (match == 0) goto <D.32777>; else goto <D.32778>;
      <D.32777>:
      // predicted unlikely by continue predictor.
      goto <D.24607>;
      <D.32778>:
      match = 0;
      if (method != 0B) goto <D.32779>; else goto <D.32780>;
      <D.32779>:
      D.32759 = method->flags;
      D.32760 = (int) D.32759;
      D.32781 = D.32760 & 16;
      if (D.32781 != 0) goto <D.32782>; else goto <D.32783>;
      <D.32782>:
      D.32784 = bflags & 8;
      if (D.32784 != 0) goto <D.32785>; else goto <D.32786>;
      <D.32785>:
      D.32789 = bflags & 64;
      if (D.32789 != 0) goto <D.32787>; else goto <D.32790>;
      <D.32790>:
      if (klass == startklass) goto <D.32787>; else goto <D.32788>;
      <D.32787>:
      match = match + 1;
      <D.32788>:
      <D.32786>:
      goto <D.32791>;
      <D.32783>:
      D.32792 = bflags & 4;
      if (D.32792 != 0) goto <D.32793>; else goto <D.32794>;
      <D.32793>:
      match = match + 1;
      <D.32794>:
      <D.32791>:
      goto <D.32795>;
      <D.32780>:
      D.32792 = bflags & 4;
      if (D.32792 != 0) goto <D.32796>; else goto <D.32797>;
      <D.32796>:
      match = match + 1;
      <D.32797>:
      <D.32795>:
      if (match == 0) goto <D.32798>; else goto <D.32799>;
      <D.32798>:
      // predicted unlikely by continue predictor.
      goto <D.24607>;
      <D.32799>:
      D.32800 = tmp_array.size;
      D.32801 = tmp_array.capacity;
      if (D.32800 >= D.32801) goto <D.32802>; else goto <D.32803>;
      <D.32802>:
      {
        void * __tmp;

        D.32801 = tmp_array.capacity;
        D.32804 = (unsigned int) D.32801;
        D.32805 = D.32804 * 8;
        D.32801 = tmp_array.capacity;
        D.32806 = D.32801 * 2;
        D.32807 = mono_gc_make_root_descr_all_refs (D.32806);
        __tmp = mono_gc_alloc_fixed (D.32805, D.32807);
        D.32808 = tmp_array.data;
        D.32801 = tmp_array.capacity;
        D.32804 = (unsigned int) D.32801;
        D.32809 = D.32804 * 4;
        mono_gc_memmove_aligned (__tmp, D.32808, D.32809);
        D.32801 = tmp_array.capacity;
        if (D.32801 > 16) goto <D.32810>; else goto <D.32811>;
        <D.32810>:
        D.32808 = tmp_array.data;
        mono_gc_free_fixed (D.32808);
        <D.32811>:
        tmp_array.data = __tmp;
        D.32801 = tmp_array.capacity;
        D.32806 = D.32801 * 2;
        tmp_array.capacity = D.32806;
      }
      <D.32803>:
      D.32808 = tmp_array.data;
      D.32800 = tmp_array.size;
      D.32812 = D.32800;
      D.32813 = D.32812 + 1;
      tmp_array.size = D.32813;
      D.32814 = (unsigned int) D.32812;
      D.32815 = D.32814 * 4;
      D.32816 = D.32808 + D.32815;
      D.32817 = mono_event_get_object (domain, startklass, event);
      *D.32816 = D.32817;
      <D.24607>:
      event = mono_class_get_events (klass, &iter);
      if (event != 0B) goto <D.24609>; else goto <D.24610>;
      <D.24610>:
      D.32818 = bflags & 2;
      if (D.32818 == 0) goto <D.32819>; else goto <D.32820>;
      <D.32819>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.32821>;
      <D.32821>:
      <D.32820>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.236 = tmp_klass;
          if (tmp_klass.236 == 0B) goto <D.32823>; else goto <D.32824>;
          <D.32823>:
          System_Reflection_EventInfo.232 = System_Reflection_EventInfo;
          tmp_klass.237 = mono_array_class_get (System_Reflection_EventInfo.232, 1);
          tmp_klass = tmp_klass.237;
          tmp_klass.236 = tmp_klass;
          D.32826 = tmp_klass.236 == 0B;
          D.32827 = (long int) D.32826;
          D.32828 = __builtin_expect (D.32827, 0);
          if (D.32828 != 0) goto <D.32829>; else goto <D.32830>;
          <D.32829>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3965, "tmp_klass");
          <D.32830>:
          <D.32824>:
        }
        D.24612 = tmp_klass;
      }
      D.32831 = mono_class_vtable (domain, D.24612);
      D.32800 = tmp_array.size;
      D.32832 = (unsigned int) D.32800;
      res = mono_array_new_specific (D.32831, D.32832);
      i = 0;
      goto <D.24615>;
      <D.24614>:
      {
        void * * __p;

        i.238 = (unsigned int) i;
        __p = mono_array_addr_with_size (res, 4, i.238);
        D.32808 = tmp_array.data;
        i.239 = (unsigned int) i;
        D.32835 = i.239 * 4;
        D.32836 = D.32808 + D.32835;
        D.32837 = *D.32836;
        mono_gc_wbarrier_set_arrayref (res, __p, D.32837);
      }
      i = i + 1;
      <D.24615>:
      D.32800 = tmp_array.size;
      if (D.32800 > i) goto <D.24614>; else goto <D.24616>;
      <D.24616>:
      D.32801 = tmp_array.capacity;
      if (D.32801 > 16) goto <D.32838>; else goto <D.32839>;
      <D.32838>:
      D.32808 = tmp_array.data;
      mono_gc_free_fixed (D.32808);
      <D.32839>:
      D.32738 = res;
      return D.32738;
      loader_error:
      D.32801 = tmp_array.capacity;
      if (D.32801 > 16) goto <D.32840>; else goto <D.32841>;
      <D.32840>:
      D.32808 = tmp_array.data;
      mono_gc_free_fixed (D.32808);
      <D.32841>:
      D.32749 = klass->exception_type;
      if (D.32749 != 0) goto <D.32842>; else goto <D.32843>;
      <D.32842>:
      ex = mono_class_get_exception_for_failure (klass);
      goto <D.32844>;
      <D.32843>:
      D.32845 = mono_loader_get_last_error ();
      ex = mono_loader_error_prepare_exception (D.32845);
      mono_loader_clear_error ();
      <D.32844>:
      mono_raise_exception (ex);
      D.32738 = 0B;
      return D.32738;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_MonoType_GetElementType (struct MonoReflectionType * type)
{
  struct MonoType * D.32848;
  short unsigned int D.32849;
  short unsigned int D.32850;
  struct MonoReflectionType * D.32853;
  struct MonoVTable * D.32854;
  struct MonoDomain * D.32855;
  struct MonoClass * D.32856;
  struct MonoType * D.32857;
  unsigned char D.32858;
  unsigned char D.32859;
  struct MonoType * D.32862;
  struct MonoClass * D.32864;
  unsigned char D.32866;
  struct MonoType * D.32868;
  unsigned char D.32871;
  struct MonoClass * class;

  D.32848 = type->type;
  D.32849 = BIT_FIELD_REF <*D.32848, 16, 48>;
  D.32850 = D.32849 & 16639;
  if (D.32850 == 29) goto <D.32851>; else goto <D.32852>;
  <D.32851>:
  D.32854 = MEM[(struct MonoObject *)type].vtable;
  D.32855 = D.32854->domain;
  D.32848 = type->type;
  D.32856 = D.32848->data.klass;
  D.32857 = &D.32856->byval_arg;
  D.32853 = mono_type_get_object (D.32855, D.32857);
  return D.32853;
  <D.32852>:
  D.32848 = type->type;
  class = mono_class_from_mono_type (D.32848);
  mono_class_init_or_throw (class);
  D.32848 = type->type;
  D.32858 = BIT_FIELD_REF <*D.32848, 8, 56>;
  D.32859 = D.32858 & 64;
  if (D.32859 != 0) goto <D.32860>; else goto <D.32861>;
  <D.32860>:
  D.32854 = MEM[(struct MonoObject *)type].vtable;
  D.32855 = D.32854->domain;
  D.32862 = &class->byval_arg;
  D.32853 = mono_type_get_object (D.32855, D.32862);
  return D.32853;
  <D.32861>:
  D.32864 = class->element_class;
  if (D.32864 != 0B) goto <D.32865>; else goto <D.32863>;
  <D.32865>:
  D.32866 = class->rank;
  if (D.32866 != 0) goto <D.32867>; else goto <D.32863>;
  <D.32867>:
  D.32854 = MEM[(struct MonoObject *)type].vtable;
  D.32855 = D.32854->domain;
  D.32864 = class->element_class;
  D.32868 = &D.32864->byval_arg;
  D.32853 = mono_type_get_object (D.32855, D.32868);
  return D.32853;
  <D.32863>:
  D.32864 = class->element_class;
  if (D.32864 != 0B) goto <D.32870>; else goto <D.32869>;
  <D.32870>:
  D.32848 = type->type;
  D.32871 = D.32848->type;
  if (D.32871 == 15) goto <D.32872>; else goto <D.32869>;
  <D.32872>:
  D.32854 = MEM[(struct MonoObject *)type].vtable;
  D.32855 = D.32854->domain;
  D.32864 = class->element_class;
  D.32868 = &D.32864->byval_arg;
  D.32853 = mono_type_get_object (D.32855, D.32868);
  return D.32853;
  <D.32869>:
  D.32853 = 0B;
  return D.32853;
}


ves_icall_MonoType_GetCorrespondingInflatedMethod (struct MonoReflectionType * type, struct MonoReflectionMethod * generic)
{
  struct MonoVTable * D.32874;
  struct MonoType * D.32875;
  unsigned int D.32876;
  struct MonoMethod * D.32877;
  unsigned int D.32878;
  struct MonoReflectionMethod * D.32881;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoMethod * method;
  void * iter;

  try
    {
      D.32874 = MEM[(struct MonoObject *)type].vtable;
      domain = D.32874->domain;
      D.32875 = type->type;
      klass = mono_class_from_mono_type (D.32875);
      mono_class_init_or_throw (klass);
      iter = 0B;
      goto <D.23970>;
      <D.23969>:
      D.32876 = method->token;
      D.32877 = generic->method;
      D.32878 = D.32877->token;
      if (D.32876 == D.32878) goto <D.32879>; else goto <D.32880>;
      <D.32879>:
      D.32881 = mono_method_get_object (domain, method, klass);
      return D.32881;
      <D.32880>:
      <D.23970>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.23969>; else goto <D.23971>;
      <D.23971>:
      D.32881 = 0B;
      return D.32881;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetConstructors_internal (struct MonoReflectionType * type, guint32 bflags, struct MonoReflectionType * reftype)
{
  void * D.32884;
  struct MonoVTable * D.32885;
  struct MonoType * D.32886;
  unsigned char D.32887;
  unsigned char D.32888;
  struct MonoArray * D.32891;
  struct MonoClass * D.24487;
  struct MonoClass * tmp_klass.240;
  struct MonoClass * D.32895;
  struct MonoClass * tmp_klass.241;
  _Bool D.32897;
  long int D.32898;
  long int D.32899;
  struct MonoVTable * D.32902;
  struct MonoType * D.32903;
  struct MonoClass * System_Reflection_ConstructorInfo.242;
  struct MonoImage * D.32907;
  struct MonoClass * System_Reflection_ConstructorInfo.243;
  int D.24496;
  int iftmp.244;
  int D.24495;
  const char[6] * D.32912;
  unsigned char D.32913;
  int D.32914;
  unsigned char D.32915;
  int D.32916;
  _Bool D.32917;
  _Bool D.32918;
  _Bool D.32919;
  const unsigned char * D.32922;
  unsigned char D.32923;
  int D.32924;
  const unsigned char * D.32925;
  unsigned char D.32926;
  int D.32927;
  _Bool D.32928;
  _Bool D.32929;
  const unsigned char * D.32932;
  unsigned char D.32933;
  int D.32934;
  const unsigned char * D.32935;
  unsigned char D.32936;
  int D.32937;
  _Bool D.32938;
  _Bool D.32939;
  const unsigned char * D.32942;
  unsigned char D.32943;
  int D.32944;
  const unsigned char * D.32945;
  unsigned char D.32946;
  int D.32947;
  const char * D.32949;
  int D.24505;
  int iftmp.245;
  int D.24504;
  const char[7] * D.32955;
  unsigned char D.32956;
  int D.32957;
  unsigned char D.32958;
  int D.32959;
  _Bool D.32960;
  _Bool D.32961;
  _Bool D.32962;
  const unsigned char * D.32965;
  unsigned char D.32966;
  int D.32967;
  const unsigned char * D.32968;
  unsigned char D.32969;
  int D.32970;
  _Bool D.32971;
  _Bool D.32972;
  const unsigned char * D.32975;
  unsigned char D.32976;
  int D.32977;
  const unsigned char * D.32978;
  unsigned char D.32979;
  int D.32980;
  _Bool D.32981;
  _Bool D.32982;
  const unsigned char * D.32985;
  unsigned char D.32986;
  int D.32987;
  const unsigned char * D.32988;
  unsigned char D.32989;
  int D.32990;
  short unsigned int D.32994;
  int D.32995;
  int D.32996;
  unsigned int D.32999;
  unsigned int D.33003;
  int D.33008;
  unsigned int D.33011;
  unsigned int D.33016;
  unsigned int D.33019;
  int D.33024;
  int D.33025;
  unsigned int D.33028;
  unsigned int D.33029;
  int D.33030;
  void * D.33031;
  void * * D.33032;
  unsigned int D.33033;
  int D.33036;
  int D.33037;
  unsigned int D.33038;
  unsigned int D.33039;
  void * * D.33040;
  struct MonoClass * D.24511;
  struct MonoClass * tmp_klass.246;
  struct MonoClass * tmp_klass.247;
  _Bool D.33045;
  long int D.33046;
  long int D.33047;
  struct MonoVTable * D.33050;
  unsigned int D.33051;
  unsigned int i.248;
  unsigned int i.249;
  unsigned int D.33054;
  void * * D.33055;
  void * D.33056;
  struct MonoDomain * domain;
  static struct MonoClass * System_Reflection_ConstructorInfo;
  struct MonoClass * startklass;
  struct MonoClass * klass;
  struct MonoClass * refklass;
  struct MonoArray * res;
  struct MonoMethod * method;
  struct MonoObject * member;
  int i;
  int match;
  void * iter;
  struct MonoPtrArray tmp_array;

  try
    {
      iter = 0B;
      tmp_array.size = 0;
      tmp_array.capacity = 16;
      D.32884 = __builtin_alloca (64);
      tmp_array.data = D.32884;
      D.32885 = MEM[(struct MonoObject *)type].vtable;
      domain = D.32885->domain;
      D.32886 = type->type;
      D.32887 = BIT_FIELD_REF <*D.32886, 8, 56>;
      D.32888 = D.32887 & 64;
      if (D.32888 != 0) goto <D.32889>; else goto <D.32890>;
      <D.32889>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.240 = tmp_klass;
          if (tmp_klass.240 == 0B) goto <D.32893>; else goto <D.32894>;
          <D.32893>:
          D.32895 = mono_defaults.method_info_class;
          tmp_klass.241 = mono_array_class_get (D.32895, 1);
          tmp_klass = tmp_klass.241;
          tmp_klass.240 = tmp_klass;
          D.32897 = tmp_klass.240 == 0B;
          D.32898 = (long int) D.32897;
          D.32899 = __builtin_expect (D.32898, 0);
          if (D.32899 != 0) goto <D.32900>; else goto <D.32901>;
          <D.32900>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3617, "tmp_klass");
          <D.32901>:
          <D.32894>:
        }
        D.24487 = tmp_klass;
      }
      D.32902 = mono_class_vtable (domain, D.24487);
      D.32891 = mono_array_new_specific (D.32902, 0);
      return D.32891;
      <D.32890>:
      D.32886 = type->type;
      startklass = mono_class_from_mono_type (D.32886);
      klass = startklass;
      D.32903 = reftype->type;
      refklass = mono_class_from_mono_type (D.32903);
      System_Reflection_ConstructorInfo.242 = System_Reflection_ConstructorInfo;
      if (System_Reflection_ConstructorInfo.242 == 0B) goto <D.32905>; else goto <D.32906>;
      <D.32905>:
      D.32907 = mono_defaults.corlib;
      System_Reflection_ConstructorInfo.243 = mono_class_from_name (D.32907, "System.Reflection", "ConstructorInfo");
      System_Reflection_ConstructorInfo = System_Reflection_ConstructorInfo.243;
      <D.32906>:
      iter = 0B;
      goto <D.24506>;
      <D.24508>:
      match = 0;
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 5;
        if (__s2_len <= 3) goto <D.32910>; else goto <D.32911>;
        <D.32910>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = method->name;
          D.32912 = ".ctor";
          D.32913 = MEM[(const unsigned char *)D.32912];
          D.32914 = (int) D.32913;
          D.32915 = *__s2;
          D.32916 = (int) D.32915;
          __result = D.32914 - D.32916;
          {
            D.32917 = __s2_len != 0;
            D.32918 = __result == 0;
            D.32919 = D.32917 & D.32918;
            if (D.32919 != 0) goto <D.32920>; else goto <D.32921>;
            <D.32920>:
            D.32922 = &MEM[(void *)".ctor" + 1B];
            D.32923 = *D.32922;
            D.32924 = (int) D.32923;
            D.32925 = __s2 + 1;
            D.32926 = *D.32925;
            D.32927 = (int) D.32926;
            __result = D.32924 - D.32927;
            D.32928 = __s2_len > 1;
            D.32918 = __result == 0;
            D.32929 = D.32928 & D.32918;
            if (D.32929 != 0) goto <D.32930>; else goto <D.32931>;
            <D.32930>:
            D.32932 = &MEM[(void *)".ctor" + 2B];
            D.32933 = *D.32932;
            D.32934 = (int) D.32933;
            D.32935 = __s2 + 2;
            D.32936 = *D.32935;
            D.32937 = (int) D.32936;
            __result = D.32934 - D.32937;
            D.32938 = __s2_len > 2;
            D.32918 = __result == 0;
            D.32939 = D.32938 & D.32918;
            if (D.32939 != 0) goto <D.32940>; else goto <D.32941>;
            <D.32940>:
            D.32942 = &MEM[(void *)".ctor" + 3B];
            D.32943 = *D.32942;
            D.32944 = (int) D.32943;
            D.32945 = __s2 + 3;
            D.32946 = *D.32945;
            D.32947 = (int) D.32946;
            __result = D.32944 - D.32947;
            <D.32941>:
            <D.32931>:
            <D.32921>:
          }
          D.24495 = __result;
        }
        iftmp.244 = -D.24495;
        goto <D.32948>;
        <D.32911>:
        D.32949 = method->name;
        iftmp.244 = __builtin_strcmp (D.32949, ".ctor");
        <D.32948>:
        D.24496 = iftmp.244;
      }
      if (D.24496 != 0) goto <D.32950>; else goto <D.32951>;
      <D.32950>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 6;
        if (__s2_len <= 3) goto <D.32953>; else goto <D.32954>;
        <D.32953>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = method->name;
          D.32955 = ".cctor";
          D.32956 = MEM[(const unsigned char *)D.32955];
          D.32957 = (int) D.32956;
          D.32958 = *__s2;
          D.32959 = (int) D.32958;
          __result = D.32957 - D.32959;
          {
            D.32960 = __s2_len != 0;
            D.32961 = __result == 0;
            D.32962 = D.32960 & D.32961;
            if (D.32962 != 0) goto <D.32963>; else goto <D.32964>;
            <D.32963>:
            D.32965 = &MEM[(void *)".cctor" + 1B];
            D.32966 = *D.32965;
            D.32967 = (int) D.32966;
            D.32968 = __s2 + 1;
            D.32969 = *D.32968;
            D.32970 = (int) D.32969;
            __result = D.32967 - D.32970;
            D.32971 = __s2_len > 1;
            D.32961 = __result == 0;
            D.32972 = D.32971 & D.32961;
            if (D.32972 != 0) goto <D.32973>; else goto <D.32974>;
            <D.32973>:
            D.32975 = &MEM[(void *)".cctor" + 2B];
            D.32976 = *D.32975;
            D.32977 = (int) D.32976;
            D.32978 = __s2 + 2;
            D.32979 = *D.32978;
            D.32980 = (int) D.32979;
            __result = D.32977 - D.32980;
            D.32981 = __s2_len > 2;
            D.32961 = __result == 0;
            D.32982 = D.32981 & D.32961;
            if (D.32982 != 0) goto <D.32983>; else goto <D.32984>;
            <D.32983>:
            D.32985 = &MEM[(void *)".cctor" + 3B];
            D.32986 = *D.32985;
            D.32987 = (int) D.32986;
            D.32988 = __s2 + 3;
            D.32989 = *D.32988;
            D.32990 = (int) D.32989;
            __result = D.32987 - D.32990;
            <D.32984>:
            <D.32974>:
            <D.32964>:
          }
          D.24504 = __result;
        }
        iftmp.245 = -D.24504;
        goto <D.32991>;
        <D.32954>:
        D.32949 = method->name;
        iftmp.245 = __builtin_strcmp (D.32949, ".cctor");
        <D.32991>:
        D.24505 = iftmp.245;
      }
      if (D.24505 != 0) goto <D.32992>; else goto <D.32993>;
      <D.32992>:
      // predicted unlikely by continue predictor.
      goto <D.24506>;
      <D.32993>:
      <D.32951>:
      D.32994 = method->flags;
      D.32995 = (int) D.32994;
      D.32996 = D.32995 & 7;
      if (D.32996 == 6) goto <D.32997>; else goto <D.32998>;
      <D.32997>:
      D.32999 = bflags & 16;
      if (D.32999 != 0) goto <D.33000>; else goto <D.33001>;
      <D.33000>:
      match = match + 1;
      <D.33001>:
      goto <D.33002>;
      <D.32998>:
      D.33003 = bflags & 32;
      if (D.33003 != 0) goto <D.33004>; else goto <D.33005>;
      <D.33004>:
      match = match + 1;
      <D.33005>:
      <D.33002>:
      if (match == 0) goto <D.33006>; else goto <D.33007>;
      <D.33006>:
      // predicted unlikely by continue predictor.
      goto <D.24506>;
      <D.33007>:
      match = 0;
      D.32994 = method->flags;
      D.32995 = (int) D.32994;
      D.33008 = D.32995 & 16;
      if (D.33008 != 0) goto <D.33009>; else goto <D.33010>;
      <D.33009>:
      D.33011 = bflags & 8;
      if (D.33011 != 0) goto <D.33012>; else goto <D.33013>;
      <D.33012>:
      D.33016 = bflags & 64;
      if (D.33016 != 0) goto <D.33014>; else goto <D.33017>;
      <D.33017>:
      if (klass == startklass) goto <D.33014>; else goto <D.33015>;
      <D.33014>:
      match = match + 1;
      <D.33015>:
      <D.33013>:
      goto <D.33018>;
      <D.33010>:
      D.33019 = bflags & 4;
      if (D.33019 != 0) goto <D.33020>; else goto <D.33021>;
      <D.33020>:
      match = match + 1;
      <D.33021>:
      <D.33018>:
      if (match == 0) goto <D.33022>; else goto <D.33023>;
      <D.33022>:
      // predicted unlikely by continue predictor.
      goto <D.24506>;
      <D.33023>:
      member = mono_method_get_object (domain, method, refklass);
      D.33024 = tmp_array.size;
      D.33025 = tmp_array.capacity;
      if (D.33024 >= D.33025) goto <D.33026>; else goto <D.33027>;
      <D.33026>:
      {
        void * __tmp;

        D.33025 = tmp_array.capacity;
        D.33028 = (unsigned int) D.33025;
        D.33029 = D.33028 * 8;
        D.33025 = tmp_array.capacity;
        D.33030 = D.33025 * 2;
        D.33031 = mono_gc_make_root_descr_all_refs (D.33030);
        __tmp = mono_gc_alloc_fixed (D.33029, D.33031);
        D.33032 = tmp_array.data;
        D.33025 = tmp_array.capacity;
        D.33028 = (unsigned int) D.33025;
        D.33033 = D.33028 * 4;
        mono_gc_memmove_aligned (__tmp, D.33032, D.33033);
        D.33025 = tmp_array.capacity;
        if (D.33025 > 16) goto <D.33034>; else goto <D.33035>;
        <D.33034>:
        D.33032 = tmp_array.data;
        mono_gc_free_fixed (D.33032);
        <D.33035>:
        tmp_array.data = __tmp;
        D.33025 = tmp_array.capacity;
        D.33030 = D.33025 * 2;
        tmp_array.capacity = D.33030;
      }
      <D.33027>:
      D.33032 = tmp_array.data;
      D.33024 = tmp_array.size;
      D.33036 = D.33024;
      D.33037 = D.33036 + 1;
      tmp_array.size = D.33037;
      D.33038 = (unsigned int) D.33036;
      D.33039 = D.33038 * 4;
      D.33040 = D.33032 + D.33039;
      *D.33040 = member;
      <D.24506>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.24508>; else goto <D.24509>;
      <D.24509>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.246 = tmp_klass;
          if (tmp_klass.246 == 0B) goto <D.33042>; else goto <D.33043>;
          <D.33042>:
          System_Reflection_ConstructorInfo.242 = System_Reflection_ConstructorInfo;
          tmp_klass.247 = mono_array_class_get (System_Reflection_ConstructorInfo.242, 1);
          tmp_klass = tmp_klass.247;
          tmp_klass.246 = tmp_klass;
          D.33045 = tmp_klass.246 == 0B;
          D.33046 = (long int) D.33045;
          D.33047 = __builtin_expect (D.33046, 0);
          if (D.33047 != 0) goto <D.33048>; else goto <D.33049>;
          <D.33048>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3656, "tmp_klass");
          <D.33049>:
          <D.33043>:
        }
        D.24511 = tmp_klass;
      }
      D.33050 = mono_class_vtable (domain, D.24511);
      D.33024 = tmp_array.size;
      D.33051 = (unsigned int) D.33024;
      res = mono_array_new_specific (D.33050, D.33051);
      i = 0;
      goto <D.24514>;
      <D.24513>:
      {
        void * * __p;

        i.248 = (unsigned int) i;
        __p = mono_array_addr_with_size (res, 4, i.248);
        D.33032 = tmp_array.data;
        i.249 = (unsigned int) i;
        D.33054 = i.249 * 4;
        D.33055 = D.33032 + D.33054;
        D.33056 = *D.33055;
        mono_gc_wbarrier_set_arrayref (res, __p, D.33056);
      }
      i = i + 1;
      <D.24514>:
      D.33024 = tmp_array.size;
      if (D.33024 > i) goto <D.24513>; else goto <D.24515>;
      <D.24515>:
      D.33025 = tmp_array.capacity;
      if (D.33025 > 16) goto <D.33057>; else goto <D.33058>;
      <D.33057>:
      D.33032 = tmp_array.data;
      mono_gc_free_fixed (D.33032);
      <D.33058>:
      D.32891 = res;
      return D.32891;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_MonoType_GetArrayRank (struct MonoReflectionType * type)
{
  struct MonoType * D.33061;
  unsigned char D.33062;
  _Bool D.33063;
  _Bool D.33064;
  _Bool D.33065;
  struct MonoException * D.33068;
  gint32 D.33069;
  unsigned char D.33070;
  struct MonoClass * class;

  D.33061 = type->type;
  D.33062 = D.33061->type;
  D.33063 = D.33062 != 20;
  D.33064 = D.33062 != 29;
  D.33065 = D.33063 & D.33064;
  if (D.33065 != 0) goto <D.33066>; else goto <D.33067>;
  <D.33066>:
  D.33068 = mono_get_exception_argument ("type", "Type must be an array type");
  mono_raise_exception (D.33068);
  <D.33067>:
  D.33061 = type->type;
  class = mono_class_from_mono_type (D.33061);
  D.33070 = class->rank;
  D.33069 = (gint32) D.33070;
  return D.33069;
}


ves_icall_get_enum_info (struct MonoReflectionType * type, struct MonoEnumInfo * info)
{
  struct MonoVTable * D.33072;
  struct MonoType * D.33073;
  struct MonoReflectionType * * D.33074;
  struct MonoType * D.33075;
  struct MonoReflectionType * D.33076;
  guint iftmp.250;
  int D.33078;
  int D.33081;
  int D.33082;
  struct MonoArray * * D.33084;
  struct MonoClass * D.33085;
  struct MonoArray * D.33086;
  struct MonoArray * * D.33087;
  struct MonoArray * D.33088;
  struct MonoType * D.33089;
  short unsigned int D.33090;
  int D.33091;
  int D.33092;
  int D.24274;
  int iftmp.251;
  int D.24270;
  const char[8] * D.33098;
  unsigned char D.33099;
  int D.33100;
  unsigned char D.33101;
  int D.33102;
  _Bool D.33103;
  _Bool D.33104;
  _Bool D.33105;
  const unsigned char * D.33108;
  unsigned char D.33109;
  int D.33110;
  const unsigned char * D.33111;
  unsigned char D.33112;
  int D.33113;
  _Bool D.33114;
  _Bool D.33115;
  const unsigned char * D.33118;
  unsigned char D.33119;
  int D.33120;
  const unsigned char * D.33121;
  unsigned char D.33122;
  int D.33123;
  _Bool D.33124;
  _Bool D.33125;
  const unsigned char * D.33128;
  unsigned char D.33129;
  int D.33130;
  const unsigned char * D.33131;
  unsigned char D.33132;
  int D.33133;
  const char * D.33135;
  int D.33138;
  int D.24283;
  int iftmp.252;
  int D.24282;
  const char[9] * D.33144;
  unsigned char D.33145;
  int D.33146;
  unsigned char D.33147;
  int D.33148;
  _Bool D.33149;
  _Bool D.33150;
  _Bool D.33151;
  const unsigned char * D.33154;
  unsigned char D.33155;
  int D.33156;
  const unsigned char * D.33157;
  unsigned char D.33158;
  int D.33159;
  _Bool D.33160;
  _Bool D.33161;
  const unsigned char * D.33164;
  unsigned char D.33165;
  int D.33166;
  const unsigned char * D.33167;
  unsigned char D.33168;
  int D.33169;
  _Bool D.33170;
  _Bool D.33171;
  const unsigned char * D.33174;
  unsigned char D.33175;
  int D.33176;
  const unsigned char * D.33177;
  unsigned char D.33178;
  int D.33179;
  const char * D.33181;
  struct MonoArray * D.33184;
  const char * D.33185;
  struct MonoString * D.33186;
  const char * p.253;
  const char * p.254;
  unsigned int D.33189;
  struct MonoType * D.33190;
  unsigned char D.33191;
  int D.33192;
  struct MonoArray * D.33193;
  char D.33194;
  short unsigned int D.33195;
  short int D.33196;
  unsigned int D.33197;
  int D.33198;
  long long unsigned int D.33199;
  long long int D.33200;
  struct MonoType * D.33201;
  unsigned char D.33202;
  int D.33203;
  struct MonoDomain * domain;
  struct MonoClass * enumc;
  guint j;
  guint nvalues;
  guint crow;
  void * iter;
  struct MonoClassField * field;

  try
    {
      D.33072 = MEM[(struct MonoObject *)type].vtable;
      domain = D.33072->domain;
      D.33073 = type->type;
      enumc = mono_class_from_mono_type (D.33073);
      j = 0;
      mono_class_init_or_throw (enumc);
      D.33074 = &info->utype;
      D.33075 = mono_class_enum_basetype (enumc);
      D.33076 = mono_type_get_object (domain, D.33075);
      mono_gc_wbarrier_generic_store (D.33074, D.33076);
      D.33078 = mono_class_num_fields (enumc);
      if (D.33078 != 0) goto <D.33079>; else goto <D.33080>;
      <D.33079>:
      D.33081 = mono_class_num_fields (enumc);
      D.33082 = D.33081 + -1;
      iftmp.250 = (guint) D.33082;
      goto <D.33083>;
      <D.33080>:
      iftmp.250 = 0;
      <D.33083>:
      nvalues = iftmp.250;
      D.33084 = &info->names;
      D.33085 = mono_defaults.string_class;
      D.33086 = mono_array_new (domain, D.33085, nvalues);
      mono_gc_wbarrier_generic_store (D.33084, D.33086);
      D.33087 = &info->values;
      D.33088 = mono_array_new (domain, enumc, nvalues);
      mono_gc_wbarrier_generic_store (D.33087, D.33088);
      crow = 4294967295;
      iter = 0B;
      goto <D.24265>;
      <D.24301>:
      {
        const char * p;
        int len;
        MonoTypeEnum def_type;

        try
          {
            D.33089 = field->type;
            D.33090 = D.33089->attrs;
            D.33091 = (int) D.33090;
            D.33092 = D.33091 & 16;
            if (D.33092 == 0) goto <D.33093>; else goto <D.33094>;
            <D.33093>:
            // predicted unlikely by continue predictor.
            goto <D.24265>;
            <D.33094>:
            {
              size_t __s1_len;
              size_t __s2_len;

              __s1_len = 7;
              if (__s1_len <= 3) goto <D.33096>; else goto <D.33097>;
              <D.33096>:
              {
                const unsigned char * __s2;
                int __result;

                __s2 = mono_field_get_name (field);
                D.33098 = "value__";
                D.33099 = MEM[(const unsigned char *)D.33098];
                D.33100 = (int) D.33099;
                D.33101 = *__s2;
                D.33102 = (int) D.33101;
                __result = D.33100 - D.33102;
                {
                  D.33103 = __s1_len != 0;
                  D.33104 = __result == 0;
                  D.33105 = D.33103 & D.33104;
                  if (D.33105 != 0) goto <D.33106>; else goto <D.33107>;
                  <D.33106>:
                  D.33108 = &MEM[(void *)"value__" + 1B];
                  D.33109 = *D.33108;
                  D.33110 = (int) D.33109;
                  D.33111 = __s2 + 1;
                  D.33112 = *D.33111;
                  D.33113 = (int) D.33112;
                  __result = D.33110 - D.33113;
                  D.33114 = __s1_len > 1;
                  D.33104 = __result == 0;
                  D.33115 = D.33114 & D.33104;
                  if (D.33115 != 0) goto <D.33116>; else goto <D.33117>;
                  <D.33116>:
                  D.33118 = &MEM[(void *)"value__" + 2B];
                  D.33119 = *D.33118;
                  D.33120 = (int) D.33119;
                  D.33121 = __s2 + 2;
                  D.33122 = *D.33121;
                  D.33123 = (int) D.33122;
                  __result = D.33120 - D.33123;
                  D.33124 = __s1_len > 2;
                  D.33104 = __result == 0;
                  D.33125 = D.33124 & D.33104;
                  if (D.33125 != 0) goto <D.33126>; else goto <D.33127>;
                  <D.33126>:
                  D.33128 = &MEM[(void *)"value__" + 3B];
                  D.33129 = *D.33128;
                  D.33130 = (int) D.33129;
                  D.33131 = __s2 + 3;
                  D.33132 = *D.33131;
                  D.33133 = (int) D.33132;
                  __result = D.33130 - D.33133;
                  <D.33127>:
                  <D.33117>:
                  <D.33107>:
                }
                D.24270 = __result;
              }
              iftmp.251 = D.24270;
              goto <D.33134>;
              <D.33097>:
              D.33135 = mono_field_get_name (field);
              iftmp.251 = __builtin_strcmp ("value__", D.33135);
              <D.33134>:
              D.24274 = iftmp.251;
            }
            if (D.24274 == 0) goto <D.33136>; else goto <D.33137>;
            <D.33136>:
            // predicted unlikely by continue predictor.
            goto <D.24265>;
            <D.33137>:
            D.33089 = field->type;
            D.33090 = D.33089->attrs;
            D.33091 = (int) D.33090;
            D.33138 = D.33091 & 1536;
            if (D.33138 != 0) goto <D.33139>; else goto <D.33140>;
            <D.33139>:
            {
              size_t __s1_len;
              size_t __s2_len;

              __s2_len = 8;
              if (__s2_len <= 3) goto <D.33142>; else goto <D.33143>;
              <D.33142>:
              {
                const unsigned char * __s2;
                int __result;

                __s2 = mono_field_get_name (field);
                D.33144 = "_Deleted";
                D.33145 = MEM[(const unsigned char *)D.33144];
                D.33146 = (int) D.33145;
                D.33147 = *__s2;
                D.33148 = (int) D.33147;
                __result = D.33146 - D.33148;
                {
                  D.33149 = __s2_len != 0;
                  D.33150 = __result == 0;
                  D.33151 = D.33149 & D.33150;
                  if (D.33151 != 0) goto <D.33152>; else goto <D.33153>;
                  <D.33152>:
                  D.33154 = &MEM[(void *)"_Deleted" + 1B];
                  D.33155 = *D.33154;
                  D.33156 = (int) D.33155;
                  D.33157 = __s2 + 1;
                  D.33158 = *D.33157;
                  D.33159 = (int) D.33158;
                  __result = D.33156 - D.33159;
                  D.33160 = __s2_len > 1;
                  D.33150 = __result == 0;
                  D.33161 = D.33160 & D.33150;
                  if (D.33161 != 0) goto <D.33162>; else goto <D.33163>;
                  <D.33162>:
                  D.33164 = &MEM[(void *)"_Deleted" + 2B];
                  D.33165 = *D.33164;
                  D.33166 = (int) D.33165;
                  D.33167 = __s2 + 2;
                  D.33168 = *D.33167;
                  D.33169 = (int) D.33168;
                  __result = D.33166 - D.33169;
                  D.33170 = __s2_len > 2;
                  D.33150 = __result == 0;
                  D.33171 = D.33170 & D.33150;
                  if (D.33171 != 0) goto <D.33172>; else goto <D.33173>;
                  <D.33172>:
                  D.33174 = &MEM[(void *)"_Deleted" + 3B];
                  D.33175 = *D.33174;
                  D.33176 = (int) D.33175;
                  D.33177 = __s2 + 3;
                  D.33178 = *D.33177;
                  D.33179 = (int) D.33178;
                  __result = D.33176 - D.33179;
                  <D.33173>:
                  <D.33163>:
                  <D.33153>:
                }
                D.24282 = __result;
              }
              iftmp.252 = -D.24282;
              goto <D.33180>;
              <D.33143>:
              D.33181 = mono_field_get_name (field);
              iftmp.252 = __builtin_strcmp (D.33181, "_Deleted");
              <D.33180>:
              D.24283 = iftmp.252;
            }
            if (D.24283 == 0) goto <D.33182>; else goto <D.33183>;
            <D.33182>:
            // predicted unlikely by continue predictor.
            goto <D.24265>;
            <D.33183>:
            <D.33140>:
            {
              void * * __p;

              D.33184 = info->names;
              __p = mono_array_addr_with_size (D.33184, 4, j);
              D.33184 = info->names;
              D.33185 = mono_field_get_name (field);
              D.33186 = mono_string_new (domain, D.33185);
              mono_gc_wbarrier_set_arrayref (D.33184, __p, D.33186);
            }
            p.253 = mono_class_get_field_default_value (field, &def_type);
            p = p.253;
            p.254 = p;
            D.33189 = mono_metadata_decode_blob_size (p.254, &p);
            len = (int) D.33189;
            D.33190 = mono_class_enum_basetype (enumc);
            D.33191 = D.33190->type;
            D.33192 = (int) D.33191;
            switch (D.33192) <default: <D.24299>, case 3: <D.24289>, case 4: <D.24286>, case 5: <D.24285>, case 6: <D.24291>, case 7: <D.24290>, case 8: <D.24294>, case 9: <D.24293>, case 10: <D.24297>, case 11: <D.24296>>
            <D.24285>:
            <D.24286>:
            {
              gchar * __p;

              D.33193 = info->values;
              __p = mono_array_addr_with_size (D.33193, 1, j);
              p.254 = p;
              D.33194 = *p.254;
              *__p = D.33194;
            }
            goto <D.24288>;
            <D.24289>:
            <D.24290>:
            <D.24291>:
            {
              gint16 * __p;

              D.33193 = info->values;
              __p = mono_array_addr_with_size (D.33193, 2, j);
              p.254 = p;
              D.33195 = mono_read16 (p.254);
              D.33196 = (short int) D.33195;
              *__p = D.33196;
            }
            goto <D.24288>;
            <D.24293>:
            <D.24294>:
            {
              gint32 * __p;

              D.33193 = info->values;
              __p = mono_array_addr_with_size (D.33193, 4, j);
              p.254 = p;
              D.33197 = mono_read32 (p.254);
              D.33198 = (int) D.33197;
              *__p = D.33198;
            }
            goto <D.24288>;
            <D.24296>:
            <D.24297>:
            {
              gint64 * __p;

              D.33193 = info->values;
              __p = mono_array_addr_with_size (D.33193, 8, j);
              p.254 = p;
              D.33199 = mono_read64 (p.254);
              D.33200 = (long long int) D.33199;
              *__p = D.33200;
            }
            goto <D.24288>;
            <D.24299>:
            D.33201 = mono_class_enum_basetype (enumc);
            D.33202 = D.33201->type;
            D.33203 = (int) D.33202;
            monoeg_g_log (0B, 4, "Implement type 0x%02x in get_enum_info", D.33203);
            <D.24300>:
            goto <D.24300>;
            <D.24288>:
            j = j + 1;
          }
        finally
          {
            p = {CLOBBER};
            def_type = {CLOBBER};
          }
      }
      <D.24265>:
      field = mono_class_get_fields (enumc, &iter);
      if (field != 0B) goto <D.24301>; else goto <D.24302>;
      <D.24302>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


custom_attrs_defined_internal (struct MonoObject * obj, struct MonoReflectionType * attr_type)
{
  struct MonoType * D.33206;
  MonoBoolean D.33209;
  int D.33210;
  struct MonoClass * attr_class;
  struct MonoCustomAttrInfo * cinfo;
  gboolean found;

  D.33206 = attr_type->type;
  attr_class = mono_class_from_mono_type (D.33206);
  mono_class_init_or_throw (attr_class);
  cinfo = mono_reflection_get_custom_attrs_info (obj);
  if (cinfo == 0B) goto <D.33207>; else goto <D.33208>;
  <D.33207>:
  D.33209 = 0;
  return D.33209;
  <D.33208>:
  found = mono_custom_attrs_has_attr (cinfo, attr_class);
  D.33210 = cinfo->cached;
  if (D.33210 == 0) goto <D.33211>; else goto <D.33212>;
  <D.33211>:
  mono_custom_attrs_free (cinfo);
  <D.33212>:
  D.33209 = (MonoBoolean) found;
  return D.33209;
}


custom_attrs_get_by_type (struct MonoObject * obj, struct MonoReflectionType * attr_type)
{
  struct MonoClass * iftmp.255;
  struct MonoType * D.33217;
  int D.33221;
  struct MonoLoaderError * D.33224;
  struct MonoLoaderError * D.33227;
  struct MonoException * D.33228;
  struct MonoArray * D.33229;
  struct MonoClass * attr_class;
  struct MonoArray * res;
  struct MonoError error;

  try
    {
      if (attr_type != 0B) goto <D.33215>; else goto <D.33216>;
      <D.33215>:
      D.33217 = attr_type->type;
      iftmp.255 = mono_class_from_mono_type (D.33217);
      goto <D.33218>;
      <D.33216>:
      iftmp.255 = 0B;
      <D.33218>:
      attr_class = iftmp.255;
      if (attr_class != 0B) goto <D.33219>; else goto <D.33220>;
      <D.33219>:
      mono_class_init_or_throw (attr_class);
      <D.33220>:
      res = mono_reflection_get_custom_attrs_by_type (obj, attr_class, &error);
      D.33221 = mono_error_ok (&error);
      if (D.33221 == 0) goto <D.33222>; else goto <D.33223>;
      <D.33222>:
      mono_error_raise_exception (&error);
      <D.33223>:
      D.33224 = mono_loader_get_last_error ();
      if (D.33224 != 0B) goto <D.33225>; else goto <D.33226>;
      <D.33225>:
      D.33227 = mono_loader_get_last_error ();
      D.33228 = mono_loader_error_prepare_exception (D.33227);
      mono_raise_exception (D.33228);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 7569);
      D.33229 = 0B;
      return D.33229;
      <D.33226>:
      D.33229 = res;
      return D.33229;
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_System_IO_get_temp_path ()
{
  struct MonoString * D.33232;
  struct MonoDomain * D.33233;
  const gchar * D.33234;

  D.33233 = mono_domain_get ();
  D.33234 = monoeg_g_get_tmp_dir ();
  D.33232 = mono_string_new (D.33233, D.33234);
  return D.33232;
}


ves_icall_System_IO_DriveInfo_GetDriveType (struct MonoString * root_path_name)
{
  guint32 D.33236;
  mono_unichar2 * D.33237;

  D.33237 = mono_string_chars (root_path_name);
  D.33236 = GetDriveType (D.33237);
  return D.33236;
}


ves_icall_System_IO_DriveInfo_GetDriveFormat (struct MonoString * path)
{
  mono_unichar2 * D.33239;
  int D.33240;
  struct MonoString * D.33243;
  gunichar2 volume_name[261];

  try
    {
      D.33239 = mono_string_chars (path);
      D.33240 = GetVolumeInformation (D.33239, 0B, 0, 0B, 0B, 0B, &volume_name, 261);
      if (D.33240 == 0) goto <D.33241>; else goto <D.33242>;
      <D.33241>:
      D.33243 = 0B;
      return D.33243;
      <D.33242>:
      D.33243 = mono_string_from_utf16 (&volume_name);
      return D.33243;
    }
  finally
    {
      volume_name = {CLOBBER};
    }
}


ves_icall_System_IO_DriveInfo_GetDiskFreeSpace (struct MonoString * path_name, guint64 * free_bytes_avail, guint64 * total_number_of_bytes, guint64 * total_number_of_free_bytes, gint32 * error)
{
  mono_unichar2 * D.33246;
  long long unsigned int D.33249;
  long long unsigned int D.33250;
  long long unsigned int D.33251;
  unsigned int D.33253;
  int D.33254;
  MonoBoolean D.33255;
  gboolean result;
  union ULARGE_INTEGER wapi_free_bytes_avail;
  union ULARGE_INTEGER wapi_total_number_of_bytes;
  union ULARGE_INTEGER wapi_total_number_of_free_bytes;

  try
    {
      *error = 0;
      D.33246 = mono_string_chars (path_name);
      result = GetDiskFreeSpaceEx (D.33246, &wapi_free_bytes_avail, &wapi_total_number_of_bytes, &wapi_total_number_of_free_bytes);
      if (result != 0) goto <D.33247>; else goto <D.33248>;
      <D.33247>:
      D.33249 = wapi_free_bytes_avail.QuadPart;
      *free_bytes_avail = D.33249;
      D.33250 = wapi_total_number_of_bytes.QuadPart;
      *total_number_of_bytes = D.33250;
      D.33251 = wapi_total_number_of_free_bytes.QuadPart;
      *total_number_of_free_bytes = D.33251;
      goto <D.33252>;
      <D.33248>:
      *free_bytes_avail = 0;
      *total_number_of_bytes = 0;
      *total_number_of_free_bytes = 0;
      D.33253 = GetLastError ();
      D.33254 = (int) D.33253;
      *error = D.33254;
      <D.33252>:
      D.33255 = (MonoBoolean) result;
      return D.33255;
    }
  finally
    {
      wapi_free_bytes_avail = {CLOBBER};
      wapi_total_number_of_bytes = {CLOBBER};
      wapi_total_number_of_free_bytes = {CLOBBER};
    }
}


ves_icall_System_Environment_InternalGetHome ()
{
  struct MonoString * D.33258;
  struct MonoDomain * D.33259;
  const gchar * D.33260;

  D.33259 = mono_domain_get ();
  D.33260 = monoeg_g_get_home_dir ();
  D.33258 = mono_string_new (D.33259, D.33260);
  return D.33258;
}


ves_icall_System_Environment_GetGacPath ()
{
  struct MonoString * D.33262;
  struct MonoDomain * D.33263;
  const char * D.33264;

  D.33263 = mono_domain_get ();
  D.33264 = mono_assembly_getrootdir ();
  D.33262 = mono_string_new (D.33263, D.33264);
  return D.33262;
}


ves_icall_System_Environment_GetEnvironmentVariable (struct MonoString * name)
{
  struct MonoString * D.33268;
  struct MonoDomain * D.33271;
  const gchar * value;
  gchar * utf8_name;

  if (name == 0B) goto <D.33266>; else goto <D.33267>;
  <D.33266>:
  D.33268 = 0B;
  return D.33268;
  <D.33267>:
  utf8_name = mono_string_to_utf8 (name);
  value = monoeg_g_getenv (utf8_name);
  monoeg_g_free (utf8_name);
  if (value == 0B) goto <D.33269>; else goto <D.33270>;
  <D.33269>:
  D.33268 = 0B;
  return D.33268;
  <D.33270>:
  D.33271 = mono_domain_get ();
  D.33268 = mono_string_new (D.33271, value);
  return D.33268;
}


ves_icall_System_Environment_BroadcastSettingChange ()
{

}


ves_icall_System_Environment_get_Platform ()
{
  int D.33273;

  D.33273 = 4;
  return D.33273;
}


ves_icall_System_Environment_get_MachineName ()
{
  int D.33275;
  struct MonoDomain * D.33278;
  struct MonoString * D.33280;
  gchar buf[256];
  struct MonoString * result;

  try
    {
      D.33275 = gethostname (&buf, 256);
      if (D.33275 == 0) goto <D.33276>; else goto <D.33277>;
      <D.33276>:
      D.33278 = mono_domain_get ();
      result = mono_string_new (D.33278, &buf);
      goto <D.33279>;
      <D.33277>:
      result = 0B;
      <D.33279>:
      D.33280 = result;
      return D.33280;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


gethostname (char * __buf, size_t __buflen)
{
  unsigned int D.33283;
  int D.33286;
  int D.33289;
  unsigned int D.33290;
  unsigned int D.33291;
  unsigned int D.33294;

  D.33283 = __builtin_object_size (__buf, 1);
  if (D.33283 != 4294967295) goto <D.33284>; else goto <D.33285>;
  <D.33284>:
  D.33286 = __builtin_constant_p (__buflen);
  if (D.33286 == 0) goto <D.33287>; else goto <D.33288>;
  <D.33287>:
  D.33290 = __builtin_object_size (__buf, 1);
  D.33289 = __gethostname_chk (__buf, __buflen, D.33290);
  return D.33289;
  <D.33288>:
  D.33291 = __builtin_object_size (__buf, 1);
  if (D.33291 < __buflen) goto <D.33292>; else goto <D.33293>;
  <D.33292>:
  D.33294 = __builtin_object_size (__buf, 1);
  D.33289 = __gethostname_chk_warn (__buf, __buflen, D.33294);
  return D.33289;
  <D.33293>:
  <D.33285>:
  D.33289 = __gethostname_alias (__buf, __buflen);
  return D.33289;
}


ves_icall_System_Environment_get_HasShutdownStarted ()
{
  int D.33296;
  MonoBoolean D.33299;
  struct MonoDomain * D.33300;
  int D.33301;

  D.33296 = mono_runtime_is_shutting_down ();
  if (D.33296 != 0) goto <D.33297>; else goto <D.33298>;
  <D.33297>:
  D.33299 = 1;
  return D.33299;
  <D.33298>:
  D.33300 = mono_domain_get ();
  D.33301 = mono_domain_is_unloading (D.33300);
  if (D.33301 != 0) goto <D.33302>; else goto <D.33303>;
  <D.33302>:
  D.33299 = 1;
  return D.33299;
  <D.33303>:
  D.33299 = 0;
  return D.33299;
}


ves_icall_System_Environment_InternalSetEnvironmentVariable (struct MonoString * name, struct MonoString * value)
{
  int D.33308;
  mono_unichar2 * D.33310;
  short unsigned int D.33311;
  int D.33312;
  struct MonoError error;
  gchar * utf8_name;
  gchar * utf8_value;

  try
    {
      utf8_name = mono_string_to_utf8 (name);
      if (value == 0B) goto <D.33305>; else goto <D.33307>;
      <D.33307>:
      D.33308 = mono_string_length (value);
      if (D.33308 == 0) goto <D.33305>; else goto <D.33309>;
      <D.33309>:
      D.33310 = mono_string_chars (value);
      D.33311 = *D.33310;
      if (D.33311 == 0) goto <D.33305>; else goto <D.33306>;
      <D.33305>:
      monoeg_g_unsetenv (utf8_name);
      monoeg_g_free (utf8_name);
      return;
      <D.33306>:
      utf8_value = mono_string_to_utf8_checked (value, &error);
      D.33312 = mono_error_ok (&error);
      if (D.33312 == 0) goto <D.33313>; else goto <D.33314>;
      <D.33313>:
      monoeg_g_free (utf8_name);
      mono_error_raise_exception (&error);
      <D.33314>:
      monoeg_g_setenv (utf8_name, utf8_value, 1);
      monoeg_g_free (utf8_name);
      monoeg_g_free (utf8_value);
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_System_Environment_GetWindowsFolderPath (int folder)
{
  struct MonoString * D.33318;
  struct MonoDomain * D.33319;

  monoeg_g_log (0B, 16, "ves_icall_System_Environment_GetWindowsFolderPath should only be called on Windows!");
  D.33319 = mono_domain_get ();
  D.33318 = mono_string_new (D.33319, "");
  return D.33318;
}


ves_icall_System_Environment_get_NewLine ()
{
  struct MonoString * D.33321;
  struct MonoDomain * D.33322;

  D.33322 = mono_domain_get ();
  D.33321 = mono_string_new (D.33322, "\n");
  return D.33321;
}


ves_icall_System_Environment_GetLogicalDrives ()
{
  int D.33324;
  unsigned int D.33329;
  unsigned int D.33330;
  gunichar2 * dname.256;
  short unsigned int D.33332;
  short unsigned int D.33333;
  struct MonoClass * D.33334;
  unsigned int ndrives.257;
  short unsigned int D.33336;
  int ndrives.258;
  unsigned int ndrives.259;
  gunichar2 * dname.260;
  short unsigned int D.33340;
  struct MonoArray * D.33343;
  gunichar2 buf[256];
  gunichar2 * ptr;
  gunichar2 * dname;
  gunichar2 * u16;
  guint initial_size;
  guint size;
  gint ndrives;
  struct MonoArray * result;
  struct MonoString * drivestr;
  struct MonoDomain * domain;
  gint len;

  try
    {
      initial_size = 127;
      size = 128;
      domain = mono_domain_get ();
      buf[0] = 0;
      ptr = &buf;
      goto <D.25457>;
      <D.25456>:
      D.33324 = GetLogicalDriveStrings (initial_size, ptr);
      size = (guint) D.33324;
      if (size > initial_size) goto <D.33325>; else goto <D.33326>;
      <D.33325>:
      if (&buf != ptr) goto <D.33327>; else goto <D.33328>;
      <D.33327>:
      monoeg_g_free (ptr);
      <D.33328>:
      D.33329 = size + 1;
      D.33330 = D.33329 * 2;
      ptr = monoeg_malloc0 (D.33330);
      initial_size = size;
      size = size + 1;
      <D.33326>:
      <D.25457>:
      if (size > initial_size) goto <D.25456>; else goto <D.25458>;
      <D.25458>:
      dname = ptr;
      ndrives = 0;
      <D.25462>:
      goto <D.25460>;
      <D.25459>:
      <D.25460>:
      dname.256 = dname;
      dname = dname.256 + 2;
      D.33332 = *dname.256;
      if (D.33332 != 0) goto <D.25459>; else goto <D.25461>;
      <D.25461>:
      ndrives = ndrives + 1;
      D.33333 = *dname;
      if (D.33333 != 0) goto <D.25462>; else goto <D.25463>;
      <D.25463>:
      dname = ptr;
      D.33334 = mono_defaults.string_class;
      ndrives.257 = (unsigned int) ndrives;
      result = mono_array_new (domain, D.33334, ndrives.257);
      ndrives = 0;
      <D.25471>:
      len = 0;
      u16 = dname;
      goto <D.25465>;
      <D.25464>:
      u16 = u16 + 2;
      len = len + 1;
      <D.25465>:
      D.33336 = *u16;
      if (D.33336 != 0) goto <D.25464>; else goto <D.25466>;
      <D.25466>:
      drivestr = mono_string_new_utf16 (domain, dname, len);
      {
        void * * __p;

        ndrives.258 = ndrives;
        ndrives = ndrives.258 + 1;
        ndrives.259 = (unsigned int) ndrives.258;
        __p = mono_array_addr_with_size (result, 4, ndrives.259);
        mono_gc_wbarrier_set_arrayref (result, __p, drivestr);
      }
      goto <D.25469>;
      <D.25468>:
      <D.25469>:
      dname.260 = dname;
      dname = dname.260 + 2;
      D.33340 = *dname.260;
      if (D.33340 != 0) goto <D.25468>; else goto <D.25470>;
      <D.25470>:
      D.33333 = *dname;
      if (D.33333 != 0) goto <D.25471>; else goto <D.25472>;
      <D.25472>:
      if (&buf != ptr) goto <D.33341>; else goto <D.33342>;
      <D.33341>:
      monoeg_g_free (ptr);
      <D.33342>:
      D.33343 = result;
      return D.33343;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


ves_icall_System_Environment_GetEnvironmentVariableNames ()
{
  gchar * D.33346;
  struct MonoClass * D.33347;
  unsigned int n.261;
  gchar * D.33349;
  struct MonoArray * D.33352;
  struct MonoArray * names;
  struct MonoDomain * domain;
  struct MonoString * str;
  gchar * * e;
  gchar * * parts;
  int n;

  n = 0;
  e = environ;
  goto <D.25420>;
  <D.25419>:
  n = n + 1;
  e = e + 4;
  <D.25420>:
  D.33346 = *e;
  if (D.33346 != 0B) goto <D.25419>; else goto <D.25421>;
  <D.25421>:
  domain = mono_domain_get ();
  D.33347 = mono_defaults.string_class;
  n.261 = (unsigned int) n;
  names = mono_array_new (domain, D.33347, n.261);
  n = 0;
  e = environ;
  goto <D.25424>;
  <D.25423>:
  D.33346 = *e;
  parts = monoeg_g_strsplit (D.33346, "=", 2);
  D.33349 = *parts;
  if (D.33349 != 0B) goto <D.33350>; else goto <D.33351>;
  <D.33350>:
  D.33349 = *parts;
  str = mono_string_new (domain, D.33349);
  {
    void * * __p;

    n.261 = (unsigned int) n;
    __p = mono_array_addr_with_size (names, 4, n.261);
    mono_gc_wbarrier_set_arrayref (names, __p, str);
  }
  <D.33351>:
  monoeg_g_strfreev (parts);
  n = n + 1;
  e = e + 4;
  <D.25424>:
  D.33346 = *e;
  if (D.33346 != 0B) goto <D.25423>; else goto <D.25425>;
  <D.25425>:
  D.33352 = names;
  return D.33352;
}


ves_icall_System_Environment_Exit (int result)
{
  int D.33354;

  mono_environment_exitcode_set (result);
  D.33354 = mono_runtime_try_shutdown ();
  if (D.33354 == 0) goto <D.33355>; else goto <D.33356>;
  <D.33355>:
  mono_thread_exit ();
  <D.33356>:
  mono_thread_suspend_all_other_threads ();
  mono_runtime_quit ();
  exit (result);
}


ves_icall_System_Enum_get_value (struct MonoObject * this)
{
  struct MonoObject * D.33359;
  struct MonoVTable * D.33360;
  struct MonoClass * D.33361;
  unsigned char D.33362;
  unsigned char D.33363;
  _Bool D.33364;
  long int D.33365;
  long int D.33366;
  struct MonoType * D.33369;
  struct MonoDomain * D.33370;
  unsigned int size.262;
  struct MonoObject * res;
  struct MonoClass * enumc;
  void * dst;
  void * src;
  int size;

  if (this == 0B) goto <D.33357>; else goto <D.33358>;
  <D.33357>:
  D.33359 = 0B;
  return D.33359;
  <D.33358>:
  D.33360 = this->vtable;
  D.33361 = D.33360->klass;
  D.33362 = BIT_FIELD_REF <*D.33361, 8, 160>;
  D.33363 = D.33362 & 16;
  D.33364 = D.33363 == 0;
  D.33365 = (long int) D.33364;
  D.33366 = __builtin_expect (D.33365, 0);
  if (D.33366 != 0) goto <D.33367>; else goto <D.33368>;
  <D.33367>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3088, "this->vtable->klass->enumtype");
  <D.33368>:
  D.33360 = this->vtable;
  D.33361 = D.33360->klass;
  D.33369 = mono_class_enum_basetype (D.33361);
  enumc = mono_class_from_mono_type (D.33369);
  D.33360 = this->vtable;
  D.33370 = D.33360->domain;
  res = mono_object_new (D.33370, enumc);
  dst = res + 8;
  src = this + 8;
  size = mono_class_value_size (enumc, 0B);
  size.262 = (unsigned int) size;
  memcpy (dst, src, size.262);
  D.33359 = res;
  return D.33359;
}


ves_icall_System_Enum_get_underlying_type (struct MonoReflectionType * type)
{
  struct MonoType * D.33373;
  struct MonoException * D.33376;
  struct MonoReflectionType * D.33377;
  struct MonoVTable * D.33378;
  struct MonoDomain * D.33379;
  struct MonoType * etype;
  struct MonoClass * klass;

  D.33373 = type->type;
  klass = mono_class_from_mono_type (D.33373);
  mono_class_init_or_throw (klass);
  etype = mono_class_enum_basetype (klass);
  if (etype == 0B) goto <D.33374>; else goto <D.33375>;
  <D.33374>:
  D.33376 = mono_get_exception_argument ("Type must be a type provided by the runtime.", "enumType");
  mono_raise_exception (D.33376);
  <D.33375>:
  D.33378 = MEM[(struct MonoObject *)type].vtable;
  D.33379 = D.33378->domain;
  D.33377 = mono_type_get_object (D.33379, etype);
  return D.33377;
}


ves_icall_System_Enum_get_hashcode (struct MonoObject * this)
{
  struct MonoVTable * D.33381;
  struct MonoClass * D.33382;
  _Bool D.33383;
  long int D.33384;
  long int D.33385;
  unsigned char D.33388;
  int D.33389;
  int D.33390;
  signed char D.33391;
  unsigned char D.33392;
  short unsigned int D.33393;
  short int D.33394;
  unsigned int D.33395;
  int D.33396;
  long long int D.33397;
  int D.33398;
  void * data;
  struct MonoType * basetype;

  data = this + 8;
  D.33381 = this->vtable;
  D.33382 = D.33381->klass;
  basetype = mono_class_enum_basetype (D.33382);
  D.33383 = basetype == 0B;
  D.33384 = (long int) D.33383;
  D.33385 = __builtin_expect (D.33384, 0);
  if (D.33385 != 0) goto <D.33386>; else goto <D.33387>;
  <D.33386>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3175, "basetype");
  <D.33387>:
  D.33388 = basetype->type;
  D.33389 = (int) D.33388;
  switch (D.33389) <default: <D.24249>, case 3: <D.24241>, case 4: <D.24239>, case 5: <D.24240>, case 6: <D.24243>, case 7: <D.24242>, case 8: <D.24245>, case 9: <D.24244>, case 10: <D.24247>, case 11: <D.24246>>
  <D.24239>:
  D.33391 = MEM[(gint8 *)data];
  D.33390 = (int) D.33391;
  return D.33390;
  <D.24240>:
  D.33392 = MEM[(guint8 *)data];
  D.33390 = (int) D.33392;
  return D.33390;
  <D.24241>:
  <D.24242>:
  D.33393 = MEM[(guint16 *)data];
  D.33390 = (int) D.33393;
  return D.33390;
  <D.24243>:
  D.33394 = MEM[(gint16 *)data];
  D.33390 = (int) D.33394;
  return D.33390;
  <D.24244>:
  D.33395 = MEM[(guint32 *)data];
  D.33390 = (int) D.33395;
  return D.33390;
  <D.24245>:
  D.33390 = MEM[(gint32 *)data];
  return D.33390;
  <D.24246>:
  <D.24247>:
  {
    gint64 value;

    value = MEM[(gint64 *)data];
    D.33396 = (int) value;
    D.33397 = value >> 32;
    D.33398 = (int) D.33397;
    D.33390 = D.33396 ^ D.33398;
    return D.33390;
  }
  <D.24249>:
  D.33388 = basetype->type;
  D.33389 = (int) D.33388;
  monoeg_g_log (0B, 4, "Implement type 0x%02x in get_hashcode", D.33389);
  <D.24250>:
  goto <D.24250>;
  D.33390 = 0;
  return D.33390;
}


ves_icall_System_Enum_compare_value_to (struct MonoObject * this, struct MonoObject * other)
{
  struct MonoVTable * D.33400;
  struct MonoClass * D.33401;
  _Bool D.33402;
  long int D.33403;
  long int D.33404;
  unsigned char D.33407;
  int D.33408;
  int D.33411;
  int iftmp.263;
  int iftmp.264;
  int D.33424;
  int D.33425;
  int iftmp.265;
  int iftmp.266;
  int iftmp.267;
  int iftmp.268;
  int iftmp.269;
  void * tdata;
  void * odata;
  struct MonoType * basetype;

  tdata = this + 8;
  odata = other + 8;
  D.33400 = this->vtable;
  D.33401 = D.33400->klass;
  basetype = mono_class_enum_basetype (D.33401);
  D.33402 = basetype == 0B;
  D.33403 = (long int) D.33402;
  D.33404 = __builtin_expect (D.33403, 0);
  if (D.33404 != 0) goto <D.33405>; else goto <D.33406>;
  <D.33405>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3126, "basetype");
  <D.33406>:
  D.33407 = basetype->type;
  D.33408 = (int) D.33407;
  switch (D.33408) <default: <D.24232>, case 3: <D.24213>, case 4: <D.24210>, case 5: <D.24207>, case 6: <D.24217>, case 7: <D.24214>, case 8: <D.24223>, case 9: <D.24220>, case 10: <D.24229>, case 11: <D.24226>>
  <D.24207>:
  {
    guint8 me;
    guint8 other;

    me = MEM[(guint8 *)tdata];
    other = MEM[(guint8 *)odata];
    if (me == other) goto <D.33409>; else goto <D.33410>;
    <D.33409>:
    D.33411 = 0;
    return D.33411;
    <D.33410>:
    if (me > other) goto <D.33413>; else goto <D.33414>;
    <D.33413>:
    iftmp.263 = 1;
    goto <D.33415>;
    <D.33414>:
    iftmp.263 = -1;
    <D.33415>:
    D.33411 = iftmp.263;
    return D.33411;
  }
  <D.24210>:
  {
    gint8 me;
    gint8 other;

    me = MEM[(gint8 *)tdata];
    other = MEM[(gint8 *)odata];
    if (me == other) goto <D.33416>; else goto <D.33417>;
    <D.33416>:
    D.33411 = 0;
    return D.33411;
    <D.33417>:
    if (me > other) goto <D.33419>; else goto <D.33420>;
    <D.33419>:
    iftmp.264 = 1;
    goto <D.33421>;
    <D.33420>:
    iftmp.264 = -1;
    <D.33421>:
    D.33411 = iftmp.264;
    return D.33411;
  }
  <D.24213>:
  <D.24214>:
  {
    guint16 me;
    guint16 other;

    me = MEM[(guint16 *)tdata];
    other = MEM[(guint16 *)odata];
    if (me == other) goto <D.33422>; else goto <D.33423>;
    <D.33422>:
    D.33411 = 0;
    return D.33411;
    <D.33423>:
    D.33424 = (int) me;
    D.33425 = (int) other;
    D.33411 = D.33424 - D.33425;
    return D.33411;
  }
  <D.24217>:
  {
    gint16 me;
    gint16 other;

    me = MEM[(gint16 *)tdata];
    other = MEM[(gint16 *)odata];
    if (me == other) goto <D.33426>; else goto <D.33427>;
    <D.33426>:
    D.33411 = 0;
    return D.33411;
    <D.33427>:
    if (me > other) goto <D.33429>; else goto <D.33430>;
    <D.33429>:
    iftmp.265 = 1;
    goto <D.33431>;
    <D.33430>:
    iftmp.265 = -1;
    <D.33431>:
    D.33411 = iftmp.265;
    return D.33411;
  }
  <D.24220>:
  {
    guint32 me;
    guint32 other;

    me = MEM[(guint32 *)tdata];
    other = MEM[(guint32 *)odata];
    if (me == other) goto <D.33432>; else goto <D.33433>;
    <D.33432>:
    D.33411 = 0;
    return D.33411;
    <D.33433>:
    if (me > other) goto <D.33435>; else goto <D.33436>;
    <D.33435>:
    iftmp.266 = 1;
    goto <D.33437>;
    <D.33436>:
    iftmp.266 = -1;
    <D.33437>:
    D.33411 = iftmp.266;
    return D.33411;
  }
  <D.24223>:
  {
    gint32 me;
    gint32 other;

    me = MEM[(gint32 *)tdata];
    other = MEM[(gint32 *)odata];
    if (me == other) goto <D.33438>; else goto <D.33439>;
    <D.33438>:
    D.33411 = 0;
    return D.33411;
    <D.33439>:
    if (me > other) goto <D.33441>; else goto <D.33442>;
    <D.33441>:
    iftmp.267 = 1;
    goto <D.33443>;
    <D.33442>:
    iftmp.267 = -1;
    <D.33443>:
    D.33411 = iftmp.267;
    return D.33411;
  }
  <D.24226>:
  {
    guint64 me;
    guint64 other;

    me = MEM[(guint64 *)tdata];
    other = MEM[(guint64 *)odata];
    if (me == other) goto <D.33444>; else goto <D.33445>;
    <D.33444>:
    D.33411 = 0;
    return D.33411;
    <D.33445>:
    if (me > other) goto <D.33447>; else goto <D.33448>;
    <D.33447>:
    iftmp.268 = 1;
    goto <D.33449>;
    <D.33448>:
    iftmp.268 = -1;
    <D.33449>:
    D.33411 = iftmp.268;
    return D.33411;
  }
  <D.24229>:
  {
    gint64 me;
    gint64 other;

    me = MEM[(gint64 *)tdata];
    other = MEM[(gint64 *)odata];
    if (me == other) goto <D.33450>; else goto <D.33451>;
    <D.33450>:
    D.33411 = 0;
    return D.33411;
    <D.33451>:
    if (me > other) goto <D.33453>; else goto <D.33454>;
    <D.33453>:
    iftmp.269 = 1;
    goto <D.33455>;
    <D.33454>:
    iftmp.269 = -1;
    <D.33455>:
    D.33411 = iftmp.269;
    return D.33411;
  }
  <D.24232>:
  D.33407 = basetype->type;
  D.33408 = (int) D.33407;
  monoeg_g_log (0B, 4, "Implement type 0x%02x in get_hashcode", D.33408);
  <D.24233>:
  goto <D.24233>;
  D.33411 = 0;
  return D.33411;
}


ves_icall_System_Enum_ToObject (struct MonoReflectionType * enumType, struct MonoObject * value)
{
  _Bool D.33457;
  long int D.33458;
  long int D.33459;
  _Bool D.33464;
  long int D.33465;
  long int D.33466;
  struct MonoVTable * D.33471;
  struct MonoType * D.33472;
  struct MonoVTable * D.33473;
  unsigned char D.33474;
  unsigned char D.33475;
  struct MonoException * D.33478;
  unsigned char D.33479;
  unsigned char D.33480;
  unsigned char D.33483;
  unsigned char D.33484;
  struct MonoException * D.33487;
  struct MonoException * D.33490;
  char * D.33491;
  int iftmp.270;
  struct MonoType * D.33495;
  unsigned char D.33496;
  char * D.33498;
  unsigned char D.33499;
  int D.33500;
  struct MonoObject * D.33501;
  struct MonoDomain * domain;
  struct MonoClass * enumc;
  struct MonoClass * objc;
  struct MonoObject * res;
  struct MonoType * etype;
  guint64 val;

  D.33457 = enumType == 0B;
  D.33458 = (long int) D.33457;
  D.33459 = __builtin_expect (D.33458, 0);
  if (D.33459 != 0) goto <D.33460>; else goto <D.33461>;
  <D.33460>:
  {
    struct MonoException * ex;

    if (enumType != 0B) goto <D.33462>; else goto <D.33463>;
    <D.33462>:
    <D.33463>:
    ex = mono_get_exception_argument_null ("enumType");
    mono_raise_exception (ex);
  }
  <D.33461>:
  D.33464 = value == 0B;
  D.33465 = (long int) D.33464;
  D.33466 = __builtin_expect (D.33465, 0);
  if (D.33466 != 0) goto <D.33467>; else goto <D.33468>;
  <D.33467>:
  {
    struct MonoException * ex;

    if (value != 0B) goto <D.33469>; else goto <D.33470>;
    <D.33469>:
    <D.33470>:
    ex = mono_get_exception_argument_null ("value");
    mono_raise_exception (ex);
  }
  <D.33468>:
  D.33471 = MEM[(struct MonoObject *)enumType].vtable;
  domain = D.33471->domain;
  D.33472 = enumType->type;
  enumc = mono_class_from_mono_type (D.33472);
  mono_class_init_or_throw (enumc);
  D.33473 = value->vtable;
  objc = D.33473->klass;
  D.33474 = BIT_FIELD_REF <*enumc, 8, 160>;
  D.33475 = D.33474 & 16;
  if (D.33475 == 0) goto <D.33476>; else goto <D.33477>;
  <D.33476>:
  D.33478 = mono_get_exception_argument ("enumType", "Type provided must be an Enum.");
  mono_raise_exception (D.33478);
  <D.33477>:
  D.33479 = BIT_FIELD_REF <*objc, 8, 160>;
  D.33480 = D.33479 & 16;
  if (D.33480 == 0) goto <D.33481>; else goto <D.33482>;
  <D.33481>:
  D.33483 = objc->byval_arg.type;
  D.33484 = D.33483 + 252;
  if (D.33484 > 7) goto <D.33485>; else goto <D.33486>;
  <D.33485>:
  D.33487 = mono_get_exception_argument ("value", "The value passed in must be an enum base or an underlying type for an enum, such as an Int32.");
  mono_raise_exception (D.33487);
  <D.33486>:
  <D.33482>:
  etype = mono_class_enum_basetype (enumc);
  if (etype == 0B) goto <D.33488>; else goto <D.33489>;
  <D.33488>:
  D.33490 = mono_get_exception_argument ("Type must be a type provided by the runtime.", "enumType");
  mono_raise_exception (D.33490);
  <D.33489>:
  res = mono_object_new (domain, enumc);
  D.33491 = value + 8;
  D.33479 = BIT_FIELD_REF <*objc, 8, 160>;
  D.33480 = D.33479 & 16;
  if (D.33480 != 0) goto <D.33493>; else goto <D.33494>;
  <D.33493>:
  D.33495 = mono_class_enum_basetype (objc);
  D.33496 = D.33495->type;
  iftmp.270 = (int) D.33496;
  goto <D.33497>;
  <D.33494>:
  D.33483 = objc->byval_arg.type;
  iftmp.270 = (int) D.33483;
  <D.33497>:
  val = read_enum_value (D.33491, iftmp.270);
  D.33498 = res + 8;
  D.33499 = etype->type;
  D.33500 = (int) D.33499;
  write_enum_value (D.33498, D.33500, val);
  D.33501 = res;
  return D.33501;
}


read_enum_value (char * mem, int type)
{
  guint64 D.33503;
  unsigned char D.33504;
  signed char D.33505;
  short unsigned int D.33506;
  short int D.33507;
  unsigned int D.33508;
  int D.33509;
  long long int D.33510;

  switch (type) <default: <D.24155>, case 4: <D.24148>, case 5: <D.24147>, case 6: <D.24150>, case 7: <D.24149>, case 8: <D.24152>, case 9: <D.24151>, case 10: <D.24154>, case 11: <D.24153>>
  <D.24147>:
  D.33504 = MEM[(guint8 *)mem];
  D.33503 = (guint64) D.33504;
  return D.33503;
  <D.24148>:
  D.33505 = MEM[(gint8 *)mem];
  D.33503 = (guint64) D.33505;
  return D.33503;
  <D.24149>:
  D.33506 = MEM[(guint16 *)mem];
  D.33503 = (guint64) D.33506;
  return D.33503;
  <D.24150>:
  D.33507 = MEM[(gint16 *)mem];
  D.33503 = (guint64) D.33507;
  return D.33503;
  <D.24151>:
  D.33508 = MEM[(guint32 *)mem];
  D.33503 = (guint64) D.33508;
  return D.33503;
  <D.24152>:
  D.33509 = MEM[(gint32 *)mem];
  D.33503 = (guint64) D.33509;
  return D.33503;
  <D.24153>:
  D.33503 = MEM[(guint64 *)mem];
  return D.33503;
  <D.24154>:
  D.33510 = MEM[(gint64 *)mem];
  D.33503 = (guint64) D.33510;
  return D.33503;
  <D.24155>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 2997);
  D.33503 = 0;
  return D.33503;
}


write_enum_value (char * mem, int type, guint64 value)
{
  unsigned char D.33512;
  short unsigned int D.33513;
  unsigned int D.33514;

  switch (type) <default: <D.24174>, case 4: <D.24162>, case 5: <D.24161>, case 6: <D.24166>, case 7: <D.24165>, case 8: <D.24169>, case 9: <D.24168>, case 10: <D.24172>, case 11: <D.24171>>
  <D.24161>:
  <D.24162>:
  {
    guint8 * p;

    p = mem;
    D.33512 = (unsigned char) value;
    *p = D.33512;
    goto <D.24164>;
  }
  <D.24165>:
  <D.24166>:
  {
    guint16 * p;

    p = mem;
    D.33513 = (short unsigned int) value;
    *p = D.33513;
    goto <D.24164>;
  }
  <D.24168>:
  <D.24169>:
  {
    guint32 * p;

    p = mem;
    D.33514 = (unsigned int) value;
    *p = D.33514;
    goto <D.24164>;
  }
  <D.24171>:
  <D.24172>:
  {
    guint64 * p;

    p = mem;
    *p = value;
    goto <D.24164>;
  }
  <D.24174>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 3031);
  <D.24164>:
  return;
}


mono_double_ParseImpl (char * ptr, double * result)
{
  char D.33516;
  double D.33519;
  gchar * endptr.271;
  char D.33525;
  gboolean D.33526;
  gchar * endptr;

  try
    {
      endptr = 0B;
      *result = 0.0;
      D.33516 = *ptr;
      if (D.33516 != 0) goto <D.33517>; else goto <D.33518>;
      <D.33517>:
      D.33519 = strtod (ptr, &endptr);
      *result = D.33519;
      <D.33518>:
      D.33516 = *ptr;
      if (D.33516 == 0) goto <D.33520>; else goto <D.33522>;
      <D.33522>:
      endptr.271 = endptr;
      if (endptr.271 != 0B) goto <D.33524>; else goto <D.33521>;
      <D.33524>:
      endptr.271 = endptr;
      D.33525 = *endptr.271;
      if (D.33525 != 0) goto <D.33520>; else goto <D.33521>;
      <D.33520>:
      D.33526 = 0;
      return D.33526;
      <D.33521>:
      D.33526 = 1;
      return D.33526;
    }
  finally
    {
      endptr = {CLOBBER};
    }
}


ves_icall_System_Diagnostics_DefaultTraceListener_WriteWindowsDebugString (struct MonoString * message)
{
  monoeg_g_log (0B, 16, "WriteWindowsDebugString called and HOST_WIN32 not defined!\n");
}


ves_icall_System_Diagnostics_Debugger_Log (int level, struct MonoString * category, struct MonoString * message)
{
  struct MonoRuntimeCallbacks * D.33529;
  void (*<T3185>) (int, struct MonoString *, struct MonoString *) D.33530;
  struct MonoRuntimeCallbacks * D.33533;
  void (*<T3185>) (int, struct MonoString *, struct MonoString *) D.33534;

  D.33529 = mono_get_runtime_callbacks ();
  D.33530 = D.33529->debug_log;
  if (D.33530 != 0B) goto <D.33531>; else goto <D.33532>;
  <D.33531>:
  D.33533 = mono_get_runtime_callbacks ();
  D.33534 = D.33533->debug_log;
  D.33534 (level, category, message);
  <D.33532>:
}


ves_icall_System_Diagnostics_Debugger_IsLogging ()
{
  struct MonoRuntimeCallbacks * D.33535;
  gboolean (*<T3189>) (void) D.33536;
  MonoBoolean D.33539;
  struct MonoRuntimeCallbacks * D.33540;
  gboolean (*<T3189>) (void) D.33541;
  int D.33542;

  D.33535 = mono_get_runtime_callbacks ();
  D.33536 = D.33535->debug_log_is_enabled;
  if (D.33536 != 0B) goto <D.33537>; else goto <D.33538>;
  <D.33537>:
  D.33540 = mono_get_runtime_callbacks ();
  D.33541 = D.33540->debug_log_is_enabled;
  D.33542 = D.33541 ();
  D.33539 = (MonoBoolean) D.33542;
  return D.33539;
  <D.33538>:
  D.33539 = 0;
  return D.33539;
}


ves_icall_System_Diagnostics_Debugger_IsAttached_internal ()
{
  MonoBoolean D.33544;
  int D.33545;

  D.33545 = mono_is_debugger_attached ();
  D.33544 = (MonoBoolean) D.33545;
  return D.33544;
}


ves_icall_System_Delegate_SetMulticastInvoke (struct MonoDelegate * this)
{
  struct MonoVTable * D.33547;
  struct MonoClass * D.33548;
  void * D.33549;

  D.33547 = this->object.vtable;
  D.33548 = D.33547->klass;
  D.33549 = mono_runtime_create_delegate_trampoline (D.33548);
  this->invoke_impl = D.33549;
}


ves_icall_System_Delegate_CreateDelegate_internal (struct MonoReflectionType * type, struct MonoObject * target, struct MonoReflectionMethod * info, MonoBoolean throwOnBindFailure)
{
  struct MonoType * D.33550;
  struct MonoClass * D.33551;
  struct MonoClass * D.33552;
  <unnamed type> D.33555;
  int D.33558;
  int D.33559;
  struct MonoObject * D.33562;
  struct MonoVTable * D.33563;
  struct MonoDomain * D.33564;
  unsigned char D.33565;
  unsigned char D.33566;
  short unsigned int D.33572;
  int D.33573;
  int D.33574;
  struct MonoClass * D.33577;
  struct MonoVTable * D.33578;
  struct MonoClass * D.33579;
  struct MonoDomain * D.33582;
  struct MonoDomain * D.33583;
  void * D.33584;
  struct MonoClass * delegate_class;
  struct MonoObject * delegate;
  void * func;
  struct MonoMethod * method;
  static const char __PRETTY_FUNCTION__[50] = "ves_icall_System_Delegate_CreateDelegate_internal";

  D.33550 = type->type;
  delegate_class = mono_class_from_mono_type (D.33550);
  method = info->method;
  mono_class_init_or_throw (delegate_class);
  D.33551 = delegate_class->parent;
  D.33552 = mono_defaults.multicastdelegate_class;
  if (D.33551 != D.33552) goto <D.33553>; else goto <D.33554>;
  <D.33553>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("file %s: line %d (%s): assertion failed: (%s)", "icall.c", 5817, &__PRETTY_FUNCTION__, "delegate_class->parent == mono_defaults.multicastdelegate_class");
    ex = mono_get_exception_execution_engine (msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.33554>:
  D.33555 = mono_security_get_mode ();
  if (D.33555 == 1) goto <D.33556>; else goto <D.33557>;
  <D.33556>:
  D.33558 = (int) throwOnBindFailure;
  D.33559 = mono_security_core_clr_ensure_delegate_creation (method, D.33558);
  if (D.33559 == 0) goto <D.33560>; else goto <D.33561>;
  <D.33560>:
  D.33562 = 0B;
  return D.33562;
  <D.33561>:
  <D.33557>:
  D.33563 = MEM[(struct MonoObject *)type].vtable;
  D.33564 = D.33563->domain;
  delegate = mono_object_new (D.33564, delegate_class);
  D.33565 = BIT_FIELD_REF <*method, 8, 168>;
  D.33566 = D.33565 & 2;
  if (D.33566 != 0) goto <D.33567>; else goto <D.33568>;
  <D.33567>:
  func = mono_compile_method (method);
  goto <D.33569>;
  <D.33568>:
  if (target != 0B) goto <D.33570>; else goto <D.33571>;
  <D.33570>:
  D.33572 = method->flags;
  D.33573 = (int) D.33572;
  D.33574 = D.33573 & 64;
  if (D.33574 != 0) goto <D.33575>; else goto <D.33576>;
  <D.33575>:
  D.33577 = method->klass;
  D.33578 = target->vtable;
  D.33579 = D.33578->klass;
  if (D.33577 != D.33579) goto <D.33580>; else goto <D.33581>;
  <D.33580>:
  method = mono_object_get_virtual_method (target, method);
  <D.33581>:
  <D.33576>:
  <D.33571>:
  D.33582 = mono_domain_get ();
  D.33583 = mono_domain_get ();
  D.33584 = mono_runtime_create_jump_trampoline (D.33583, method, 1);
  func = mono_create_ftnptr (D.33582, D.33584);
  <D.33569>:
  mono_delegate_ctor_with_method (delegate, target, func, method);
  D.33562 = delegate;
  return D.33562;
}


ves_icall_System_CurrentSystemTimeZone_GetTimeZoneData (guint32 year, struct MonoArray * * data, struct MonoArray * * names)
{
  _Bool D.33586;
  long int D.33587;
  long int D.33588;
  _Bool D.33593;
  long int D.33594;
  long int D.33595;
  struct MonoClass * D.33600;
  struct MonoArray * D.33601;
  struct MonoClass * D.33602;
  struct MonoArray * D.33603;
  unsigned int D.33604;
  int D.33605;
  long int t.272;
  unsigned int D.33609;
  long int t.273;
  long int t.274;
  struct tm * D.33613;
  struct MonoArray * D.33614;
  struct MonoString * D.33615;
  struct MonoString * D.33616;
  guint32 D.33617;
  long int t.275;
  struct tm * D.33619;
  long int t1.276;
  long int t1.277;
  struct tm * D.33624;
  int D.33625;
  long int t1.278;
  struct tm * D.33627;
  int D.33628;
  long int t1.279;
  int D.33630;
  struct MonoString * D.33633;
  struct MonoArray * D.33634;
  long long unsigned int D.33635;
  long long unsigned int D.33636;
  long long unsigned int D.33637;
  long long int D.33638;
  struct MonoString * D.33642;
  int D.33645;
  long long int D.33648;
  long long int D.33649;
  long int D.33650;
  long long int D.33651;
  long long int D.33652;
  _Bool D.33653;
  _Bool D.33654;
  _Bool D.33655;
  struct MonoString * D.33658;
  struct MonoString * D.33659;
  long long int D.33660;
  long long int D.33661;
  struct MonoDomain * domain;
  struct tm start;
  struct tm tt;
  time_t t;
  long int gmtoff;
  long int gmtoff_after;
  long int gmtoff_st;
  long int gmtoff_ds;
  int day;
  int transitioned;
  char tzone[64];

  try
    {
      domain = mono_domain_get ();
      transitioned = 0;
      gmtoff_ds = 0;
      gmtoff_st = gmtoff_ds;
      D.33586 = data == 0B;
      D.33587 = (long int) D.33586;
      D.33588 = __builtin_expect (D.33587, 0);
      if (D.33588 != 0) goto <D.33589>; else goto <D.33590>;
      <D.33589>:
      {
        struct MonoException * ex;

        if (data != 0B) goto <D.33591>; else goto <D.33592>;
        <D.33591>:
        <D.33592>:
        ex = mono_get_exception_argument_null ("data");
        mono_raise_exception (ex);
      }
      <D.33590>:
      D.33593 = names == 0B;
      D.33594 = (long int) D.33593;
      D.33595 = __builtin_expect (D.33594, 0);
      if (D.33595 != 0) goto <D.33596>; else goto <D.33597>;
      <D.33596>:
      {
        struct MonoException * ex;

        if (names != 0B) goto <D.33598>; else goto <D.33599>;
        <D.33598>:
        <D.33599>:
        ex = mono_get_exception_argument_null ("names");
        mono_raise_exception (ex);
      }
      <D.33597>:
      D.33600 = mono_defaults.int64_class;
      D.33601 = mono_array_new (domain, D.33600, 4);
      mono_gc_wbarrier_generic_store (data, D.33601);
      D.33602 = mono_defaults.string_class;
      D.33603 = mono_array_new (domain, D.33602, 2);
      mono_gc_wbarrier_generic_store (names, D.33603);
      memset (&start, 0, 44);
      start.tm_mday = 1;
      D.33604 = year + 4294965396;
      D.33605 = (int) D.33604;
      start.tm_year = D.33605;
      t.272 = mktime (&start);
      t = t.272;
      D.33609 = year + 4294965326;
      if (D.33609 > 67) goto <D.33607>; else goto <D.33610>;
      <D.33610>:
      t.273 = t;
      if (t.273 == -1) goto <D.33607>; else goto <D.33608>;
      <D.33607>:
      t.274 = time (0B);
      t = t.274;
      D.33613 = localtime (&t);
      tt = *D.33613;
      strftime (&tzone, 64, "%Z", &tt);
      {
        void * * __p;

        D.33614 = *names;
        __p = mono_array_addr_with_size (D.33614, 4, 0);
        D.33614 = *names;
        D.33615 = mono_string_new (domain, &tzone);
        mono_gc_wbarrier_set_arrayref (D.33614, __p, D.33615);
      }
      {
        void * * __p;

        D.33614 = *names;
        __p = mono_array_addr_with_size (D.33614, 4, 1);
        D.33614 = *names;
        D.33616 = mono_string_new (domain, &tzone);
        mono_gc_wbarrier_set_arrayref (D.33614, __p, D.33616);
      }
      D.33617 = 1;
      return D.33617;
      <D.33608>:
      t.273 = t;
      gmtoff = gmt_offset (&start, t.273);
      day = 0;
      goto <D.25318>;
      <D.25317>:
      t.273 = t;
      t.275 = t.273 + 86400;
      t = t.275;
      D.33619 = localtime (&t);
      tt = *D.33619;
      t.273 = t;
      gmtoff_after = gmt_offset (&tt, t.273);
      if (gmtoff_after != gmtoff) goto <D.33620>; else goto <D.33621>;
      <D.33620>:
      {
        struct tm tt1;
        time_t t1;

        try
          {
            t.273 = t;
            t1 = t.273;
            <D.25306>:
            t1.276 = t1;
            t1.277 = t1.276 + -3600;
            t1 = t1.277;
            D.33624 = localtime (&t1);
            tt1 = *D.33624;
            t1.276 = t1;
            D.33625 = gmt_offset (&tt1, t1.276);
            if (D.33625 != gmtoff) goto <D.25306>; else goto <D.25307>;
            <D.25307>:
            <D.25308>:
            t1.276 = t1;
            t1.278 = t1.276 + 60;
            t1 = t1.278;
            D.33627 = localtime (&t1);
            tt1 = *D.33627;
            t1.276 = t1;
            D.33628 = gmt_offset (&tt1, t1.276);
            if (D.33628 == gmtoff) goto <D.25308>; else goto <D.25309>;
            <D.25309>:
            t1.276 = t1;
            t1.279 = t1.276 + gmtoff;
            t1 = t1.279;
            strftime (&tzone, 64, "%Z", &tt);
            D.33630 = tt.tm_isdst;
            if (D.33630 != 0) goto <D.33631>; else goto <D.33632>;
            <D.33631>:
            {
              void * * __p;

              D.33614 = *names;
              __p = mono_array_addr_with_size (D.33614, 4, 1);
              D.33614 = *names;
              D.33633 = mono_string_new (domain, &tzone);
              mono_gc_wbarrier_set_arrayref (D.33614, __p, D.33633);
            }
            {
              gint64 * __p;

              D.33634 = *data;
              __p = mono_array_addr_with_size (D.33634, 8, 0);
              t1.276 = t1;
              D.33635 = (long long unsigned int) t1.276;
              D.33636 = D.33635 * 10000000;
              D.33637 = D.33636 + 621355968000000000;
              D.33638 = (long long int) D.33637;
              *__p = D.33638;
            }
            if (gmtoff_ds == 0) goto <D.33639>; else goto <D.33640>;
            <D.33639>:
            gmtoff_st = gmtoff;
            gmtoff_ds = gmtoff_after;
            <D.33640>:
            transitioned = transitioned + 1;
            goto <D.33641>;
            <D.33632>:
            {
              time_t te;

              te = mktime (&tt);
              {
                void * * __p;

                D.33614 = *names;
                __p = mono_array_addr_with_size (D.33614, 4, 0);
                D.33614 = *names;
                D.33642 = mono_string_new (domain, &tzone);
                mono_gc_wbarrier_set_arrayref (D.33614, __p, D.33642);
              }
              {
                gint64 * __p;

                D.33634 = *data;
                __p = mono_array_addr_with_size (D.33634, 8, 1);
                t1.276 = t1;
                D.33635 = (long long unsigned int) t1.276;
                D.33636 = D.33635 * 10000000;
                D.33637 = D.33636 + 621355968000000000;
                D.33638 = (long long int) D.33637;
                *__p = D.33638;
              }
              if (gmtoff_ds == 0) goto <D.33643>; else goto <D.33644>;
              <D.33643>:
              gmtoff_st = gmtoff_after;
              gmtoff_ds = gmtoff;
              <D.33644>:
              transitioned = transitioned + 1;
            }
            <D.33641>:
            D.33645 = tt1.tm_isdst;
            if (D.33645 != 0) goto <D.33646>; else goto <D.33647>;
            <D.33646>:
            {
              gint64 * __p;

              D.33634 = *data;
              __p = mono_array_addr_with_size (D.33634, 8, 2);
              D.33648 = (long long int) gmtoff_st;
              D.33649 = D.33648 * 10000000;
              *__p = D.33649;
            }
            {
              gint64 * __p;

              D.33634 = *data;
              __p = mono_array_addr_with_size (D.33634, 8, 3);
              D.33650 = gmtoff_ds - gmtoff_st;
              D.33651 = (long long int) D.33650;
              D.33652 = D.33651 * 10000000;
              *__p = D.33652;
            }
            <D.33647>:
            t.273 = t;
            gmtoff = gmt_offset (&tt, t.273);
          }
        finally
          {
            tt1 = {CLOBBER};
            t1 = {CLOBBER};
          }
      }
      <D.33621>:
      day = day + 1;
      <D.25318>:
      D.33653 = day <= 364;
      D.33654 = transitioned <= 1;
      D.33655 = D.33653 & D.33654;
      if (D.33655 != 0) goto <D.25317>; else goto <D.25319>;
      <D.25319>:
      if (transitioned <= 1) goto <D.33656>; else goto <D.33657>;
      <D.33656>:
      strftime (&tzone, 64, "%Z", &tt);
      {
        void * * __p;

        D.33614 = *names;
        __p = mono_array_addr_with_size (D.33614, 4, 0);
        D.33614 = *names;
        D.33658 = mono_string_new (domain, &tzone);
        mono_gc_wbarrier_set_arrayref (D.33614, __p, D.33658);
      }
      {
        void * * __p;

        D.33614 = *names;
        __p = mono_array_addr_with_size (D.33614, 4, 1);
        D.33614 = *names;
        D.33659 = mono_string_new (domain, &tzone);
        mono_gc_wbarrier_set_arrayref (D.33614, __p, D.33659);
      }
      {
        gint64 * __p;

        D.33634 = *data;
        __p = mono_array_addr_with_size (D.33634, 8, 0);
        *__p = 0;
      }
      {
        gint64 * __p;

        D.33634 = *data;
        __p = mono_array_addr_with_size (D.33634, 8, 1);
        *__p = 0;
      }
      {
        gint64 * __p;

        D.33634 = *data;
        __p = mono_array_addr_with_size (D.33634, 8, 2);
        D.33660 = (long long int) gmtoff;
        D.33661 = D.33660 * 10000000;
        *__p = D.33661;
      }
      {
        gint64 * __p;

        D.33634 = *data;
        __p = mono_array_addr_with_size (D.33634, 8, 3);
        *__p = 0;
      }
      <D.33657>:
      D.33617 = 1;
      return D.33617;
    }
  finally
    {
      start = {CLOBBER};
      tt = {CLOBBER};
      t = {CLOBBER};
      tzone = {CLOBBER};
    }
}


gmt_offset (struct tm * tm, time_t t)
{
  int D.33664;

  D.33664 = tm->tm_gmtoff;
  return D.33664;
}


InternalFromBase64String (struct MonoString * str, MonoBoolean allowWhitespaceOnly)
{
  struct MonoArray * D.33666;
  mono_unichar2 * D.33667;
  int D.33668;

  D.33667 = mono_string_chars (str);
  D.33668 = mono_string_length (str);
  D.33666 = base64_to_byte_array (D.33667, D.33668, allowWhitespaceOnly);
  return D.33666;
}


base64_to_byte_array (gunichar2 * start, gint ilength, MonoBoolean allowWhitespaceOnly)
{
  unsigned int i.280;
  unsigned int D.33671;
  gunichar2 * D.33672;
  struct MonoImage * D.33675;
  const short unsigned int * * D.33677;
  const short unsigned int * D.33678;
  unsigned int D.33679;
  unsigned int D.33680;
  const short unsigned int * D.33681;
  short unsigned int D.33682;
  int D.33683;
  int D.33684;
  _Bool D.33688;
  _Bool D.33689;
  _Bool D.33690;
  struct MonoImage * D.33693;
  _Bool D.33697;
  _Bool D.33698;
  _Bool D.33699;
  struct MonoArray * D.33702;
  struct MonoDomain * D.33703;
  struct MonoClass * D.33704;
  int D.33707;
  struct MonoImage * D.33709;
  struct MonoImage * D.33712;
  int D.33713;
  struct MonoDomain * D.33718;
  unsigned int olength.281;
  int i.282;
  unsigned int i.283;
  unsigned int D.33722;
  gunichar2 * D.33723;
  unsigned char D.33726;
  int D.33727;
  int D.33728;
  unsigned char D.33729;
  int D.33730;
  int D.33731;
  int D.33732;
  struct MonoImage * D.33735;
  _Bool D.33736;
  _Bool D.33737;
  _Bool D.33738;
  guchar * res_ptr.284;
  int D.33740;
  int D.33741;
  signed char D.33742;
  int D.33743;
  int D.33744;
  signed char D.33745;
  signed char D.33746;
  unsigned char D.33747;
  int D.33748;
  guchar * res_ptr.285;
  int D.33752;
  signed char D.33753;
  int D.33754;
  int D.33755;
  signed char D.33756;
  signed char D.33757;
  unsigned char D.33758;
  int D.33759;
  guchar * res_ptr.286;
  int D.33763;
  signed char D.33764;
  int D.33765;
  signed char D.33766;
  signed char D.33767;
  unsigned char D.33768;
  short unsigned int D.33770;
  unsigned int D.33771;
  unsigned int D.33772;
  const short unsigned int * D.33773;
  short unsigned int D.33774;
  int D.33775;
  int D.33776;
  gint ignored;
  gint i;
  gunichar2 c;
  gunichar2 last;
  gunichar2 prev_last;
  gunichar2 prev2_last;
  gint olength;
  struct MonoArray * result;
  guchar * res_ptr;
  gint a[4];
  gint b[4];
  struct MonoException * exc;
  int havePadding;

  try
    {
      havePadding = 0;
      ignored = 0;
      prev_last = 0;
      last = prev_last;
      prev2_last = 0;
      i = 0;
      goto <D.25830>;
      <D.25829>:
      i.280 = (unsigned int) i;
      D.33671 = i.280 * 2;
      D.33672 = start + D.33671;
      c = *D.33672;
      if (c > 122) goto <D.33673>; else goto <D.33674>;
      <D.33673>:
      D.33675 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.33675, "System", "FormatException", "Invalid character found.");
      mono_raise_exception (exc);
      goto <D.33676>;
      <D.33674>:
      D.33677 = __ctype_b_loc ();
      D.33678 = *D.33677;
      D.33679 = (unsigned int) c;
      D.33680 = D.33679 * 2;
      D.33681 = D.33678 + D.33680;
      D.33682 = *D.33681;
      D.33683 = (int) D.33682;
      D.33684 = D.33683 & 8192;
      if (D.33684 != 0) goto <D.33685>; else goto <D.33686>;
      <D.33685>:
      ignored = ignored + 1;
      goto <D.33687>;
      <D.33686>:
      D.33688 = havePadding != 0;
      D.33689 = c != 61;
      D.33690 = D.33688 & D.33689;
      if (D.33690 != 0) goto <D.33691>; else goto <D.33692>;
      <D.33691>:
      D.33693 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.33693, "System", "FormatException", "Invalid character found.");
      mono_raise_exception (exc);
      goto <D.33694>;
      <D.33692>:
      if (c == 61) goto <D.33695>; else goto <D.33696>;
      <D.33695>:
      havePadding = 1;
      <D.33696>:
      prev2_last = prev_last;
      prev_last = last;
      last = c;
      <D.33694>:
      <D.33687>:
      <D.33676>:
      i = i + 1;
      <D.25830>:
      if (i < ilength) goto <D.25829>; else goto <D.25831>;
      <D.25831>:
      olength = ilength - ignored;
      D.33697 = allowWhitespaceOnly != 0;
      D.33698 = olength == 0;
      D.33699 = D.33697 & D.33698;
      if (D.33699 != 0) goto <D.33700>; else goto <D.33701>;
      <D.33700>:
      D.33703 = mono_domain_get ();
      D.33704 = mono_defaults.byte_class;
      D.33702 = mono_array_new (D.33703, D.33704, 0);
      return D.33702;
      <D.33701>:
      D.33707 = olength & 3;
      if (D.33707 != 0) goto <D.33705>; else goto <D.33708>;
      <D.33708>:
      if (olength <= 0) goto <D.33705>; else goto <D.33706>;
      <D.33705>:
      D.33709 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.33709, "System", "FormatException", "Invalid length.");
      mono_raise_exception (exc);
      <D.33706>:
      if (prev2_last == 61) goto <D.33710>; else goto <D.33711>;
      <D.33710>:
      D.33712 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.33712, "System", "FormatException", "Invalid format.");
      mono_raise_exception (exc);
      <D.33711>:
      D.33713 = olength * 3;
      olength = D.33713 / 4;
      if (last == 61) goto <D.33714>; else goto <D.33715>;
      <D.33714>:
      olength = olength + -1;
      <D.33715>:
      if (prev_last == 61) goto <D.33716>; else goto <D.33717>;
      <D.33716>:
      olength = olength + -1;
      <D.33717>:
      D.33718 = mono_domain_get ();
      D.33704 = mono_defaults.byte_class;
      olength.281 = (unsigned int) olength;
      result = mono_array_new (D.33718, D.33704, olength.281);
      res_ptr = mono_array_addr_with_size (result, 1, 0);
      i = 0;
      goto <D.25840>;
      <D.25839>:
      {
        int k;

        k = 0;
        goto <D.25833>;
        <D.25834>:
        i.282 = i;
        i = i.282 + 1;
        i.283 = (unsigned int) i.282;
        D.33722 = i.283 * 2;
        D.33723 = start + D.33722;
        c = *D.33723;
        D.33677 = __ctype_b_loc ();
        D.33678 = *D.33677;
        D.33679 = (unsigned int) c;
        D.33680 = D.33679 * 2;
        D.33681 = D.33678 + D.33680;
        D.33682 = *D.33681;
        D.33683 = (int) D.33682;
        D.33684 = D.33683 & 8192;
        if (D.33684 != 0) goto <D.33724>; else goto <D.33725>;
        <D.33724>:
        // predicted unlikely by continue predictor.
        goto <D.25833>;
        <D.33725>:
        D.33726 = (unsigned char) c;
        D.33727 = (int) D.33726;
        a[k] = D.33727;
        D.33728 = (int) c;
        D.33729 = dbase64[D.33728];
        D.33730 = (int) D.33729;
        b[k] = D.33730;
        D.33731 = b[k];
        D.33732 = D.33731 & 128;
        if (D.33732 != 0) goto <D.33733>; else goto <D.33734>;
        <D.33733>:
        D.33735 = mono_get_corlib ();
        exc = mono_exception_from_name_msg (D.33735, "System", "FormatException", "Invalid character found.");
        mono_raise_exception (exc);
        <D.33734>:
        k = k + 1;
        <D.25833>:
        D.33736 = k <= 3;
        D.33737 = i < ilength;
        D.33738 = D.33736 & D.33737;
        if (D.33738 != 0) goto <D.25834>; else goto <D.25835>;
        <D.25835>:
        res_ptr.284 = res_ptr;
        res_ptr = res_ptr.284 + 1;
        D.33740 = b[0];
        D.33741 = D.33740 << 2;
        D.33742 = (signed char) D.33741;
        D.33743 = b[1];
        D.33744 = D.33743 >> 4;
        D.33745 = (signed char) D.33744;
        D.33746 = D.33742 | D.33745;
        D.33747 = (unsigned char) D.33746;
        *res_ptr.284 = D.33747;
        D.33748 = a[2];
        if (D.33748 != 61) goto <D.33749>; else goto <D.33750>;
        <D.33749>:
        res_ptr.285 = res_ptr;
        res_ptr = res_ptr.285 + 1;
        D.33743 = b[1];
        D.33752 = D.33743 << 4;
        D.33753 = (signed char) D.33752;
        D.33754 = b[2];
        D.33755 = D.33754 >> 2;
        D.33756 = (signed char) D.33755;
        D.33757 = D.33753 | D.33756;
        D.33758 = (unsigned char) D.33757;
        *res_ptr.285 = D.33758;
        <D.33750>:
        D.33759 = a[3];
        if (D.33759 != 61) goto <D.33760>; else goto <D.33761>;
        <D.33760>:
        res_ptr.286 = res_ptr;
        res_ptr = res_ptr.286 + 1;
        D.33754 = b[2];
        D.33763 = D.33754 << 6;
        D.33764 = (signed char) D.33763;
        D.33765 = b[3];
        D.33766 = (signed char) D.33765;
        D.33767 = D.33764 | D.33766;
        D.33768 = (unsigned char) D.33767;
        *res_ptr.286 = D.33768;
        <D.33761>:
        goto <D.25837>;
        <D.25836>:
        i = i + 1;
        <D.25837>:
        if (i < ilength) goto <D.33769>; else goto <D.25838>;
        <D.33769>:
        D.33677 = __ctype_b_loc ();
        D.33678 = *D.33677;
        i.280 = (unsigned int) i;
        D.33671 = i.280 * 2;
        D.33672 = start + D.33671;
        D.33770 = *D.33672;
        D.33771 = (unsigned int) D.33770;
        D.33772 = D.33771 * 2;
        D.33773 = D.33678 + D.33772;
        D.33774 = *D.33773;
        D.33775 = (int) D.33774;
        D.33776 = D.33775 & 8192;
        if (D.33776 != 0) goto <D.25836>; else goto <D.25838>;
        <D.25838>:
      }
      <D.25840>:
      if (i < ilength) goto <D.25839>; else goto <D.25841>;
      <D.25841>:
      D.33702 = result;
      return D.33702;
    }
  finally
    {
      a = {CLOBBER};
      b = {CLOBBER};
    }
}


InternalFromBase64CharArray (struct MonoArray * input, gint offset, gint length)
{
  struct MonoArray * D.33779;
  unsigned int offset.287;
  char * D.33781;

  offset.287 = (unsigned int) offset;
  D.33781 = mono_array_addr_with_size (input, 2, offset.287);
  D.33779 = base64_to_byte_array (D.33781, length, 0);
  return D.33779;
}


get_bundled_app_config ()
{
  struct MonoAppDomainSetup * D.33783;
  struct MonoString * D.33786;
  unsigned int D.33789;
  unsigned int D.33790;
  struct MonoDomain * D.33795;
  const gchar * app_config;
  struct MonoDomain * domain;
  struct MonoString * file;
  gchar * config_file_name;
  gchar * config_file_path;
  gsize len;
  gchar * module;

  domain = mono_domain_get ();
  D.33783 = domain->setup;
  file = D.33783->configuration_file;
  if (file == 0B) goto <D.33784>; else goto <D.33785>;
  <D.33784>:
  D.33786 = 0B;
  return D.33786;
  <D.33785>:
  config_file_name = mono_string_to_utf8 (file);
  config_file_path = mono_portability_find_file (config_file_name, 1);
  if (config_file_path == 0B) goto <D.33787>; else goto <D.33788>;
  <D.33787>:
  config_file_path = config_file_name;
  <D.33788>:
  D.33789 = strlen (config_file_path);
  len = D.33789 + 4294967289;
  D.33790 = len + 1;
  module = monoeg_malloc0 (D.33790);
  memcpy (module, config_file_path, len);
  app_config = mono_config_string_for_assembly_file (module);
  monoeg_g_free (module);
  if (config_file_name != config_file_path) goto <D.33791>; else goto <D.33792>;
  <D.33791>:
  monoeg_g_free (config_file_name);
  <D.33792>:
  monoeg_g_free (config_file_path);
  if (app_config == 0B) goto <D.33793>; else goto <D.33794>;
  <D.33793>:
  D.33786 = 0B;
  return D.33786;
  <D.33794>:
  D.33795 = mono_domain_get ();
  D.33786 = mono_string_new (D.33795, app_config);
  return D.33786;
}


ves_icall_System_Configuration_DefaultConfig_get_machine_config_path ()
{
  const char * D.33797;
  const struct MonoRuntimeInfo * D.33798;
  const char[4] * D.33799;
  struct MonoDomain * D.33800;
  struct MonoString * D.33801;
  struct MonoString * mcpath;
  gchar * path;

  D.33797 = mono_get_config_dir ();
  D.33798 = mono_get_runtime_info ();
  D.33799 = &D.33798->framework_version;
  path = monoeg_g_build_path ("/", D.33797, "mono", D.33799, "machine.config", 0B);
  D.33800 = mono_domain_get ();
  mcpath = mono_string_new (D.33800, path);
  monoeg_g_free (path);
  D.33801 = mcpath;
  return D.33801;
}


get_bundled_machine_config ()
{
  struct MonoString * D.33805;
  struct MonoDomain * D.33806;
  const gchar * machine_config;

  machine_config = mono_get_machine_config ();
  if (machine_config == 0B) goto <D.33803>; else goto <D.33804>;
  <D.33803>:
  D.33805 = 0B;
  return D.33805;
  <D.33804>:
  D.33806 = mono_domain_get ();
  D.33805 = mono_string_new (D.33806, machine_config);
  return D.33805;
}


ves_icall_System_ComponentModel_Win32Exception_W32ErrorMessage (guint32 code)
{
  struct MonoDomain * D.33810;
  struct MonoDomain * D.33812;
  int ret.288;
  struct MonoString * D.33814;
  struct MonoString * message;
  guint32 ret;
  gunichar2 buf[256];

  try
    {
      ret = FormatMessage (4608, 0B, code, 0, &buf, 255, 0B);
      if (ret == 0) goto <D.33808>; else goto <D.33809>;
      <D.33808>:
      D.33810 = mono_domain_get ();
      message = mono_string_new (D.33810, "Error looking up error string");
      goto <D.33811>;
      <D.33809>:
      D.33812 = mono_domain_get ();
      ret.288 = (int) ret;
      message = mono_string_new_utf16 (D.33812, &buf, ret.288);
      <D.33811>:
      D.33814 = message;
      return D.33814;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


ves_icall_System_Char_GetDataTablePointers (int category_data_version, const guint8 * * category_data, const guint16 * * category_astral_index, const guint8 * * numeric_data, const gdouble * * numeric_data_values, const guint16 * * to_lower_data_low, const guint16 * * to_lower_data_high, const guint16 * * to_upper_data_low, const guint16 * * to_upper_data_high)
{
  get_category_data (category_data_version, category_data, category_astral_index);
  *numeric_data = &NumericData;
  *numeric_data_values = &NumericDataValues;
  *to_lower_data_low = &ToLowerDataLow;
  *to_lower_data_high = &ToLowerDataHigh;
  *to_upper_data_low = &ToUpperDataLow;
  *to_upper_data_high = &ToUpperDataHigh;
}


get_category_data (int version, const guint8 * * category_data, const guint16 * * category_astral_index)
{
  *category_astral_index = 0B;
  if (version == 4) goto <D.33817>; else goto <D.33818>;
  <D.33817>:
  *category_data = &CategoryData_v4;
  *category_astral_index = &CategoryData_v4_astral_index;
  return;
  <D.33818>:
  *category_data = &CategoryData_v2;
  *category_astral_index = &CategoryData_v2_astral_index;
}


ves_icall_System_Buffer_SetByteInternal (struct MonoArray * array, gint32 idx, gint8 value)
{
  unsigned int idx.289;

  {
    gint8 * __p;

    idx.289 = (unsigned int) idx;
    __p = mono_array_addr_with_size (array, 1, idx.289);
    *__p = value;
  }
}


ves_icall_System_Buffer_GetByteInternal (struct MonoArray * array, gint32 idx)
{
  gint8 D.33821;
  unsigned int idx.290;
  char * D.33823;

  idx.290 = (unsigned int) idx;
  D.33823 = mono_array_addr_with_size (array, 1, idx.290);
  D.33821 = MEM[(gint8 *)D.33823];
  return D.33821;
}


ves_icall_System_Buffer_ByteLengthInternal (struct MonoArray * array)
{
  gint32 D.33825;

  D.33825 = mono_array_get_byte_length (array);
  return D.33825;
}


mono_array_get_byte_length (struct MonoArray * array)
{
  struct MonoVTable * D.33827;
  struct MonoArrayBounds * D.33828;
  unsigned int D.33831;
  unsigned int i.291;
  unsigned int D.33834;
  struct MonoArrayBounds * D.33835;
  unsigned int D.33836;
  unsigned int length.292;
  unsigned int D.33838;
  unsigned char D.33839;
  int D.33840;
  struct MonoClass * D.33841;
  unsigned char D.33842;
  int D.33843;
  gint32 D.33844;
  unsigned int length.293;
  unsigned int D.33846;
  struct MonoClass * klass;
  int length;
  int i;

  D.33827 = array->obj.vtable;
  klass = D.33827->klass;
  D.33828 = array->bounds;
  if (D.33828 == 0B) goto <D.33829>; else goto <D.33830>;
  <D.33829>:
  D.33831 = array->max_length;
  length = (int) D.33831;
  goto <D.33832>;
  <D.33830>:
  length = 1;
  i = 0;
  goto <D.25336>;
  <D.25335>:
  D.33828 = array->bounds;
  i.291 = (unsigned int) i;
  D.33834 = i.291 * 8;
  D.33835 = D.33828 + D.33834;
  D.33836 = D.33835->length;
  length.292 = (unsigned int) length;
  D.33838 = D.33836 * length.292;
  length = (int) D.33838;
  i = i + 1;
  <D.25336>:
  D.33839 = klass->rank;
  D.33840 = (int) D.33839;
  if (D.33840 > i) goto <D.25335>; else goto <D.25337>;
  <D.25337>:
  <D.33832>:
  D.33841 = klass->element_class;
  D.33842 = D.33841->byval_arg.type;
  D.33843 = (int) D.33842;
  switch (D.33843) <default: <D.25352>, case 2: <D.25340>, case 3: <D.25343>, case 4: <D.25338>, case 5: <D.25339>, case 6: <D.25341>, case 7: <D.25342>, case 8: <D.25344>, case 9: <D.25345>, case 10: <D.25349>, case 11: <D.25350>, case 12: <D.25346>, case 13: <D.25351>, case 24: <D.25347>, case 25: <D.25348>>
  <D.25338>:
  <D.25339>:
  <D.25340>:
  D.33844 = length;
  return D.33844;
  <D.25341>:
  <D.25342>:
  <D.25343>:
  D.33844 = length << 1;
  return D.33844;
  <D.25344>:
  <D.25345>:
  <D.25346>:
  D.33844 = length << 2;
  return D.33844;
  <D.25347>:
  <D.25348>:
  length.293 = (unsigned int) length;
  D.33846 = length.293 * 4;
  D.33844 = (gint32) D.33846;
  return D.33844;
  <D.25349>:
  <D.25350>:
  <D.25351>:
  D.33844 = length << 3;
  return D.33844;
  <D.25352>:
  D.33844 = -1;
  return D.33844;
}


ves_icall_System_Buffer_BlockCopyInternal (struct MonoArray * src, gint32 src_offset, struct MonoArray * dest, gint32 dest_offset, gint32 count)
{
  _Bool D.33848;
  long int D.33849;
  long int D.33850;
  _Bool D.33855;
  long int D.33856;
  long int D.33857;
  int D.33864;
  int D.33865;
  int D.33867;
  int D.33868;
  MonoBoolean D.33869;
  double[0:] * D.33870;
  sizetype src_offset.294;
  double[0:] * D.33872;
  sizetype dest_offset.295;
  unsigned int count.296;
  guint8 * src_buf;
  guint8 * dest_buf;

  D.33848 = src == 0B;
  D.33849 = (long int) D.33848;
  D.33850 = __builtin_expect (D.33849, 0);
  if (D.33850 != 0) goto <D.33851>; else goto <D.33852>;
  <D.33851>:
  {
    struct MonoException * ex;

    if (src != 0B) goto <D.33853>; else goto <D.33854>;
    <D.33853>:
    <D.33854>:
    ex = mono_get_exception_argument_null ("src");
    mono_raise_exception (ex);
  }
  <D.33852>:
  D.33855 = dest == 0B;
  D.33856 = (long int) D.33855;
  D.33857 = __builtin_expect (D.33856, 0);
  if (D.33857 != 0) goto <D.33858>; else goto <D.33859>;
  <D.33858>:
  {
    struct MonoException * ex;

    if (dest != 0B) goto <D.33860>; else goto <D.33861>;
    <D.33860>:
    <D.33861>:
    ex = mono_get_exception_argument_null ("dest");
    mono_raise_exception (ex);
  }
  <D.33859>:
  D.33864 = mono_array_get_byte_length (src);
  D.33865 = D.33864 - count;
  if (D.33865 < src_offset) goto <D.33862>; else goto <D.33866>;
  <D.33866>:
  D.33867 = mono_array_get_byte_length (dest);
  D.33868 = D.33867 - count;
  if (D.33868 < dest_offset) goto <D.33862>; else goto <D.33863>;
  <D.33862>:
  D.33869 = 0;
  return D.33869;
  <D.33863>:
  D.33870 = &src->vector;
  src_offset.294 = (sizetype) src_offset;
  src_buf = D.33870 + src_offset.294;
  D.33872 = &dest->vector;
  dest_offset.295 = (sizetype) dest_offset;
  dest_buf = D.33872 + dest_offset.295;
  if (src != dest) goto <D.33874>; else goto <D.33875>;
  <D.33874>:
  count.296 = (unsigned int) count;
  memcpy (dest_buf, src_buf, count.296);
  goto <D.33877>;
  <D.33875>:
  count.296 = (unsigned int) count;
  memmove (dest_buf, src_buf, count.296);
  <D.33877>:
  D.33869 = 1;
  return D.33869;
}


memmove (void * __dest, const void * __src, size_t __len)
{
  void * D.33879;
  unsigned int D.33880;

  D.33880 = __builtin_object_size (__dest, 0);
  D.33879 = __builtin___memmove_chk (__dest, __src, __len, D.33880);
  return D.33879;
}


ves_icall_System_Array_SetValueImpl (struct MonoArray * this, struct MonoObject * value, guint32 pos)
{
  struct MonoVTable * D.33884;
  struct MonoVTable * D.33886;
  double[0:] * D.33887;
  unsigned int esize.297;
  unsigned int D.33889;
  int D.33890;
  unsigned int esize.298;
  unsigned char D.33896;
  int D.33897;
  unsigned char D.33898;
  int D.33899;
  struct MonoRuntimeCallbacks * D.33900;
  void (*<T3181>) (struct MonoClass *, struct MonoClass *) D.33901;
  struct MonoException * D.33902;
  struct MonoException * D.33903;
  struct MonoRuntimeCallbacks * D.33904;
  void (*<T3181>) (struct MonoClass *, struct MonoClass *) D.33905;
  struct MonoException * D.33906;
  unsigned char D.33908;
  unsigned char D.33909;
  struct MonoObject * D.33912;
  struct MonoRuntimeCallbacks * D.33915;
  void (*<T3181>) (struct MonoClass *, struct MonoClass *) D.33916;
  struct MonoException * D.33917;
  struct MonoObject * D.33918;
  unsigned char D.33921;
  unsigned char D.33922;
  void * D.33925;
  const void * D.33927;
  unsigned char D.33928;
  unsigned char D.33929;
  struct MonoRuntimeCallbacks * D.33932;
  void (*<T3181>) (struct MonoClass *, struct MonoClass *) D.33933;
  struct MonoException * D.33934;
  int D.33935;
  unsigned int D.33936;
  unsigned int D.33937;
  struct MonoClass * D.33940;
  unsigned char D.33941;
  unsigned char D.33942;
  struct MonoType * D.33945;
  unsigned char D.33946;
  struct MonoClass * D.33949;
  unsigned char D.33950;
  unsigned char D.33951;
  struct MonoType * D.33954;
  unsigned char D.33955;
  unsigned char D.33956;
  short unsigned int D.33957;
  unsigned int D.33958;
  signed char D.33959;
  short int D.33960;
  int D.33961;
  float D.33962;
  struct MonoException * D.33963;
  struct MonoRuntimeCallbacks * D.33964;
  void (*<T3181>) (struct MonoClass *, struct MonoClass *) D.33965;
  struct MonoException * D.33966;
  struct MonoException * D.33970;
  short unsigned int D.33971;
  struct MonoException * D.33972;
  struct MonoException * D.33976;
  unsigned char D.33977;
  struct MonoException * D.33978;
  struct MonoException * D.33982;
  struct MonoException * D.33983;
  struct MonoException * D.33987;
  unsigned int D.33988;
  struct MonoException * D.33989;
  struct MonoException * D.33993;
  struct MonoException * D.33994;
  struct MonoException * D.33998;
  signed char D.33999;
  struct MonoException * D.34002;
  signed char D.34003;
  struct MonoException * D.34004;
  struct MonoException * D.34008;
  short int D.34009;
  struct MonoException * D.34012;
  short int D.34013;
  struct MonoException * D.34014;
  struct MonoException * D.34018;
  int D.34019;
  struct MonoException * D.34022;
  int D.34023;
  struct MonoException * D.34024;
  struct MonoException * D.34028;
  struct MonoException * D.34031;
  long long int u64.299;
  struct MonoException * D.34033;
  struct MonoException * D.34037;
  float D.34038;
  float D.34039;
  float D.34040;
  struct MonoException * D.34044;
  double D.34045;
  double D.34046;
  struct MonoRuntimeCallbacks * D.34049;
  void (*<T3181>) (struct MonoClass *, struct MonoClass *) D.34050;
  struct MonoException * D.34051;
  struct MonoClass * ac;
  struct MonoClass * vc;
  struct MonoClass * ec;
  gint32 esize;
  gint32 vsize;
  void * * ea;
  void * * va;
  int et;
  int vt;
  guint64 u64;
  gint64 i64;
  gdouble r64;

  u64 = 0;
  i64 = 0;
  r64 = 0.0;
  if (value != 0B) goto <D.33882>; else goto <D.33883>;
  <D.33882>:
  D.33884 = value->vtable;
  vc = D.33884->klass;
  goto <D.33885>;
  <D.33883>:
  vc = 0B;
  <D.33885>:
  D.33886 = this->obj.vtable;
  ac = D.33886->klass;
  ec = ac->element_class;
  esize = mono_array_element_size (ac);
  D.33887 = &this->vector;
  esize.297 = (unsigned int) esize;
  D.33889 = pos * esize.297;
  ea = D.33887 + D.33889;
  va = value + 8;
  D.33890 = mono_class_is_nullable (ec);
  if (D.33890 != 0) goto <D.33891>; else goto <D.33892>;
  <D.33891>:
  mono_nullable_init (ea, value, ec);
  return;
  <D.33892>:
  if (value == 0B) goto <D.33893>; else goto <D.33894>;
  <D.33893>:
  esize.298 = (unsigned int) esize;
  mono_gc_bzero_atomic (ea, esize.298);
  return;
  <D.33894>:
  D.33896 = ec->byval_arg.type;
  D.33897 = (int) D.33896;
  switch (D.33897) <default: <D.33907>, case 2: <D.22930>, case 14: <D.22925>>
  <D.22925>:
  D.33898 = vc->byval_arg.type;
  D.33899 = (int) D.33898;
  switch (D.33899) <default: <D.22928>, case 14: <D.22926>>
  <D.22926>:
  goto <D.22927>;
  <D.22928>:
  D.33900 = mono_get_runtime_callbacks ();
  D.33901 = D.33900->set_cast_details;
  D.33901 (vc, ec);
  D.33902 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.33902);
  <D.22927>:
  goto <D.22929>;
  <D.22930>:
  D.33898 = vc->byval_arg.type;
  D.33899 = (int) D.33898;
  switch (D.33899) <default: <D.22944>, case 2: <D.22931>, case 3: <D.22933>, case 4: <D.22938>, case 5: <D.22934>, case 6: <D.22939>, case 7: <D.22935>, case 8: <D.22940>, case 9: <D.22936>, case 10: <D.22941>, case 11: <D.22937>, case 12: <D.22942>, case 13: <D.22943>>
  <D.22931>:
  goto <D.22932>;
  <D.22933>:
  <D.22934>:
  <D.22935>:
  <D.22936>:
  <D.22937>:
  <D.22938>:
  <D.22939>:
  <D.22940>:
  <D.22941>:
  <D.22942>:
  <D.22943>:
  D.33903 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.33903);
  <D.22944>:
  D.33904 = mono_get_runtime_callbacks ();
  D.33905 = D.33904->set_cast_details;
  D.33905 (vc, ec);
  D.33906 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.33906);
  <D.22932>:
  goto <D.22929>;
  <D.33907>:
  <D.22929>:
  D.33908 = BIT_FIELD_REF <*ec, 8, 160>;
  D.33909 = D.33908 & 8;
  if (D.33909 == 0) goto <D.33910>; else goto <D.33911>;
  <D.33910>:
  D.33912 = mono_object_isinst (value, ec);
  if (D.33912 == 0B) goto <D.33913>; else goto <D.33914>;
  <D.33913>:
  D.33915 = mono_get_runtime_callbacks ();
  D.33916 = D.33915->set_cast_details;
  D.33916 (vc, ec);
  D.33917 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.33917);
  <D.33914>:
  mono_gc_wbarrier_set_arrayref (this, ea, value);
  return;
  <D.33911>:
  D.33918 = mono_object_isinst (value, ec);
  if (D.33918 != 0B) goto <D.33919>; else goto <D.33920>;
  <D.33919>:
  D.33921 = BIT_FIELD_REF <*ec, 8, 184>;
  D.33922 = D.33921 & 8;
  if (D.33922 != 0) goto <D.33923>; else goto <D.33924>;
  <D.33923>:
  D.33925 = value + 8;
  mono_value_copy (ea, D.33925, ec);
  goto <D.33926>;
  <D.33924>:
  D.33927 = value + 8;
  esize.298 = (unsigned int) esize;
  mono_gc_memmove_atomic (ea, D.33927, esize.298);
  <D.33926>:
  return;
  <D.33920>:
  D.33928 = BIT_FIELD_REF <*vc, 8, 160>;
  D.33929 = D.33928 & 8;
  if (D.33929 == 0) goto <D.33930>; else goto <D.33931>;
  <D.33930>:
  D.33932 = mono_get_runtime_callbacks ();
  D.33933 = D.33932->set_cast_details;
  D.33933 (vc, ec);
  D.33934 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.33934);
  <D.33931>:
  D.33935 = mono_class_instance_size (vc);
  D.33936 = (unsigned int) D.33935;
  D.33937 = D.33936 + 4294967288;
  vsize = (gint32) D.33937;
  D.33896 = ec->byval_arg.type;
  et = (int) D.33896;
  if (et == 17) goto <D.33938>; else goto <D.33939>;
  <D.33938>:
  D.33940 = ec->byval_arg.data.klass;
  D.33941 = BIT_FIELD_REF <*D.33940, 8, 160>;
  D.33942 = D.33941 & 16;
  if (D.33942 != 0) goto <D.33943>; else goto <D.33944>;
  <D.33943>:
  D.33940 = ec->byval_arg.data.klass;
  D.33945 = mono_class_enum_basetype (D.33940);
  D.33946 = D.33945->type;
  et = (int) D.33946;
  <D.33944>:
  <D.33939>:
  D.33898 = vc->byval_arg.type;
  vt = (int) D.33898;
  if (vt == 17) goto <D.33947>; else goto <D.33948>;
  <D.33947>:
  D.33949 = vc->byval_arg.data.klass;
  D.33950 = BIT_FIELD_REF <*D.33949, 8, 160>;
  D.33951 = D.33950 & 16;
  if (D.33951 != 0) goto <D.33952>; else goto <D.33953>;
  <D.33952>:
  D.33949 = vc->byval_arg.data.klass;
  D.33954 = mono_class_enum_basetype (D.33949);
  D.33955 = D.33954->type;
  vt = (int) D.33955;
  <D.33953>:
  <D.33948>:
  switch (vt) <default: <D.33967>, case 2: <D.22957>, case 3: <D.22956>, case 4: <D.22950>, case 5: <D.22945>, case 6: <D.22951>, case 7: <D.22947>, case 8: <D.22952>, case 9: <D.22948>, case 10: <D.22953>, case 11: <D.22949>, case 12: <D.22954>, case 13: <D.22955>>
  <D.22945>:
  D.33956 = MEM[(guint8 *)va];
  u64 = (guint64) D.33956;
  goto <D.22946>;
  <D.22947>:
  D.33957 = MEM[(guint16 *)va];
  u64 = (guint64) D.33957;
  goto <D.22946>;
  <D.22948>:
  D.33958 = MEM[(guint32 *)va];
  u64 = (guint64) D.33958;
  goto <D.22946>;
  <D.22949>:
  u64 = MEM[(guint64 *)va];
  goto <D.22946>;
  <D.22950>:
  D.33959 = MEM[(gint8 *)va];
  i64 = (gint64) D.33959;
  goto <D.22946>;
  <D.22951>:
  D.33960 = MEM[(gint16 *)va];
  i64 = (gint64) D.33960;
  goto <D.22946>;
  <D.22952>:
  D.33961 = MEM[(gint32 *)va];
  i64 = (gint64) D.33961;
  goto <D.22946>;
  <D.22953>:
  i64 = MEM[(gint64 *)va];
  goto <D.22946>;
  <D.22954>:
  D.33962 = MEM[(gfloat *)va];
  r64 = (gdouble) D.33962;
  goto <D.22946>;
  <D.22955>:
  r64 = MEM[(gdouble *)va];
  goto <D.22946>;
  <D.22956>:
  D.33957 = MEM[(guint16 *)va];
  u64 = (guint64) D.33957;
  goto <D.22946>;
  <D.22957>:
  switch (et) <default: <D.22969>, case 3: <D.22958>, case 4: <D.22963>, case 5: <D.22959>, case 6: <D.22964>, case 7: <D.22960>, case 8: <D.22965>, case 9: <D.22961>, case 10: <D.22966>, case 11: <D.22962>, case 12: <D.22967>, case 13: <D.22968>>
  <D.22958>:
  <D.22959>:
  <D.22960>:
  <D.22961>:
  <D.22962>:
  <D.22963>:
  <D.22964>:
  <D.22965>:
  <D.22966>:
  <D.22967>:
  <D.22968>:
  D.33963 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.33963);
  <D.22969>:
  D.33964 = mono_get_runtime_callbacks ();
  D.33965 = D.33964->set_cast_details;
  D.33965 (vc, ec);
  D.33966 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.33966);
  goto <D.22946>;
  <D.33967>:
  <D.22946>:
  switch (et) <default: <D.34048>, case 3: <D.22970>, case 4: <D.23030>, case 5: <D.22982>, case 6: <D.23042>, case 7: <D.22994>, case 8: <D.23054>, case 9: <D.23006>, case 10: <D.23066>, case 11: <D.23018>, case 12: <D.23078>, case 13: <D.23090>>
  <D.22970>:
  switch (vt) <default: <D.33973>, case 3: <D.22975>, case 4: <D.22976>, case 5: <D.22971>, case 6: <D.22977>, case 7: <D.22972>, case 8: <D.22978>, case 9: <D.22973>, case 10: <D.22979>, case 11: <D.22974>, case 12: <D.22980>, case 13: <D.22981>>
  <D.22971>:
  <D.22972>:
  <D.22973>:
  <D.22974>:
  <D.22975>:
  if (esize < vsize) goto <D.33968>; else goto <D.33969>;
  <D.33968>:
  D.33970 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.33970);
  <D.33969>:
  D.33971 = (short unsigned int) u64;
  MEM[(guint16 *)ea] = D.33971;
  return;
  <D.22976>:
  <D.22977>:
  <D.22978>:
  <D.22979>:
  <D.22980>:
  <D.22981>:
  D.33972 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.33972);
  <D.33973>:
  <D.22982>:
  switch (vt) <default: <D.33979>, case 3: <D.22987>, case 4: <D.22988>, case 5: <D.22983>, case 6: <D.22989>, case 7: <D.22984>, case 8: <D.22990>, case 9: <D.22985>, case 10: <D.22991>, case 11: <D.22986>, case 12: <D.22992>, case 13: <D.22993>>
  <D.22983>:
  <D.22984>:
  <D.22985>:
  <D.22986>:
  <D.22987>:
  if (esize < vsize) goto <D.33974>; else goto <D.33975>;
  <D.33974>:
  D.33976 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.33976);
  <D.33975>:
  D.33977 = (unsigned char) u64;
  MEM[(guint8 *)ea] = D.33977;
  return;
  <D.22988>:
  <D.22989>:
  <D.22990>:
  <D.22991>:
  <D.22992>:
  <D.22993>:
  D.33978 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.33978);
  <D.33979>:
  <D.22994>:
  switch (vt) <default: <D.33984>, case 3: <D.22999>, case 4: <D.23000>, case 5: <D.22995>, case 6: <D.23001>, case 7: <D.22996>, case 8: <D.23002>, case 9: <D.22997>, case 10: <D.23003>, case 11: <D.22998>, case 12: <D.23004>, case 13: <D.23005>>
  <D.22995>:
  <D.22996>:
  <D.22997>:
  <D.22998>:
  <D.22999>:
  if (esize < vsize) goto <D.33980>; else goto <D.33981>;
  <D.33980>:
  D.33982 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.33982);
  <D.33981>:
  D.33971 = (short unsigned int) u64;
  MEM[(guint16 *)ea] = D.33971;
  return;
  <D.23000>:
  <D.23001>:
  <D.23002>:
  <D.23003>:
  <D.23004>:
  <D.23005>:
  D.33983 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.33983);
  <D.33984>:
  <D.23006>:
  switch (vt) <default: <D.33990>, case 3: <D.23011>, case 4: <D.23012>, case 5: <D.23007>, case 6: <D.23013>, case 7: <D.23008>, case 8: <D.23014>, case 9: <D.23009>, case 10: <D.23015>, case 11: <D.23010>, case 12: <D.23016>, case 13: <D.23017>>
  <D.23007>:
  <D.23008>:
  <D.23009>:
  <D.23010>:
  <D.23011>:
  if (esize < vsize) goto <D.33985>; else goto <D.33986>;
  <D.33985>:
  D.33987 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.33987);
  <D.33986>:
  D.33988 = (unsigned int) u64;
  MEM[(guint32 *)ea] = D.33988;
  return;
  <D.23012>:
  <D.23013>:
  <D.23014>:
  <D.23015>:
  <D.23016>:
  <D.23017>:
  D.33989 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.33989);
  <D.33990>:
  <D.23018>:
  switch (vt) <default: <D.33995>, case 3: <D.23023>, case 4: <D.23024>, case 5: <D.23019>, case 6: <D.23025>, case 7: <D.23020>, case 8: <D.23026>, case 9: <D.23021>, case 10: <D.23027>, case 11: <D.23022>, case 12: <D.23028>, case 13: <D.23029>>
  <D.23019>:
  <D.23020>:
  <D.23021>:
  <D.23022>:
  <D.23023>:
  if (esize < vsize) goto <D.33991>; else goto <D.33992>;
  <D.33991>:
  D.33993 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.33993);
  <D.33992>:
  MEM[(guint64 *)ea] = u64;
  return;
  <D.23024>:
  <D.23025>:
  <D.23026>:
  <D.23027>:
  <D.23028>:
  <D.23029>:
  D.33994 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.33994);
  <D.33995>:
  <D.23030>:
  switch (vt) <default: <D.34005>, case 3: <D.23039>, case 4: <D.23031>, case 5: <D.23035>, case 6: <D.23032>, case 7: <D.23036>, case 8: <D.23033>, case 9: <D.23037>, case 10: <D.23034>, case 11: <D.23038>, case 12: <D.23040>, case 13: <D.23041>>
  <D.23031>:
  <D.23032>:
  <D.23033>:
  <D.23034>:
  if (esize < vsize) goto <D.33996>; else goto <D.33997>;
  <D.33996>:
  D.33998 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.33998);
  <D.33997>:
  D.33999 = (signed char) i64;
  MEM[(gint8 *)ea] = D.33999;
  return;
  <D.23035>:
  <D.23036>:
  <D.23037>:
  <D.23038>:
  <D.23039>:
  if (vsize >= esize) goto <D.34000>; else goto <D.34001>;
  <D.34000>:
  D.34002 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.34002);
  <D.34001>:
  D.34003 = (signed char) u64;
  MEM[(gint8 *)ea] = D.34003;
  return;
  <D.23040>:
  <D.23041>:
  D.34004 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.34004);
  <D.34005>:
  <D.23042>:
  switch (vt) <default: <D.34015>, case 3: <D.23051>, case 4: <D.23043>, case 5: <D.23047>, case 6: <D.23044>, case 7: <D.23048>, case 8: <D.23045>, case 9: <D.23049>, case 10: <D.23046>, case 11: <D.23050>, case 12: <D.23052>, case 13: <D.23053>>
  <D.23043>:
  <D.23044>:
  <D.23045>:
  <D.23046>:
  if (esize < vsize) goto <D.34006>; else goto <D.34007>;
  <D.34006>:
  D.34008 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.34008);
  <D.34007>:
  D.34009 = (short int) i64;
  MEM[(gint16 *)ea] = D.34009;
  return;
  <D.23047>:
  <D.23048>:
  <D.23049>:
  <D.23050>:
  <D.23051>:
  if (vsize >= esize) goto <D.34010>; else goto <D.34011>;
  <D.34010>:
  D.34012 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.34012);
  <D.34011>:
  D.34013 = (short int) u64;
  MEM[(gint16 *)ea] = D.34013;
  return;
  <D.23052>:
  <D.23053>:
  D.34014 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.34014);
  <D.34015>:
  <D.23054>:
  switch (vt) <default: <D.34025>, case 3: <D.23063>, case 4: <D.23055>, case 5: <D.23059>, case 6: <D.23056>, case 7: <D.23060>, case 8: <D.23057>, case 9: <D.23061>, case 10: <D.23058>, case 11: <D.23062>, case 12: <D.23064>, case 13: <D.23065>>
  <D.23055>:
  <D.23056>:
  <D.23057>:
  <D.23058>:
  if (esize < vsize) goto <D.34016>; else goto <D.34017>;
  <D.34016>:
  D.34018 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.34018);
  <D.34017>:
  D.34019 = (int) i64;
  MEM[(gint32 *)ea] = D.34019;
  return;
  <D.23059>:
  <D.23060>:
  <D.23061>:
  <D.23062>:
  <D.23063>:
  if (vsize >= esize) goto <D.34020>; else goto <D.34021>;
  <D.34020>:
  D.34022 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.34022);
  <D.34021>:
  D.34023 = (int) u64;
  MEM[(gint32 *)ea] = D.34023;
  return;
  <D.23064>:
  <D.23065>:
  D.34024 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.34024);
  <D.34025>:
  <D.23066>:
  switch (vt) <default: <D.34034>, case 3: <D.23075>, case 4: <D.23067>, case 5: <D.23071>, case 6: <D.23068>, case 7: <D.23072>, case 8: <D.23069>, case 9: <D.23073>, case 10: <D.23070>, case 11: <D.23074>, case 12: <D.23076>, case 13: <D.23077>>
  <D.23067>:
  <D.23068>:
  <D.23069>:
  <D.23070>:
  if (esize < vsize) goto <D.34026>; else goto <D.34027>;
  <D.34026>:
  D.34028 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.34028);
  <D.34027>:
  MEM[(gint64 *)ea] = i64;
  return;
  <D.23071>:
  <D.23072>:
  <D.23073>:
  <D.23074>:
  <D.23075>:
  if (vsize >= esize) goto <D.34029>; else goto <D.34030>;
  <D.34029>:
  D.34031 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.34031);
  <D.34030>:
  u64.299 = (long long int) u64;
  MEM[(gint64 *)ea] = u64.299;
  return;
  <D.23076>:
  <D.23077>:
  D.34033 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.34033);
  <D.34034>:
  <D.23078>:
  switch (vt) <default: <D.34041>, case 3: <D.23089>, case 4: <D.23081>, case 5: <D.23085>, case 6: <D.23082>, case 7: <D.23086>, case 8: <D.23083>, case 9: <D.23087>, case 10: <D.23084>, case 11: <D.23088>, case 12: <D.23079>, case 13: <D.23080>>
  <D.23079>:
  <D.23080>:
  if (esize < vsize) goto <D.34035>; else goto <D.34036>;
  <D.34035>:
  D.34037 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.34037);
  <D.34036>:
  D.34038 = (float) r64;
  MEM[(gfloat *)ea] = D.34038;
  return;
  <D.23081>:
  <D.23082>:
  <D.23083>:
  <D.23084>:
  D.34039 = (float) i64;
  MEM[(gfloat *)ea] = D.34039;
  return;
  <D.23085>:
  <D.23086>:
  <D.23087>:
  <D.23088>:
  <D.23089>:
  D.34040 = (float) u64;
  MEM[(gfloat *)ea] = D.34040;
  return;
  <D.34041>:
  <D.23090>:
  switch (vt) <default: <D.34047>, case 3: <D.23101>, case 4: <D.23093>, case 5: <D.23097>, case 6: <D.23094>, case 7: <D.23098>, case 8: <D.23095>, case 9: <D.23099>, case 10: <D.23096>, case 11: <D.23100>, case 12: <D.23091>, case 13: <D.23092>>
  <D.23091>:
  <D.23092>:
  if (esize < vsize) goto <D.34042>; else goto <D.34043>;
  <D.34042>:
  D.34044 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.34044);
  <D.34043>:
  MEM[(gdouble *)ea] = r64;
  return;
  <D.23093>:
  <D.23094>:
  <D.23095>:
  <D.23096>:
  D.34045 = (double) i64;
  MEM[(gdouble *)ea] = D.34045;
  return;
  <D.23097>:
  <D.23098>:
  <D.23099>:
  <D.23100>:
  <D.23101>:
  D.34046 = (double) u64;
  MEM[(gdouble *)ea] = D.34046;
  return;
  <D.34047>:
  <D.34048>:
  D.34049 = mono_get_runtime_callbacks ();
  D.34050 = D.34049->set_cast_details;
  D.34050 (vc, ec);
  D.34051 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.34051);
  return;
}


ves_icall_System_Array_SetValue (struct MonoArray * this, struct MonoObject * value, struct MonoArray * idxs)
{
  _Bool D.34055;
  long int D.34056;
  long int D.34057;
  struct MonoVTable * D.34062;
  struct MonoVTable * D.34063;
  unsigned char D.34064;
  _Bool D.34065;
  long int D.34066;
  long int D.34067;
  struct MonoArrayBounds * D.34072;
  unsigned int D.34074;
  unsigned char D.34075;
  unsigned int D.34076;
  struct MonoException * D.34077;
  struct MonoArrayBounds * D.34078;
  int D.34083;
  unsigned int D.34085;
  unsigned int D.34086;
  struct MonoException * D.34087;
  unsigned int D.34088;
  unsigned int i.300;
  unsigned int D.34092;
  gint32 * D.34093;
  int D.34094;
  unsigned int D.34095;
  struct MonoArrayBounds * D.34096;
  int D.34097;
  unsigned int D.34099;
  int D.34100;
  int D.34101;
  struct MonoException * D.34102;
  int D.34103;
  int D.34104;
  unsigned int pos.301;
  unsigned int D.34106;
  unsigned int D.34107;
  unsigned int D.34108;
  unsigned int D.34109;
  unsigned int D.34110;
  unsigned int pos.302;
  struct MonoClass * ac;
  struct MonoClass * ic;
  gint32 i;
  gint32 pos;
  gint32 * ind;

  D.34055 = idxs == 0B;
  D.34056 = (long int) D.34055;
  D.34057 = __builtin_expect (D.34056, 0);
  if (D.34057 != 0) goto <D.34058>; else goto <D.34059>;
  <D.34058>:
  {
    struct MonoException * ex;

    if (idxs != 0B) goto <D.34060>; else goto <D.34061>;
    <D.34060>:
    <D.34061>:
    ex = mono_get_exception_argument_null ("idxs");
    mono_raise_exception (ex);
  }
  <D.34059>:
  D.34062 = idxs->obj.vtable;
  ic = D.34062->klass;
  D.34063 = this->obj.vtable;
  ac = D.34063->klass;
  D.34064 = ic->rank;
  D.34065 = D.34064 != 1;
  D.34066 = (long int) D.34065;
  D.34067 = __builtin_expect (D.34066, 0);
  if (D.34067 != 0) goto <D.34068>; else goto <D.34069>;
  <D.34068>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 502, "ic->rank == 1");
  <D.34069>:
  D.34072 = idxs->bounds;
  if (D.34072 != 0B) goto <D.34070>; else goto <D.34073>;
  <D.34073>:
  D.34074 = idxs->max_length;
  D.34075 = ac->rank;
  D.34076 = (unsigned int) D.34075;
  if (D.34074 != D.34076) goto <D.34070>; else goto <D.34071>;
  <D.34070>:
  D.34077 = mono_get_exception_argument (0B, 0B);
  mono_raise_exception (D.34077);
  <D.34071>:
  ind = &idxs->vector;
  D.34078 = this->bounds;
  if (D.34078 == 0B) goto <D.34079>; else goto <D.34080>;
  <D.34079>:
  D.34083 = *ind;
  if (D.34083 < 0) goto <D.34081>; else goto <D.34084>;
  <D.34084>:
  D.34083 = *ind;
  D.34085 = (unsigned int) D.34083;
  D.34086 = this->max_length;
  if (D.34085 >= D.34086) goto <D.34081>; else goto <D.34082>;
  <D.34081>:
  D.34087 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.34087);
  <D.34082>:
  D.34083 = *ind;
  D.34088 = (unsigned int) D.34083;
  ves_icall_System_Array_SetValueImpl (this, value, D.34088);
  return;
  <D.34080>:
  i = 0;
  goto <D.23114>;
  <D.23113>:
  i.300 = (unsigned int) i;
  D.34092 = i.300 * 4;
  D.34093 = ind + D.34092;
  D.34094 = *D.34093;
  D.34078 = this->bounds;
  i.300 = (unsigned int) i;
  D.34095 = i.300 * 8;
  D.34096 = D.34078 + D.34095;
  D.34097 = D.34096->lower_bound;
  if (D.34094 < D.34097) goto <D.34089>; else goto <D.34098>;
  <D.34098>:
  i.300 = (unsigned int) i;
  D.34092 = i.300 * 4;
  D.34093 = ind + D.34092;
  D.34094 = *D.34093;
  D.34078 = this->bounds;
  i.300 = (unsigned int) i;
  D.34095 = i.300 * 8;
  D.34096 = D.34078 + D.34095;
  D.34099 = D.34096->length;
  D.34100 = (int) D.34099;
  D.34078 = this->bounds;
  i.300 = (unsigned int) i;
  D.34095 = i.300 * 8;
  D.34096 = D.34078 + D.34095;
  D.34097 = D.34096->lower_bound;
  D.34101 = D.34100 + D.34097;
  if (D.34094 >= D.34101) goto <D.34089>; else goto <D.34090>;
  <D.34089>:
  D.34102 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.34102);
  <D.34090>:
  i = i + 1;
  <D.23114>:
  D.34075 = ac->rank;
  D.34103 = (int) D.34075;
  if (D.34103 > i) goto <D.23113>; else goto <D.23115>;
  <D.23115>:
  D.34083 = *ind;
  D.34078 = this->bounds;
  D.34104 = D.34078->lower_bound;
  pos = D.34083 - D.34104;
  i = 1;
  goto <D.23117>;
  <D.23116>:
  D.34078 = this->bounds;
  i.300 = (unsigned int) i;
  D.34095 = i.300 * 8;
  D.34096 = D.34078 + D.34095;
  D.34099 = D.34096->length;
  pos.301 = (unsigned int) pos;
  D.34106 = D.34099 * pos.301;
  i.300 = (unsigned int) i;
  D.34092 = i.300 * 4;
  D.34093 = ind + D.34092;
  D.34094 = *D.34093;
  D.34107 = (unsigned int) D.34094;
  D.34108 = D.34106 + D.34107;
  D.34078 = this->bounds;
  i.300 = (unsigned int) i;
  D.34095 = i.300 * 8;
  D.34096 = D.34078 + D.34095;
  D.34097 = D.34096->lower_bound;
  D.34109 = (unsigned int) D.34097;
  D.34110 = D.34108 - D.34109;
  pos = (gint32) D.34110;
  i = i + 1;
  <D.23117>:
  D.34075 = ac->rank;
  D.34103 = (int) D.34075;
  if (D.34103 > i) goto <D.23116>; else goto <D.23118>;
  <D.23118>:
  pos.302 = (unsigned int) pos;
  ves_icall_System_Array_SetValueImpl (this, value, pos.302);
}


ves_icall_System_Array_SetGenericValueImpl (struct MonoObject * this, guint32 pos, void * value)
{
  struct MonoVTable * D.34113;
  double[0:] * D.34114;
  unsigned int esize.303;
  unsigned int D.34116;
  struct MonoType * D.34117;
  int D.34118;
  _Bool D.34121;
  long int D.34122;
  long int D.34123;
  void * D.34126;
  unsigned char D.34128;
  unsigned char D.34129;
  _Bool D.34130;
  long int D.34131;
  long int D.34132;
  int D.34135;
  _Bool D.34136;
  long int D.34137;
  long int D.34138;
  unsigned char D.34141;
  unsigned char D.34142;
  unsigned int esize.304;
  struct MonoClass * ac;
  struct MonoClass * ec;
  struct MonoArray * ao;
  gint32 esize;
  void * * ea;

  ao = this;
  D.34113 = ao->obj.vtable;
  ac = D.34113->klass;
  ec = ac->element_class;
  esize = mono_array_element_size (ac);
  D.34114 = &ao->vector;
  esize.303 = (unsigned int) esize;
  D.34116 = pos * esize.303;
  ea = D.34114 + D.34116;
  D.34117 = &ec->byval_arg;
  D.34118 = mono_type_is_reference (D.34117);
  if (D.34118 != 0) goto <D.34119>; else goto <D.34120>;
  <D.34119>:
  D.34121 = esize != 4;
  D.34122 = (long int) D.34121;
  D.34123 = __builtin_expect (D.34122, 0);
  if (D.34123 != 0) goto <D.34124>; else goto <D.34125>;
  <D.34124>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 793, "esize == sizeof (gpointer)");
  <D.34125>:
  D.34126 = MEM[(void * *)value];
  mono_gc_wbarrier_generic_store (ea, D.34126);
  goto <D.34127>;
  <D.34120>:
  D.34128 = BIT_FIELD_REF <*ec, 8, 160>;
  D.34129 = D.34128 & 1;
  D.34130 = D.34129 == 0;
  D.34131 = (long int) D.34130;
  D.34132 = __builtin_expect (D.34131, 0);
  if (D.34132 != 0) goto <D.34133>; else goto <D.34134>;
  <D.34133>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 796, "ec->inited");
  <D.34134>:
  D.34135 = mono_class_value_size (ec, 0B);
  D.34136 = D.34135 != esize;
  D.34137 = (long int) D.34136;
  D.34138 = __builtin_expect (D.34137, 0);
  if (D.34138 != 0) goto <D.34139>; else goto <D.34140>;
  <D.34139>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 797, "esize == mono_class_value_size (ec, NULL)");
  <D.34140>:
  D.34141 = BIT_FIELD_REF <*ec, 8, 184>;
  D.34142 = D.34141 & 8;
  if (D.34142 != 0) goto <D.34143>; else goto <D.34144>;
  <D.34143>:
  mono_gc_wbarrier_value_copy (ea, value, 1, ec);
  goto <D.34145>;
  <D.34144>:
  esize.304 = (unsigned int) esize;
  mono_gc_memmove_atomic (ea, value, esize.304);
  <D.34145>:
  <D.34127>:
}


ves_icall_System_Array_GetValueImpl (struct MonoObject * this, guint32 pos)
{
  struct MonoVTable * D.34147;
  double[0:] * D.34148;
  unsigned int esize.305;
  unsigned int D.34150;
  struct MonoClass * D.34151;
  unsigned char D.34152;
  unsigned char D.34153;
  struct MonoObject * D.34156;
  struct MonoVTable * D.34157;
  struct MonoDomain * D.34158;
  struct MonoClass * ac;
  struct MonoArray * ao;
  gint32 esize;
  void * * ea;

  ao = this;
  D.34147 = ao->obj.vtable;
  ac = D.34147->klass;
  esize = mono_array_element_size (ac);
  D.34148 = &ao->vector;
  esize.305 = (unsigned int) esize;
  D.34150 = pos * esize.305;
  ea = D.34148 + D.34150;
  D.34151 = ac->element_class;
  D.34152 = BIT_FIELD_REF <*D.34151, 8, 160>;
  D.34153 = D.34152 & 8;
  if (D.34153 != 0) goto <D.34154>; else goto <D.34155>;
  <D.34154>:
  D.34157 = this->vtable;
  D.34158 = D.34157->domain;
  D.34151 = ac->element_class;
  D.34156 = mono_value_box (D.34158, D.34151, ea);
  return D.34156;
  <D.34155>:
  D.34156 = *ea;
  return D.34156;
}


ves_icall_System_Array_GetValue (struct MonoObject * this, struct MonoObject * idxs)
{
  _Bool D.34160;
  long int D.34161;
  long int D.34162;
  struct MonoVTable * D.34167;
  struct MonoVTable * D.34168;
  unsigned char D.34169;
  _Bool D.34170;
  long int D.34171;
  long int D.34172;
  struct MonoArrayBounds * D.34177;
  unsigned int D.34179;
  unsigned char D.34180;
  unsigned int D.34181;
  struct MonoException * D.34182;
  struct MonoArrayBounds * D.34183;
  int D.34188;
  unsigned int D.34190;
  unsigned int D.34191;
  struct MonoException * D.34192;
  struct MonoObject * D.34193;
  unsigned int D.34194;
  unsigned int i.306;
  unsigned int D.34198;
  gint32 * D.34199;
  int D.34200;
  unsigned int D.34201;
  struct MonoArrayBounds * D.34202;
  int D.34203;
  unsigned int D.34205;
  int D.34206;
  int D.34207;
  struct MonoException * D.34208;
  int D.34209;
  int D.34210;
  unsigned int pos.307;
  unsigned int D.34212;
  unsigned int D.34213;
  unsigned int D.34214;
  unsigned int D.34215;
  unsigned int D.34216;
  unsigned int pos.308;
  struct MonoClass * ac;
  struct MonoClass * ic;
  struct MonoArray * ao;
  struct MonoArray * io;
  gint32 i;
  gint32 pos;
  gint32 * ind;

  D.34160 = idxs == 0B;
  D.34161 = (long int) D.34160;
  D.34162 = __builtin_expect (D.34161, 0);
  if (D.34162 != 0) goto <D.34163>; else goto <D.34164>;
  <D.34163>:
  {
    struct MonoException * ex;

    if (idxs != 0B) goto <D.34165>; else goto <D.34166>;
    <D.34165>:
    <D.34166>:
    ex = mono_get_exception_argument_null ("idxs");
    mono_raise_exception (ex);
  }
  <D.34164>:
  io = idxs;
  D.34167 = io->obj.vtable;
  ic = D.34167->klass;
  ao = this;
  D.34168 = ao->obj.vtable;
  ac = D.34168->klass;
  D.34169 = ic->rank;
  D.34170 = D.34169 != 1;
  D.34171 = (long int) D.34170;
  D.34172 = __builtin_expect (D.34171, 0);
  if (D.34172 != 0) goto <D.34173>; else goto <D.34174>;
  <D.34173>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 184, "ic->rank == 1");
  <D.34174>:
  D.34177 = io->bounds;
  if (D.34177 != 0B) goto <D.34175>; else goto <D.34178>;
  <D.34178>:
  D.34179 = io->max_length;
  D.34180 = ac->rank;
  D.34181 = (unsigned int) D.34180;
  if (D.34179 != D.34181) goto <D.34175>; else goto <D.34176>;
  <D.34175>:
  D.34182 = mono_get_exception_argument (0B, 0B);
  mono_raise_exception (D.34182);
  <D.34176>:
  ind = &io->vector;
  D.34183 = ao->bounds;
  if (D.34183 == 0B) goto <D.34184>; else goto <D.34185>;
  <D.34184>:
  D.34188 = *ind;
  if (D.34188 < 0) goto <D.34186>; else goto <D.34189>;
  <D.34189>:
  D.34188 = *ind;
  D.34190 = (unsigned int) D.34188;
  D.34191 = ao->max_length;
  if (D.34190 >= D.34191) goto <D.34186>; else goto <D.34187>;
  <D.34186>:
  D.34192 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.34192);
  <D.34187>:
  D.34188 = *ind;
  D.34194 = (unsigned int) D.34188;
  D.34193 = ves_icall_System_Array_GetValueImpl (this, D.34194);
  return D.34193;
  <D.34185>:
  i = 0;
  goto <D.22903>;
  <D.22902>:
  i.306 = (unsigned int) i;
  D.34198 = i.306 * 4;
  D.34199 = ind + D.34198;
  D.34200 = *D.34199;
  D.34183 = ao->bounds;
  i.306 = (unsigned int) i;
  D.34201 = i.306 * 8;
  D.34202 = D.34183 + D.34201;
  D.34203 = D.34202->lower_bound;
  if (D.34200 < D.34203) goto <D.34195>; else goto <D.34204>;
  <D.34204>:
  i.306 = (unsigned int) i;
  D.34198 = i.306 * 4;
  D.34199 = ind + D.34198;
  D.34200 = *D.34199;
  D.34183 = ao->bounds;
  i.306 = (unsigned int) i;
  D.34201 = i.306 * 8;
  D.34202 = D.34183 + D.34201;
  D.34205 = D.34202->length;
  D.34206 = (int) D.34205;
  D.34183 = ao->bounds;
  i.306 = (unsigned int) i;
  D.34201 = i.306 * 8;
  D.34202 = D.34183 + D.34201;
  D.34203 = D.34202->lower_bound;
  D.34207 = D.34206 + D.34203;
  if (D.34200 >= D.34207) goto <D.34195>; else goto <D.34196>;
  <D.34195>:
  D.34208 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.34208);
  <D.34196>:
  i = i + 1;
  <D.22903>:
  D.34180 = ac->rank;
  D.34209 = (int) D.34180;
  if (D.34209 > i) goto <D.22902>; else goto <D.22904>;
  <D.22904>:
  D.34188 = *ind;
  D.34183 = ao->bounds;
  D.34210 = D.34183->lower_bound;
  pos = D.34188 - D.34210;
  i = 1;
  goto <D.22906>;
  <D.22905>:
  D.34183 = ao->bounds;
  i.306 = (unsigned int) i;
  D.34201 = i.306 * 8;
  D.34202 = D.34183 + D.34201;
  D.34205 = D.34202->length;
  pos.307 = (unsigned int) pos;
  D.34212 = D.34205 * pos.307;
  i.306 = (unsigned int) i;
  D.34198 = i.306 * 4;
  D.34199 = ind + D.34198;
  D.34200 = *D.34199;
  D.34213 = (unsigned int) D.34200;
  D.34214 = D.34212 + D.34213;
  D.34183 = ao->bounds;
  i.306 = (unsigned int) i;
  D.34201 = i.306 * 8;
  D.34202 = D.34183 + D.34201;
  D.34203 = D.34202->lower_bound;
  D.34215 = (unsigned int) D.34203;
  D.34216 = D.34214 - D.34215;
  pos = (gint32) D.34216;
  i = i + 1;
  <D.22906>:
  D.34180 = ac->rank;
  D.34209 = (int) D.34180;
  if (D.34209 > i) goto <D.22905>; else goto <D.22907>;
  <D.22907>:
  pos.308 = (unsigned int) pos;
  D.34193 = ves_icall_System_Array_GetValueImpl (this, pos.308);
  return D.34193;
}


ves_icall_System_Array_GetRank (struct MonoObject * this)
{
  gint32 D.34219;
  struct MonoVTable * D.34220;
  struct MonoClass * D.34221;
  unsigned char D.34222;

  D.34220 = this->vtable;
  D.34221 = D.34220->klass;
  D.34222 = D.34221->rank;
  D.34219 = (gint32) D.34222;
  return D.34219;
}


ves_icall_System_Array_GetLowerBound (struct MonoArray * this, gint32 dimension)
{
  struct MonoVTable * D.34224;
  struct MonoClass * D.34225;
  unsigned char D.34226;
  _Bool D.34227;
  _Bool D.34228;
  _Bool D.34229;
  struct MonoException * D.34232;
  struct MonoArrayBounds * D.34233;
  gint32 D.34236;
  unsigned int dimension.309;
  unsigned int D.34238;
  struct MonoArrayBounds * D.34239;
  gint32 rank;

  D.34224 = MEM[(struct MonoObject *)this].vtable;
  D.34225 = D.34224->klass;
  D.34226 = D.34225->rank;
  rank = (gint32) D.34226;
  D.34227 = dimension < 0;
  D.34228 = dimension >= rank;
  D.34229 = D.34227 | D.34228;
  if (D.34229 != 0) goto <D.34230>; else goto <D.34231>;
  <D.34230>:
  D.34232 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.34232);
  <D.34231>:
  D.34233 = this->bounds;
  if (D.34233 == 0B) goto <D.34234>; else goto <D.34235>;
  <D.34234>:
  D.34236 = 0;
  return D.34236;
  <D.34235>:
  D.34233 = this->bounds;
  dimension.309 = (unsigned int) dimension;
  D.34238 = dimension.309 * 8;
  D.34239 = D.34233 + D.34238;
  D.34236 = D.34239->lower_bound;
  return D.34236;
}


ves_icall_System_Array_GetLongLength (struct MonoArray * this, gint32 dimension)
{
  struct MonoVTable * D.34241;
  struct MonoClass * D.34242;
  unsigned char D.34243;
  _Bool D.34244;
  _Bool D.34245;
  _Bool D.34246;
  struct MonoException * D.34249;
  struct MonoArrayBounds * D.34250;
  gint64 D.34253;
  unsigned int D.34254;
  unsigned int dimension.310;
  unsigned int D.34256;
  struct MonoArrayBounds * D.34257;
  unsigned int D.34258;
  gint32 rank;

  D.34241 = MEM[(struct MonoObject *)this].vtable;
  D.34242 = D.34241->klass;
  D.34243 = D.34242->rank;
  rank = (gint32) D.34243;
  D.34244 = dimension < 0;
  D.34245 = dimension >= rank;
  D.34246 = D.34244 | D.34245;
  if (D.34246 != 0) goto <D.34247>; else goto <D.34248>;
  <D.34247>:
  D.34249 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.34249);
  <D.34248>:
  D.34250 = this->bounds;
  if (D.34250 == 0B) goto <D.34251>; else goto <D.34252>;
  <D.34251>:
  D.34254 = this->max_length;
  D.34253 = (gint64) D.34254;
  return D.34253;
  <D.34252>:
  D.34250 = this->bounds;
  dimension.310 = (unsigned int) dimension;
  D.34256 = dimension.310 * 8;
  D.34257 = D.34250 + D.34256;
  D.34258 = D.34257->length;
  D.34253 = (gint64) D.34258;
  return D.34253;
}


ves_icall_System_Array_GetLength (struct MonoArray * this, gint32 dimension)
{
  struct MonoVTable * D.34260;
  struct MonoClass * D.34261;
  unsigned char D.34262;
  _Bool D.34263;
  _Bool D.34264;
  _Bool D.34265;
  struct MonoException * D.34268;
  struct MonoArrayBounds * D.34269;
  unsigned int dimension.311;
  unsigned int D.34274;
  struct MonoArrayBounds * D.34275;
  gint32 D.34276;
  gint32 rank;
  uintptr_t length;

  D.34260 = MEM[(struct MonoObject *)this].vtable;
  D.34261 = D.34260->klass;
  D.34262 = D.34261->rank;
  rank = (gint32) D.34262;
  D.34263 = dimension < 0;
  D.34264 = dimension >= rank;
  D.34265 = D.34263 | D.34264;
  if (D.34265 != 0) goto <D.34266>; else goto <D.34267>;
  <D.34266>:
  D.34268 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.34268);
  <D.34267>:
  D.34269 = this->bounds;
  if (D.34269 == 0B) goto <D.34270>; else goto <D.34271>;
  <D.34270>:
  length = this->max_length;
  goto <D.34272>;
  <D.34271>:
  D.34269 = this->bounds;
  dimension.311 = (unsigned int) dimension;
  D.34274 = dimension.311 * 8;
  D.34275 = D.34269 + D.34274;
  length = D.34275->length;
  <D.34272>:
  D.34276 = (gint32) length;
  return D.34276;
}


ves_icall_System_Array_GetGenericValueImpl (struct MonoObject * this, guint32 pos, void * value)
{
  struct MonoVTable * D.34278;
  double[0:] * D.34279;
  unsigned int esize.312;
  unsigned int D.34281;
  unsigned int esize.313;
  struct MonoClass * ac;
  struct MonoArray * ao;
  gint32 esize;
  void * * ea;

  ao = this;
  D.34278 = ao->obj.vtable;
  ac = D.34278->klass;
  esize = mono_array_element_size (ac);
  D.34279 = &ao->vector;
  esize.312 = (unsigned int) esize;
  D.34281 = pos * esize.312;
  ea = D.34279 + D.34281;
  esize.313 = (unsigned int) esize;
  mono_gc_memmove_atomic (value, ea, esize.313);
}


ves_icall_System_Array_FastCopy (struct MonoArray * source, int source_idx, struct MonoArray * dest, int dest_idx, int length)
{
  unsigned char D.34283;
  unsigned char D.34284;
  gboolean D.34287;
  struct MonoArrayBounds * D.34290;
  struct MonoArrayBounds * D.34292;
  int D.34295;
  unsigned int D.34296;
  unsigned int D.34297;
  int D.34299;
  unsigned int D.34300;
  unsigned int D.34301;
  struct MonoClass * D.34302;
  struct MonoClass * D.34303;
  struct MonoClass * D.34304;
  unsigned char D.34307;
  unsigned char D.34308;
  unsigned char D.34315;
  unsigned char D.34317;
  unsigned char D.34318;
  int D.34319;
  struct MonoVTable * D.34324;
  struct MonoClass * D.34325;
  double[0:] * D.34326;
  int D.34327;
  sizetype D.34328;
  unsigned char D.34329;
  unsigned char D.34330;
  double[0:] * D.34334;
  int D.34335;
  sizetype D.34336;
  int D.34337;
  unsigned int D.34338;
  unsigned int dest_idx.314;
  unsigned int D.34341;
  unsigned int source_idx.315;
  unsigned int D.34343;
  int element_size;
  void * dest_addr;
  void * source_addr;
  struct MonoVTable * src_vtable;
  struct MonoVTable * dest_vtable;
  struct MonoClass * src_class;
  struct MonoClass * dest_class;

  src_vtable = source->obj.vtable;
  dest_vtable = dest->obj.vtable;
  D.34283 = src_vtable->rank;
  D.34284 = dest_vtable->rank;
  if (D.34283 != D.34284) goto <D.34285>; else goto <D.34286>;
  <D.34285>:
  D.34287 = 0;
  return D.34287;
  <D.34286>:
  D.34290 = source->bounds;
  if (D.34290 != 0B) goto <D.34288>; else goto <D.34291>;
  <D.34291>:
  D.34292 = dest->bounds;
  if (D.34292 != 0B) goto <D.34288>; else goto <D.34289>;
  <D.34288>:
  D.34287 = 0;
  return D.34287;
  <D.34289>:
  D.34295 = dest_idx + length;
  D.34296 = (unsigned int) D.34295;
  D.34297 = dest->max_length;
  if (D.34296 > D.34297) goto <D.34293>; else goto <D.34298>;
  <D.34298>:
  D.34299 = source_idx + length;
  D.34300 = (unsigned int) D.34299;
  D.34301 = source->max_length;
  if (D.34300 > D.34301) goto <D.34293>; else goto <D.34294>;
  <D.34293>:
  D.34287 = 0;
  return D.34287;
  <D.34294>:
  D.34302 = src_vtable->klass;
  src_class = D.34302->element_class;
  D.34303 = dest_vtable->klass;
  dest_class = D.34303->element_class;
  D.34304 = mono_defaults.object_class;
  if (D.34304 == src_class) goto <D.34305>; else goto <D.34306>;
  <D.34305>:
  D.34307 = BIT_FIELD_REF <*dest_class, 8, 160>;
  D.34308 = D.34307 & 8;
  if (D.34308 != 0) goto <D.34309>; else goto <D.34310>;
  <D.34309>:
  D.34287 = 0;
  return D.34287;
  <D.34310>:
  <D.34306>:
  if (src_class != dest_class) goto <D.34311>; else goto <D.34312>;
  <D.34311>:
  D.34307 = BIT_FIELD_REF <*dest_class, 8, 160>;
  D.34315 = D.34307 & 24;
  if (D.34315 != 0) goto <D.34313>; else goto <D.34316>;
  <D.34316>:
  D.34317 = BIT_FIELD_REF <*src_class, 8, 160>;
  D.34318 = D.34317 & 24;
  if (D.34318 != 0) goto <D.34313>; else goto <D.34314>;
  <D.34313>:
  D.34287 = 0;
  return D.34287;
  <D.34314>:
  D.34319 = mono_class_is_subclass_of (src_class, dest_class, 0);
  if (D.34319 == 0) goto <D.34320>; else goto <D.34321>;
  <D.34320>:
  D.34287 = 0;
  return D.34287;
  <D.34321>:
  <D.34312>:
  D.34307 = BIT_FIELD_REF <*dest_class, 8, 160>;
  D.34308 = D.34307 & 8;
  if (D.34308 != 0) goto <D.34322>; else goto <D.34323>;
  <D.34322>:
  D.34324 = source->obj.vtable;
  D.34325 = D.34324->klass;
  element_size = mono_array_element_size (D.34325);
  D.34326 = &source->vector;
  D.34327 = element_size * source_idx;
  D.34328 = (sizetype) D.34327;
  source_addr = D.34326 + D.34328;
  D.34329 = BIT_FIELD_REF <*dest_class, 8, 184>;
  D.34330 = D.34329 & 8;
  if (D.34330 != 0) goto <D.34331>; else goto <D.34332>;
  <D.34331>:
  mono_value_copy_array (dest, dest_idx, source_addr, length);
  goto <D.34333>;
  <D.34332>:
  D.34334 = &dest->vector;
  D.34335 = element_size * dest_idx;
  D.34336 = (sizetype) D.34335;
  dest_addr = D.34334 + D.34336;
  D.34337 = element_size * length;
  D.34338 = (unsigned int) D.34337;
  mono_gc_memmove_atomic (dest_addr, source_addr, D.34338);
  <D.34333>:
  goto <D.34339>;
  <D.34323>:
  {
    void * * __p;
    void * * __s;

    D.34334 = &dest->vector;
    dest_idx.314 = (unsigned int) dest_idx;
    D.34341 = dest_idx.314 * 4;
    __p = D.34334 + D.34341;
    D.34326 = &source->vector;
    source_idx.315 = (unsigned int) source_idx;
    D.34343 = source_idx.315 * 4;
    __s = D.34326 + D.34343;
    mono_gc_wbarrier_arrayref_copy (__p, __s, length);
  }
  <D.34339>:
  D.34287 = 1;
  return D.34287;
}


ves_icall_System_Array_CreateInstanceImpl64 (struct MonoReflectionType * type, struct MonoArray * lengths, struct MonoArray * bounds)
{
  _Bool D.34345;
  long int D.34346;
  long int D.34347;
  _Bool D.34352;
  long int D.34353;
  long int D.34354;
  unsigned int D.34359;
  _Bool D.34360;
  long int D.34361;
  long int D.34362;
  unsigned int D.34369;
  unsigned int D.34370;
  _Bool D.34371;
  long int D.34372;
  long int D.34373;
  char * D.34380;
  long long int D.34381;
  char * D.34383;
  long long int D.34384;
  struct MonoException * D.34385;
  unsigned int D.34386;
  struct MonoType * D.34387;
  unsigned int D.34391;
  char * D.34393;
  long long int D.34394;
  unsigned int D.34396;
  unsigned char D.34397;
  unsigned int D.34398;
  unsigned int D.34399;
  unsigned int D.34400;
  uintptr_t * D.34401;
  char * D.34402;
  long long unsigned int D.34403;
  unsigned int D.34404;
  unsigned int D.34407;
  unsigned int D.34408;
  unsigned int D.34409;
  uintptr_t * D.34410;
  char * D.34411;
  long long unsigned int D.34412;
  unsigned int D.34413;
  struct MonoVTable * D.34415;
  struct MonoDomain * D.34416;
  unsigned int D.34417;
  intptr_t * D.34418;
  struct MonoArray * D.34419;
  struct MonoClass * aklass;
  struct MonoClass * klass;
  struct MonoArray * array;
  uintptr_t * sizes;
  uintptr_t i;
  gboolean bounded;

  bounded = 0;
  D.34345 = type == 0B;
  D.34346 = (long int) D.34345;
  D.34347 = __builtin_expect (D.34346, 0);
  if (D.34347 != 0) goto <D.34348>; else goto <D.34349>;
  <D.34348>:
  {
    struct MonoException * ex;

    if (type != 0B) goto <D.34350>; else goto <D.34351>;
    <D.34350>:
    <D.34351>:
    ex = mono_get_exception_argument_null ("type");
    mono_raise_exception (ex);
  }
  <D.34349>:
  D.34352 = lengths == 0B;
  D.34353 = (long int) D.34352;
  D.34354 = __builtin_expect (D.34353, 0);
  if (D.34354 != 0) goto <D.34355>; else goto <D.34356>;
  <D.34355>:
  {
    struct MonoException * ex;

    if (lengths != 0B) goto <D.34357>; else goto <D.34358>;
    <D.34357>:
    <D.34358>:
    ex = mono_get_exception_argument_null ("lengths");
    mono_raise_exception (ex);
  }
  <D.34356>:
  D.34359 = mono_array_length (lengths);
  D.34360 = D.34359 == 0;
  D.34361 = (long int) D.34360;
  D.34362 = __builtin_expect (D.34361, 0);
  if (D.34362 != 0) goto <D.34363>; else goto <D.34364>;
  <D.34363>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("assertion `%s\' failed", "mono_array_length (lengths) > 0");
    if (lengths != 0B) goto <D.34365>; else goto <D.34366>;
    <D.34365>:
    <D.34366>:
    ex = mono_get_exception_argument ("lengths", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.34364>:
  if (bounds != 0B) goto <D.34367>; else goto <D.34368>;
  <D.34367>:
  D.34369 = mono_array_length (lengths);
  D.34370 = mono_array_length (bounds);
  D.34371 = D.34369 != D.34370;
  D.34372 = (long int) D.34371;
  D.34373 = __builtin_expect (D.34372, 0);
  if (D.34373 != 0) goto <D.34374>; else goto <D.34375>;
  <D.34374>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("assertion `%s\' failed", "mono_array_length (lengths) == mono_array_length (bounds)");
    if (bounds != 0B) goto <D.34376>; else goto <D.34377>;
    <D.34376>:
    <D.34377>:
    ex = mono_get_exception_argument ("bounds", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.34375>:
  <D.34368>:
  i = 0;
  goto <D.23160>;
  <D.23159>:
  D.34380 = mono_array_addr_with_size (lengths, 8, i);
  D.34381 = MEM[(gint64 *)D.34380];
  if (D.34381 < 0) goto <D.34378>; else goto <D.34382>;
  <D.34382>:
  D.34383 = mono_array_addr_with_size (lengths, 8, i);
  D.34384 = MEM[(gint64 *)D.34383];
  if (D.34384 > 2147483647) goto <D.34378>; else goto <D.34379>;
  <D.34378>:
  D.34385 = mono_get_exception_argument_out_of_range (0B);
  mono_raise_exception (D.34385);
  <D.34379>:
  i = i + 1;
  <D.23160>:
  D.34386 = mono_array_length (lengths);
  if (D.34386 > i) goto <D.23159>; else goto <D.23161>;
  <D.23161>:
  D.34387 = type->type;
  klass = mono_class_from_mono_type (D.34387);
  mono_class_init_or_throw (klass);
  if (bounds != 0B) goto <D.34390>; else goto <D.34388>;
  <D.34390>:
  D.34391 = mono_array_length (bounds);
  if (D.34391 == 1) goto <D.34392>; else goto <D.34388>;
  <D.34392>:
  D.34393 = mono_array_addr_with_size (bounds, 8, 0);
  D.34394 = MEM[(gint64 *)D.34393];
  if (D.34394 != 0) goto <D.34395>; else goto <D.34388>;
  <D.34395>:
  bounded = 1;
  goto <D.34389>;
  <D.34388>:
  bounded = 0;
  <D.34389>:
  D.34396 = mono_array_length (lengths);
  aklass = mono_bounded_array_class_get (klass, D.34396, bounded);
  D.34397 = aklass->rank;
  D.34398 = (unsigned int) D.34397;
  D.34399 = D.34398 * 8;
  sizes = __builtin_alloca (D.34399);
  i = 0;
  goto <D.23163>;
  <D.23162>:
  D.34400 = i * 4;
  D.34401 = sizes + D.34400;
  D.34402 = mono_array_addr_with_size (lengths, 8, i);
  D.34403 = MEM[(guint64 *)D.34402];
  D.34404 = (unsigned int) D.34403;
  *D.34401 = D.34404;
  if (bounds != 0B) goto <D.34405>; else goto <D.34406>;
  <D.34405>:
  D.34397 = aklass->rank;
  D.34407 = (unsigned int) D.34397;
  D.34408 = D.34407 + i;
  D.34409 = D.34408 * 4;
  D.34410 = sizes + D.34409;
  D.34411 = mono_array_addr_with_size (bounds, 8, i);
  D.34412 = MEM[(guint64 *)D.34411];
  D.34413 = (unsigned int) D.34412;
  *D.34410 = D.34413;
  goto <D.34414>;
  <D.34406>:
  D.34397 = aklass->rank;
  D.34407 = (unsigned int) D.34397;
  D.34408 = D.34407 + i;
  D.34409 = D.34408 * 4;
  D.34410 = sizes + D.34409;
  *D.34410 = 0;
  <D.34414>:
  i = i + 1;
  <D.23163>:
  D.34397 = aklass->rank;
  D.34407 = (unsigned int) D.34397;
  if (D.34407 > i) goto <D.23162>; else goto <D.23164>;
  <D.23164>:
  D.34415 = MEM[(struct MonoObject *)type].vtable;
  D.34416 = D.34415->domain;
  D.34397 = aklass->rank;
  D.34398 = (unsigned int) D.34397;
  D.34417 = D.34398 * 4;
  D.34418 = sizes + D.34417;
  array = mono_array_new_full (D.34416, aklass, sizes, D.34418);
  D.34419 = array;
  return D.34419;
}


ves_icall_System_Array_CreateInstanceImpl (struct MonoReflectionType * type, struct MonoArray * lengths, struct MonoArray * bounds)
{
  _Bool D.34421;
  long int D.34422;
  long int D.34423;
  _Bool D.34428;
  long int D.34429;
  long int D.34430;
  unsigned int D.34435;
  _Bool D.34436;
  long int D.34437;
  long int D.34438;
  unsigned int D.34445;
  unsigned int D.34446;
  _Bool D.34447;
  long int D.34448;
  long int D.34449;
  char * D.34454;
  int D.34455;
  struct MonoException * D.34458;
  unsigned int D.34459;
  struct MonoType * D.34460;
  unsigned int D.34464;
  char * D.34466;
  int D.34467;
  unsigned int D.34469;
  unsigned char D.34470;
  unsigned int D.34471;
  unsigned int D.34472;
  unsigned int D.34473;
  uintptr_t * D.34474;
  char * D.34475;
  unsigned int D.34476;
  unsigned int D.34479;
  unsigned int D.34480;
  unsigned int D.34481;
  uintptr_t * D.34482;
  char * D.34483;
  int D.34484;
  unsigned int D.34485;
  struct MonoVTable * D.34487;
  struct MonoDomain * D.34488;
  unsigned int D.34489;
  intptr_t * D.34490;
  struct MonoArray * D.34491;
  struct MonoClass * aklass;
  struct MonoClass * klass;
  struct MonoArray * array;
  uintptr_t * sizes;
  uintptr_t i;
  gboolean bounded;

  bounded = 0;
  D.34421 = type == 0B;
  D.34422 = (long int) D.34421;
  D.34423 = __builtin_expect (D.34422, 0);
  if (D.34423 != 0) goto <D.34424>; else goto <D.34425>;
  <D.34424>:
  {
    struct MonoException * ex;

    if (type != 0B) goto <D.34426>; else goto <D.34427>;
    <D.34426>:
    <D.34427>:
    ex = mono_get_exception_argument_null ("type");
    mono_raise_exception (ex);
  }
  <D.34425>:
  D.34428 = lengths == 0B;
  D.34429 = (long int) D.34428;
  D.34430 = __builtin_expect (D.34429, 0);
  if (D.34430 != 0) goto <D.34431>; else goto <D.34432>;
  <D.34431>:
  {
    struct MonoException * ex;

    if (lengths != 0B) goto <D.34433>; else goto <D.34434>;
    <D.34433>:
    <D.34434>:
    ex = mono_get_exception_argument_null ("lengths");
    mono_raise_exception (ex);
  }
  <D.34432>:
  D.34435 = mono_array_length (lengths);
  D.34436 = D.34435 == 0;
  D.34437 = (long int) D.34436;
  D.34438 = __builtin_expect (D.34437, 0);
  if (D.34438 != 0) goto <D.34439>; else goto <D.34440>;
  <D.34439>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("assertion `%s\' failed", "mono_array_length (lengths) > 0");
    if (lengths != 0B) goto <D.34441>; else goto <D.34442>;
    <D.34441>:
    <D.34442>:
    ex = mono_get_exception_argument ("lengths", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.34440>:
  if (bounds != 0B) goto <D.34443>; else goto <D.34444>;
  <D.34443>:
  D.34445 = mono_array_length (lengths);
  D.34446 = mono_array_length (bounds);
  D.34447 = D.34445 != D.34446;
  D.34448 = (long int) D.34447;
  D.34449 = __builtin_expect (D.34448, 0);
  if (D.34449 != 0) goto <D.34450>; else goto <D.34451>;
  <D.34450>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("assertion `%s\' failed", "mono_array_length (lengths) == mono_array_length (bounds)");
    if (bounds != 0B) goto <D.34452>; else goto <D.34453>;
    <D.34452>:
    <D.34453>:
    ex = mono_get_exception_argument ("bounds", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.34451>:
  <D.34444>:
  i = 0;
  goto <D.23137>;
  <D.23136>:
  D.34454 = mono_array_addr_with_size (lengths, 4, i);
  D.34455 = MEM[(gint32 *)D.34454];
  if (D.34455 < 0) goto <D.34456>; else goto <D.34457>;
  <D.34456>:
  D.34458 = mono_get_exception_argument_out_of_range (0B);
  mono_raise_exception (D.34458);
  <D.34457>:
  i = i + 1;
  <D.23137>:
  D.34459 = mono_array_length (lengths);
  if (D.34459 > i) goto <D.23136>; else goto <D.23138>;
  <D.23138>:
  D.34460 = type->type;
  klass = mono_class_from_mono_type (D.34460);
  mono_class_init_or_throw (klass);
  if (bounds != 0B) goto <D.34463>; else goto <D.34461>;
  <D.34463>:
  D.34464 = mono_array_length (bounds);
  if (D.34464 == 1) goto <D.34465>; else goto <D.34461>;
  <D.34465>:
  D.34466 = mono_array_addr_with_size (bounds, 4, 0);
  D.34467 = MEM[(gint32 *)D.34466];
  if (D.34467 != 0) goto <D.34468>; else goto <D.34461>;
  <D.34468>:
  bounded = 1;
  goto <D.34462>;
  <D.34461>:
  bounded = 0;
  <D.34462>:
  D.34469 = mono_array_length (lengths);
  aklass = mono_bounded_array_class_get (klass, D.34469, bounded);
  D.34470 = aklass->rank;
  D.34471 = (unsigned int) D.34470;
  D.34472 = D.34471 * 8;
  sizes = __builtin_alloca (D.34472);
  i = 0;
  goto <D.23140>;
  <D.23139>:
  D.34473 = i * 4;
  D.34474 = sizes + D.34473;
  D.34475 = mono_array_addr_with_size (lengths, 4, i);
  D.34476 = MEM[(guint32 *)D.34475];
  *D.34474 = D.34476;
  if (bounds != 0B) goto <D.34477>; else goto <D.34478>;
  <D.34477>:
  D.34470 = aklass->rank;
  D.34479 = (unsigned int) D.34470;
  D.34480 = D.34479 + i;
  D.34481 = D.34480 * 4;
  D.34482 = sizes + D.34481;
  D.34483 = mono_array_addr_with_size (bounds, 4, i);
  D.34484 = MEM[(gint32 *)D.34483];
  D.34485 = (unsigned int) D.34484;
  *D.34482 = D.34485;
  goto <D.34486>;
  <D.34478>:
  D.34470 = aklass->rank;
  D.34479 = (unsigned int) D.34470;
  D.34480 = D.34479 + i;
  D.34481 = D.34480 * 4;
  D.34482 = sizes + D.34481;
  *D.34482 = 0;
  <D.34486>:
  i = i + 1;
  <D.23140>:
  D.34470 = aklass->rank;
  D.34479 = (unsigned int) D.34470;
  if (D.34479 > i) goto <D.23139>; else goto <D.23141>;
  <D.23141>:
  D.34487 = MEM[(struct MonoObject *)type].vtable;
  D.34488 = D.34487->domain;
  D.34470 = aklass->rank;
  D.34471 = (unsigned int) D.34470;
  D.34489 = D.34471 * 4;
  D.34490 = sizes + D.34489;
  array = mono_array_new_full (D.34488, aklass, sizes, D.34490);
  D.34491 = array;
  return D.34491;
}


ves_icall_System_Array_ClearInternal (struct MonoArray * arr, int idx, int length)
{
  struct MonoVTable * D.34493;
  struct MonoClass * D.34494;
  double[0:] * D.34495;
  int D.34496;
  sizetype D.34497;
  void * D.34498;
  int D.34499;
  unsigned int D.34500;
  int sz;

  D.34493 = MEM[(struct MonoObject *)arr].vtable;
  D.34494 = D.34493->klass;
  sz = mono_array_element_size (D.34494);
  D.34495 = &arr->vector;
  D.34496 = sz * idx;
  D.34497 = (sizetype) D.34496;
  D.34498 = D.34495 + D.34497;
  D.34499 = length * sz;
  D.34500 = (unsigned int) D.34499;
  mono_gc_bzero_atomic (D.34498, D.34500);
}


mono_ArgIterator_Setup (struct MonoArgIterator * iter, char * argsp, char * start)
{
  struct MonoMethodSignature * D.34501;
  struct MonoMethodSignature * D.34502;
  short int D.34503;
  int D.34504;
  short unsigned int D.34505;
  int D.34506;
  _Bool D.34507;
  long int D.34508;
  long int D.34509;
  unsigned char D.34512;
  unsigned char D.34513;
  _Bool D.34514;
  long int D.34515;
  long int D.34516;
  void * D.34522;
  int D.34523;

  D.34501 = MEM[(struct MonoMethodSignature * *)argsp];
  iter->sig = D.34501;
  D.34502 = iter->sig;
  D.34503 = D.34502->sentinelpos;
  D.34504 = (int) D.34503;
  D.34502 = iter->sig;
  D.34505 = D.34502->param_count;
  D.34506 = (int) D.34505;
  D.34507 = D.34504 > D.34506;
  D.34508 = (long int) D.34507;
  D.34509 = __builtin_expect (D.34508, 0);
  if (D.34509 != 0) goto <D.34510>; else goto <D.34511>;
  <D.34510>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7168, "iter->sig->sentinelpos <= iter->sig->param_count");
  <D.34511>:
  D.34502 = iter->sig;
  D.34512 = BIT_FIELD_REF <*D.34502, 8, 80>;
  D.34513 = D.34512 & 63;
  D.34514 = D.34513 != 5;
  D.34515 = (long int) D.34514;
  D.34516 = __builtin_expect (D.34515, 0);
  if (D.34516 != 0) goto <D.34517>; else goto <D.34518>;
  <D.34517>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7169, "iter->sig->call_convention == MONO_CALL_VARARG");
  <D.34518>:
  iter->next_arg = 0;
  if (start != 0B) goto <D.34519>; else goto <D.34520>;
  <D.34519>:
  iter->args = start;
  goto <D.34521>;
  <D.34520>:
  D.34522 = argsp + 4;
  iter->args = D.34522;
  <D.34521>:
  D.34502 = iter->sig;
  D.34505 = D.34502->param_count;
  D.34506 = (int) D.34505;
  D.34502 = iter->sig;
  D.34503 = D.34502->sentinelpos;
  D.34504 = (int) D.34503;
  D.34523 = D.34506 - D.34504;
  iter->num_args = D.34523;
}


mono_ArgIterator_IntGetNextArgType (struct MonoArgIterator * iter)
{
  struct MonoMethodSignature * D.34524;
  short int D.34525;
  int D.34526;
  int D.34527;
  short unsigned int D.34528;
  int D.34529;
  _Bool D.34530;
  long int D.34531;
  long int D.34532;
  struct MonoType * D.34535;
  gint i;

  D.34524 = iter->sig;
  D.34525 = D.34524->sentinelpos;
  D.34526 = (int) D.34525;
  D.34527 = iter->next_arg;
  i = D.34526 + D.34527;
  D.34524 = iter->sig;
  D.34528 = D.34524->param_count;
  D.34529 = (int) D.34528;
  D.34530 = D.34529 <= i;
  D.34531 = (long int) D.34530;
  D.34532 = __builtin_expect (D.34531, 0);
  if (D.34532 != 0) goto <D.34533>; else goto <D.34534>;
  <D.34533>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7267, "i < iter->sig->param_count");
  <D.34534>:
  D.34524 = iter->sig;
  D.34535 = D.34524->params[i];
  return D.34535;
}


mono_ArgIterator_IntGetNextArgT (struct MonoArgIterator * iter, struct MonoType * type)
{
  struct MonoMethodSignature * D.34538;
  short int D.34539;
  int D.34540;
  int D.34541;
  int D.34542;
  short unsigned int D.34543;
  unsigned int D.34544;
  _Bool D.34545;
  long int D.34546;
  long int D.34547;
  struct MonoType * D.34550;
  int D.34551;
  struct MonoType * D.34554;
  struct MonoClass * D.34555;
  int D.34556;
  void * D.34557;
  unsigned int D.34558;
  int align.316;
  unsigned int align.317;
  unsigned int D.34561;
  unsigned int D.34562;
  int D.34563;
  unsigned int D.34564;
  unsigned int D.34565;
  void * D.34566;
  void * D.34567;
  int D.34568;
  guint32 i;
  guint32 arg_size;
  gint32 align;
  struct MonoTypedRef res;

  try
    {
      D.34538 = iter->sig;
      D.34539 = D.34538->sentinelpos;
      D.34540 = (int) D.34539;
      D.34541 = iter->next_arg;
      D.34542 = D.34540 + D.34541;
      i = (guint32) D.34542;
      D.34538 = iter->sig;
      D.34543 = D.34538->param_count;
      D.34544 = (unsigned int) D.34543;
      D.34545 = D.34544 <= i;
      D.34546 = (long int) D.34545;
      D.34547 = __builtin_expect (D.34546, 0);
      if (D.34547 != 0) goto <D.34548>; else goto <D.34549>;
      <D.34548>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7233, "i < iter->sig->param_count");
      <D.34549>:
      goto <D.25659>;
      <D.25660>:
      D.34538 = iter->sig;
      D.34550 = D.34538->params[i];
      D.34551 = mono_metadata_type_equal (type, D.34550);
      if (D.34551 == 0) goto <D.34552>; else goto <D.34553>;
      <D.34552>:
      // predicted unlikely by continue predictor.
      goto <D.25659>;
      <D.34553>:
      D.34538 = iter->sig;
      D.34550 = D.34538->params[i];
      res.type = D.34550;
      D.34554 = res.type;
      D.34555 = mono_class_from_mono_type (D.34554);
      res.klass = D.34555;
      D.34554 = res.type;
      D.34556 = mono_type_stack_size (D.34554, &align);
      arg_size = (guint32) D.34556;
      D.34557 = iter->args;
      D.34558 = (unsigned int) D.34557;
      align.316 = align;
      align.317 = (unsigned int) align.316;
      D.34561 = D.34558 + align.317;
      D.34562 = D.34561 + 4294967295;
      align.316 = align;
      D.34563 = -align.316;
      D.34564 = (unsigned int) D.34563;
      D.34565 = D.34562 & D.34564;
      D.34566 = (void *) D.34565;
      iter->args = D.34566;
      D.34557 = iter->args;
      res.value = D.34557;
      D.34557 = iter->args;
      D.34567 = D.34557 + arg_size;
      iter->args = D.34567;
      D.34541 = iter->next_arg;
      D.34568 = D.34541 + 1;
      iter->next_arg = D.34568;
      <retval> = res;
      return <retval>;
      <D.25659>:
      D.34538 = iter->sig;
      D.34543 = D.34538->param_count;
      D.34544 = (unsigned int) D.34543;
      if (D.34544 > i) goto <D.25660>; else goto <D.25661>;
      <D.25661>:
      res.type = 0B;
      res.value = 0B;
      res.klass = 0B;
      <retval> = res;
      return <retval>;
    }
  finally
    {
      align = {CLOBBER};
      res = {CLOBBER};
    }
}


mono_ArgIterator_IntGetNextArg (struct MonoArgIterator * iter)
{
  struct MonoMethodSignature * D.34572;
  short int D.34573;
  int D.34574;
  int D.34575;
  int D.34576;
  short unsigned int D.34577;
  unsigned int D.34578;
  _Bool D.34579;
  long int D.34580;
  long int D.34581;
  struct MonoType * D.34584;
  struct MonoType * D.34585;
  struct MonoClass * D.34586;
  int D.34587;
  void * D.34588;
  unsigned int D.34589;
  int align.318;
  unsigned int align.319;
  unsigned int D.34592;
  unsigned int D.34593;
  int D.34594;
  unsigned int D.34595;
  unsigned int D.34596;
  void * D.34597;
  void * D.34598;
  int D.34599;
  guint32 i;
  guint32 arg_size;
  gint32 align;
  struct MonoTypedRef res;

  try
    {
      D.34572 = iter->sig;
      D.34573 = D.34572->sentinelpos;
      D.34574 = (int) D.34573;
      D.34575 = iter->next_arg;
      D.34576 = D.34574 + D.34575;
      i = (guint32) D.34576;
      D.34572 = iter->sig;
      D.34577 = D.34572->param_count;
      D.34578 = (unsigned int) D.34577;
      D.34579 = D.34578 <= i;
      D.34580 = (long int) D.34579;
      D.34581 = __builtin_expect (D.34580, 0);
      if (D.34581 != 0) goto <D.34582>; else goto <D.34583>;
      <D.34582>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7193, "i < iter->sig->param_count");
      <D.34583>:
      D.34572 = iter->sig;
      D.34584 = D.34572->params[i];
      res.type = D.34584;
      D.34585 = res.type;
      D.34586 = mono_class_from_mono_type (D.34585);
      res.klass = D.34586;
      D.34585 = res.type;
      D.34587 = mono_type_stack_size (D.34585, &align);
      arg_size = (guint32) D.34587;
      D.34588 = iter->args;
      D.34589 = (unsigned int) D.34588;
      align.318 = align;
      align.319 = (unsigned int) align.318;
      D.34592 = D.34589 + align.319;
      D.34593 = D.34592 + 4294967295;
      align.318 = align;
      D.34594 = -align.318;
      D.34595 = (unsigned int) D.34594;
      D.34596 = D.34593 & D.34595;
      D.34597 = (void *) D.34596;
      iter->args = D.34597;
      D.34588 = iter->args;
      res.value = D.34588;
      D.34588 = iter->args;
      D.34598 = D.34588 + arg_size;
      iter->args = D.34598;
      D.34575 = iter->next_arg;
      D.34599 = D.34575 + 1;
      iter->next_arg = D.34599;
      <retval> = res;
      return <retval>;
    }
  finally
    {
      align = {CLOBBER};
      res = {CLOBBER};
    }
}


ves_icall_System_Activator_CreateInstanceInternal (struct MonoReflectionType * type)
{
  struct MonoVTable * D.34602;
  struct MonoType * D.34603;
  int D.34604;
  struct MonoObject * D.34607;
  struct MonoClass * klass;
  struct MonoDomain * domain;

  D.34602 = MEM[(struct MonoObject *)type].vtable;
  domain = D.34602->domain;
  D.34603 = type->type;
  klass = mono_class_from_mono_type (D.34603);
  mono_class_init_or_throw (klass);
  D.34604 = mono_class_is_nullable (klass);
  if (D.34604 != 0) goto <D.34605>; else goto <D.34606>;
  <D.34605>:
  D.34607 = 0B;
  return D.34607;
  <D.34606>:
  D.34607 = mono_object_new (domain, klass);
  return D.34607;
}


ves_icall_Mono_Runtime_GetDisplayName ()
{
  struct MonoRuntimeCallbacks * D.34609;
  char * (*<T3178>) (void) D.34610;
  struct MonoDomain * D.34611;
  struct MonoString * D.34612;
  char * info;
  struct MonoString * display_name;

  D.34609 = mono_get_runtime_callbacks ();
  D.34610 = D.34609->get_runtime_build_info;
  info = D.34610 ();
  D.34611 = mono_domain_get ();
  display_name = mono_string_new (D.34611, info);
  monoeg_g_free (info);
  D.34612 = display_name;
  return D.34612;
}


compare_method_imap (const void * key, const void * elem)
{
  short unsigned int D.34614;
  sizetype D.34615;
  int D.34616;
  int D.27518;
  const char * method_name;

  D.34614 = MEM[(guint16 *)elem];
  D.34615 = (sizetype) D.34614;
  method_name = &icall_names_str + D.34615;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.27518 = __builtin_strcmp (key, method_name);
  }
  D.34616 = D.27518;
  return D.34616;
}


mono_lookup_icall_symbol (struct MonoMethod * m)
{
  struct _IO_FILE * stderr.320;
  const char * D.34619;

  stderr.320 = stderr;
  fprintf (stderr.320, "icall symbol maps not enabled, pass --enable-icall-symbol-map to configure.\n");
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 8216);
  D.34619 = 0B;
  return D.34619;
}


fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.34621;

  D.34621 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.34621;
}


mono_create_icall_signature (const char * sigstr)
{
  struct GHashTable * D.34623;
  struct MonoMethodSignature * D.34626;
  gchar * D.34627;
  int D.34628;
  unsigned int D.34629;
  gchar * D.34630;
  struct MonoType * D.34631;
  int D.34632;
  unsigned int i.321;
  unsigned int D.34634;
  gchar * * D.34635;
  gchar * D.34636;
  struct MonoType * D.34637;
  gchar * * parts;
  int i;
  int len;
  gchar * * tmp;
  struct MonoMethodSignature * res;
  struct MonoMethodSignature * res2;
  struct MonoImage * corlib;

  corlib = mono_defaults.corlib;
  mono_image_lock (corlib);
  D.34623 = corlib->helper_signatures;
  res = monoeg_g_hash_table_lookup (D.34623, sigstr);
  mono_image_unlock (corlib);
  if (res != 0B) goto <D.34624>; else goto <D.34625>;
  <D.34624>:
  D.34626 = res;
  return D.34626;
  <D.34625>:
  parts = monoeg_g_strsplit (sigstr, " ", 256);
  tmp = parts;
  len = 0;
  goto <D.27742>;
  <D.27741>:
  len = len + 1;
  tmp = tmp + 4;
  <D.27742>:
  D.34627 = *tmp;
  if (D.34627 != 0B) goto <D.27741>; else goto <D.27743>;
  <D.27743>:
  D.34628 = len + -1;
  D.34629 = (unsigned int) D.34628;
  res = mono_metadata_signature_alloc (corlib, D.34629);
  res->pinvoke = 1;
  D.34630 = *parts;
  D.34631 = type_from_typename (D.34630);
  res->ret = D.34631;
  i = 1;
  goto <D.27745>;
  <D.27744>:
  D.34632 = i + -1;
  i.321 = (unsigned int) i;
  D.34634 = i.321 * 4;
  D.34635 = parts + D.34634;
  D.34636 = *D.34635;
  D.34637 = type_from_typename (D.34636);
  res->params[D.34632] = D.34637;
  i = i + 1;
  <D.27745>:
  if (i < len) goto <D.27744>; else goto <D.27746>;
  <D.27746>:
  monoeg_g_strfreev (parts);
  mono_image_lock (corlib);
  D.34623 = corlib->helper_signatures;
  res2 = monoeg_g_hash_table_lookup (D.34623, sigstr);
  if (res2 != 0B) goto <D.34638>; else goto <D.34639>;
  <D.34638>:
  res = res2;
  goto <D.34640>;
  <D.34639>:
  D.34623 = corlib->helper_signatures;
  monoeg_g_hash_table_insert_replace (D.34623, sigstr, res, 0);
  <D.34640>:
  mono_image_unlock (corlib);
  D.34626 = res;
  return D.34626;
}


type_from_typename (char * typename)
{
  int D.27576;
  int iftmp.322;
  int D.27575;
  const char[4] * D.34645;
  unsigned char D.34646;
  int D.34647;
  unsigned char D.34648;
  int D.34649;
  _Bool D.34650;
  _Bool D.34651;
  _Bool D.34652;
  const unsigned char * D.34655;
  unsigned char D.34656;
  int D.34657;
  const unsigned char * D.34658;
  unsigned char D.34659;
  int D.34660;
  _Bool D.34661;
  _Bool D.34662;
  const unsigned char * D.34665;
  unsigned char D.34666;
  int D.34667;
  const unsigned char * D.34668;
  unsigned char D.34669;
  int D.34670;
  _Bool D.34671;
  _Bool D.34672;
  const unsigned char * D.34675;
  unsigned char D.34676;
  int D.34677;
  const unsigned char * D.34678;
  unsigned char D.34679;
  int D.34680;
  int D.27585;
  int iftmp.323;
  int D.27584;
  const char[4] * D.34688;
  unsigned char D.34689;
  int D.34690;
  unsigned char D.34691;
  int D.34692;
  _Bool D.34693;
  _Bool D.34694;
  _Bool D.34695;
  const unsigned char * D.34698;
  unsigned char D.34699;
  int D.34700;
  const unsigned char * D.34701;
  unsigned char D.34702;
  int D.34703;
  _Bool D.34704;
  _Bool D.34705;
  const unsigned char * D.34708;
  unsigned char D.34709;
  int D.34710;
  const unsigned char * D.34711;
  unsigned char D.34712;
  int D.34713;
  _Bool D.34714;
  _Bool D.34715;
  const unsigned char * D.34718;
  unsigned char D.34719;
  int D.34720;
  const unsigned char * D.34721;
  unsigned char D.34722;
  int D.34723;
  int D.27594;
  int iftmp.324;
  int D.27593;
  const char[5] * D.34731;
  unsigned char D.34732;
  int D.34733;
  unsigned char D.34734;
  int D.34735;
  _Bool D.34736;
  _Bool D.34737;
  _Bool D.34738;
  const unsigned char * D.34741;
  unsigned char D.34742;
  int D.34743;
  const unsigned char * D.34744;
  unsigned char D.34745;
  int D.34746;
  _Bool D.34747;
  _Bool D.34748;
  const unsigned char * D.34751;
  unsigned char D.34752;
  int D.34753;
  const unsigned char * D.34754;
  unsigned char D.34755;
  int D.34756;
  _Bool D.34757;
  _Bool D.34758;
  const unsigned char * D.34761;
  unsigned char D.34762;
  int D.34763;
  const unsigned char * D.34764;
  unsigned char D.34765;
  int D.34766;
  int D.27603;
  int iftmp.325;
  int D.27602;
  const char[6] * D.34774;
  unsigned char D.34775;
  int D.34776;
  unsigned char D.34777;
  int D.34778;
  _Bool D.34779;
  _Bool D.34780;
  _Bool D.34781;
  const unsigned char * D.34784;
  unsigned char D.34785;
  int D.34786;
  const unsigned char * D.34787;
  unsigned char D.34788;
  int D.34789;
  _Bool D.34790;
  _Bool D.34791;
  const unsigned char * D.34794;
  unsigned char D.34795;
  int D.34796;
  const unsigned char * D.34797;
  unsigned char D.34798;
  int D.34799;
  _Bool D.34800;
  _Bool D.34801;
  const unsigned char * D.34804;
  unsigned char D.34805;
  int D.34806;
  const unsigned char * D.34807;
  unsigned char D.34808;
  int D.34809;
  int D.27612;
  int iftmp.326;
  int D.27611;
  const char[7] * D.34817;
  unsigned char D.34818;
  int D.34819;
  unsigned char D.34820;
  int D.34821;
  _Bool D.34822;
  _Bool D.34823;
  _Bool D.34824;
  const unsigned char * D.34827;
  unsigned char D.34828;
  int D.34829;
  const unsigned char * D.34830;
  unsigned char D.34831;
  int D.34832;
  _Bool D.34833;
  _Bool D.34834;
  const unsigned char * D.34837;
  unsigned char D.34838;
  int D.34839;
  const unsigned char * D.34840;
  unsigned char D.34841;
  int D.34842;
  _Bool D.34843;
  _Bool D.34844;
  const unsigned char * D.34847;
  unsigned char D.34848;
  int D.34849;
  const unsigned char * D.34850;
  unsigned char D.34851;
  int D.34852;
  int D.27621;
  int iftmp.327;
  int D.27620;
  const char[5] * D.34860;
  unsigned char D.34861;
  int D.34862;
  unsigned char D.34863;
  int D.34864;
  _Bool D.34865;
  _Bool D.34866;
  _Bool D.34867;
  const unsigned char * D.34870;
  unsigned char D.34871;
  int D.34872;
  const unsigned char * D.34873;
  unsigned char D.34874;
  int D.34875;
  _Bool D.34876;
  _Bool D.34877;
  const unsigned char * D.34880;
  unsigned char D.34881;
  int D.34882;
  const unsigned char * D.34883;
  unsigned char D.34884;
  int D.34885;
  _Bool D.34886;
  _Bool D.34887;
  const unsigned char * D.34890;
  unsigned char D.34891;
  int D.34892;
  const unsigned char * D.34893;
  unsigned char D.34894;
  int D.34895;
  int D.27630;
  int iftmp.328;
  int D.27629;
  const char[6] * D.34903;
  unsigned char D.34904;
  int D.34905;
  unsigned char D.34906;
  int D.34907;
  _Bool D.34908;
  _Bool D.34909;
  _Bool D.34910;
  const unsigned char * D.34913;
  unsigned char D.34914;
  int D.34915;
  const unsigned char * D.34916;
  unsigned char D.34917;
  int D.34918;
  _Bool D.34919;
  _Bool D.34920;
  const unsigned char * D.34923;
  unsigned char D.34924;
  int D.34925;
  const unsigned char * D.34926;
  unsigned char D.34927;
  int D.34928;
  _Bool D.34929;
  _Bool D.34930;
  const unsigned char * D.34933;
  unsigned char D.34934;
  int D.34935;
  const unsigned char * D.34936;
  unsigned char D.34937;
  int D.34938;
  int D.27639;
  int iftmp.329;
  int D.27638;
  const char[6] * D.34946;
  unsigned char D.34947;
  int D.34948;
  unsigned char D.34949;
  int D.34950;
  _Bool D.34951;
  _Bool D.34952;
  _Bool D.34953;
  const unsigned char * D.34956;
  unsigned char D.34957;
  int D.34958;
  const unsigned char * D.34959;
  unsigned char D.34960;
  int D.34961;
  _Bool D.34962;
  _Bool D.34963;
  const unsigned char * D.34966;
  unsigned char D.34967;
  int D.34968;
  const unsigned char * D.34969;
  unsigned char D.34970;
  int D.34971;
  _Bool D.34972;
  _Bool D.34973;
  const unsigned char * D.34976;
  unsigned char D.34977;
  int D.34978;
  const unsigned char * D.34979;
  unsigned char D.34980;
  int D.34981;
  int D.27648;
  int iftmp.330;
  int D.27647;
  const char[7] * D.34989;
  unsigned char D.34990;
  int D.34991;
  unsigned char D.34992;
  int D.34993;
  _Bool D.34994;
  _Bool D.34995;
  _Bool D.34996;
  const unsigned char * D.34999;
  unsigned char D.35000;
  int D.35001;
  const unsigned char * D.35002;
  unsigned char D.35003;
  int D.35004;
  _Bool D.35005;
  _Bool D.35006;
  const unsigned char * D.35009;
  unsigned char D.35010;
  int D.35011;
  const unsigned char * D.35012;
  unsigned char D.35013;
  int D.35014;
  _Bool D.35015;
  _Bool D.35016;
  const unsigned char * D.35019;
  unsigned char D.35020;
  int D.35021;
  const unsigned char * D.35022;
  unsigned char D.35023;
  int D.35024;
  int D.27657;
  int iftmp.331;
  int D.27656;
  const char[5] * D.35032;
  unsigned char D.35033;
  int D.35034;
  unsigned char D.35035;
  int D.35036;
  _Bool D.35037;
  _Bool D.35038;
  _Bool D.35039;
  const unsigned char * D.35042;
  unsigned char D.35043;
  int D.35044;
  const unsigned char * D.35045;
  unsigned char D.35046;
  int D.35047;
  _Bool D.35048;
  _Bool D.35049;
  const unsigned char * D.35052;
  unsigned char D.35053;
  int D.35054;
  const unsigned char * D.35055;
  unsigned char D.35056;
  int D.35057;
  _Bool D.35058;
  _Bool D.35059;
  const unsigned char * D.35062;
  unsigned char D.35063;
  int D.35064;
  const unsigned char * D.35065;
  unsigned char D.35066;
  int D.35067;
  int D.27666;
  int iftmp.332;
  int D.27665;
  const char[6] * D.35075;
  unsigned char D.35076;
  int D.35077;
  unsigned char D.35078;
  int D.35079;
  _Bool D.35080;
  _Bool D.35081;
  _Bool D.35082;
  const unsigned char * D.35085;
  unsigned char D.35086;
  int D.35087;
  const unsigned char * D.35088;
  unsigned char D.35089;
  int D.35090;
  _Bool D.35091;
  _Bool D.35092;
  const unsigned char * D.35095;
  unsigned char D.35096;
  int D.35097;
  const unsigned char * D.35098;
  unsigned char D.35099;
  int D.35100;
  _Bool D.35101;
  _Bool D.35102;
  const unsigned char * D.35105;
  unsigned char D.35106;
  int D.35107;
  const unsigned char * D.35108;
  unsigned char D.35109;
  int D.35110;
  int D.27675;
  int iftmp.333;
  int D.27674;
  const char[6] * D.35118;
  unsigned char D.35119;
  int D.35120;
  unsigned char D.35121;
  int D.35122;
  _Bool D.35123;
  _Bool D.35124;
  _Bool D.35125;
  const unsigned char * D.35128;
  unsigned char D.35129;
  int D.35130;
  const unsigned char * D.35131;
  unsigned char D.35132;
  int D.35133;
  _Bool D.35134;
  _Bool D.35135;
  const unsigned char * D.35138;
  unsigned char D.35139;
  int D.35140;
  const unsigned char * D.35141;
  unsigned char D.35142;
  int D.35143;
  _Bool D.35144;
  _Bool D.35145;
  const unsigned char * D.35148;
  unsigned char D.35149;
  int D.35150;
  const unsigned char * D.35151;
  unsigned char D.35152;
  int D.35153;
  int D.27684;
  int iftmp.334;
  int D.27683;
  const char[7] * D.35161;
  unsigned char D.35162;
  int D.35163;
  unsigned char D.35164;
  int D.35165;
  _Bool D.35166;
  _Bool D.35167;
  _Bool D.35168;
  const unsigned char * D.35171;
  unsigned char D.35172;
  int D.35173;
  const unsigned char * D.35174;
  unsigned char D.35175;
  int D.35176;
  _Bool D.35177;
  _Bool D.35178;
  const unsigned char * D.35181;
  unsigned char D.35182;
  int D.35183;
  const unsigned char * D.35184;
  unsigned char D.35185;
  int D.35186;
  _Bool D.35187;
  _Bool D.35188;
  const unsigned char * D.35191;
  unsigned char D.35192;
  int D.35193;
  const unsigned char * D.35194;
  unsigned char D.35195;
  int D.35196;
  int D.27693;
  int iftmp.335;
  int D.27692;
  const char[7] * D.35204;
  unsigned char D.35205;
  int D.35206;
  unsigned char D.35207;
  int D.35208;
  _Bool D.35209;
  _Bool D.35210;
  _Bool D.35211;
  const unsigned char * D.35214;
  unsigned char D.35215;
  int D.35216;
  const unsigned char * D.35217;
  unsigned char D.35218;
  int D.35219;
  _Bool D.35220;
  _Bool D.35221;
  const unsigned char * D.35224;
  unsigned char D.35225;
  int D.35226;
  const unsigned char * D.35227;
  unsigned char D.35228;
  int D.35229;
  _Bool D.35230;
  _Bool D.35231;
  const unsigned char * D.35234;
  unsigned char D.35235;
  int D.35236;
  const unsigned char * D.35237;
  unsigned char D.35238;
  int D.35239;
  int D.27702;
  int iftmp.336;
  int D.27701;
  const char[4] * D.35247;
  unsigned char D.35248;
  int D.35249;
  unsigned char D.35250;
  int D.35251;
  _Bool D.35252;
  _Bool D.35253;
  _Bool D.35254;
  const unsigned char * D.35257;
  unsigned char D.35258;
  int D.35259;
  const unsigned char * D.35260;
  unsigned char D.35261;
  int D.35262;
  _Bool D.35263;
  _Bool D.35264;
  const unsigned char * D.35267;
  unsigned char D.35268;
  int D.35269;
  const unsigned char * D.35270;
  unsigned char D.35271;
  int D.35272;
  _Bool D.35273;
  _Bool D.35274;
  const unsigned char * D.35277;
  unsigned char D.35278;
  int D.35279;
  const unsigned char * D.35280;
  unsigned char D.35281;
  int D.35282;
  int D.27711;
  int iftmp.337;
  int D.27710;
  const char[7] * D.35290;
  unsigned char D.35291;
  int D.35292;
  unsigned char D.35293;
  int D.35294;
  _Bool D.35295;
  _Bool D.35296;
  _Bool D.35297;
  const unsigned char * D.35300;
  unsigned char D.35301;
  int D.35302;
  const unsigned char * D.35303;
  unsigned char D.35304;
  int D.35305;
  _Bool D.35306;
  _Bool D.35307;
  const unsigned char * D.35310;
  unsigned char D.35311;
  int D.35312;
  const unsigned char * D.35313;
  unsigned char D.35314;
  int D.35315;
  _Bool D.35316;
  _Bool D.35317;
  const unsigned char * D.35320;
  unsigned char D.35321;
  int D.35322;
  const unsigned char * D.35323;
  unsigned char D.35324;
  int D.35325;
  int D.27720;
  int iftmp.338;
  int D.27719;
  const char[5] * D.35333;
  unsigned char D.35334;
  int D.35335;
  unsigned char D.35336;
  int D.35337;
  _Bool D.35338;
  _Bool D.35339;
  _Bool D.35340;
  const unsigned char * D.35343;
  unsigned char D.35344;
  int D.35345;
  const unsigned char * D.35346;
  unsigned char D.35347;
  int D.35348;
  _Bool D.35349;
  _Bool D.35350;
  const unsigned char * D.35353;
  unsigned char D.35354;
  int D.35355;
  const unsigned char * D.35356;
  unsigned char D.35357;
  int D.35358;
  _Bool D.35359;
  _Bool D.35360;
  const unsigned char * D.35363;
  unsigned char D.35364;
  int D.35365;
  const unsigned char * D.35366;
  unsigned char D.35367;
  int D.35368;
  int D.27729;
  int iftmp.339;
  int D.27728;
  const char[8] * D.35376;
  unsigned char D.35377;
  int D.35378;
  unsigned char D.35379;
  int D.35380;
  _Bool D.35381;
  _Bool D.35382;
  _Bool D.35383;
  const unsigned char * D.35386;
  unsigned char D.35387;
  int D.35388;
  const unsigned char * D.35389;
  unsigned char D.35390;
  int D.35391;
  _Bool D.35392;
  _Bool D.35393;
  const unsigned char * D.35396;
  unsigned char D.35397;
  int D.35398;
  const unsigned char * D.35399;
  unsigned char D.35400;
  int D.35401;
  _Bool D.35402;
  _Bool D.35403;
  const unsigned char * D.35406;
  unsigned char D.35407;
  int D.35408;
  const unsigned char * D.35409;
  unsigned char D.35410;
  int D.35411;
  struct MonoType * D.35416;
  struct MonoClass * klass;

  klass = 0B;
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 3;
    if (__s2_len <= 3) goto <D.34643>; else goto <D.34644>;
    <D.34643>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.34645 = "int";
      D.34646 = MEM[(const unsigned char *)D.34645];
      D.34647 = (int) D.34646;
      D.34648 = *__s2;
      D.34649 = (int) D.34648;
      __result = D.34647 - D.34649;
      {
        D.34650 = __s2_len != 0;
        D.34651 = __result == 0;
        D.34652 = D.34650 & D.34651;
        if (D.34652 != 0) goto <D.34653>; else goto <D.34654>;
        <D.34653>:
        D.34655 = &MEM[(void *)"int" + 1B];
        D.34656 = *D.34655;
        D.34657 = (int) D.34656;
        D.34658 = __s2 + 1;
        D.34659 = *D.34658;
        D.34660 = (int) D.34659;
        __result = D.34657 - D.34660;
        D.34661 = __s2_len > 1;
        D.34651 = __result == 0;
        D.34662 = D.34661 & D.34651;
        if (D.34662 != 0) goto <D.34663>; else goto <D.34664>;
        <D.34663>:
        D.34665 = &MEM[(void *)"int" + 2B];
        D.34666 = *D.34665;
        D.34667 = (int) D.34666;
        D.34668 = __s2 + 2;
        D.34669 = *D.34668;
        D.34670 = (int) D.34669;
        __result = D.34667 - D.34670;
        D.34671 = __s2_len > 2;
        D.34651 = __result == 0;
        D.34672 = D.34671 & D.34651;
        if (D.34672 != 0) goto <D.34673>; else goto <D.34674>;
        <D.34673>:
        D.34675 = &MEM[(void *)"int" + 3B];
        D.34676 = *D.34675;
        D.34677 = (int) D.34676;
        D.34678 = __s2 + 3;
        D.34679 = *D.34678;
        D.34680 = (int) D.34679;
        __result = D.34677 - D.34680;
        <D.34674>:
        <D.34664>:
        <D.34654>:
      }
      D.27575 = __result;
    }
    iftmp.322 = -D.27575;
    goto <D.34681>;
    <D.34644>:
    iftmp.322 = __builtin_strcmp (typename, "int");
    <D.34681>:
    D.27576 = iftmp.322;
  }
  if (D.27576 == 0) goto <D.34682>; else goto <D.34683>;
  <D.34682>:
  klass = mono_defaults.int_class;
  goto <D.34684>;
  <D.34683>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 3;
    if (__s2_len <= 3) goto <D.34686>; else goto <D.34687>;
    <D.34686>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.34688 = "ptr";
      D.34689 = MEM[(const unsigned char *)D.34688];
      D.34690 = (int) D.34689;
      D.34691 = *__s2;
      D.34692 = (int) D.34691;
      __result = D.34690 - D.34692;
      {
        D.34693 = __s2_len != 0;
        D.34694 = __result == 0;
        D.34695 = D.34693 & D.34694;
        if (D.34695 != 0) goto <D.34696>; else goto <D.34697>;
        <D.34696>:
        D.34698 = &MEM[(void *)"ptr" + 1B];
        D.34699 = *D.34698;
        D.34700 = (int) D.34699;
        D.34701 = __s2 + 1;
        D.34702 = *D.34701;
        D.34703 = (int) D.34702;
        __result = D.34700 - D.34703;
        D.34704 = __s2_len > 1;
        D.34694 = __result == 0;
        D.34705 = D.34704 & D.34694;
        if (D.34705 != 0) goto <D.34706>; else goto <D.34707>;
        <D.34706>:
        D.34708 = &MEM[(void *)"ptr" + 2B];
        D.34709 = *D.34708;
        D.34710 = (int) D.34709;
        D.34711 = __s2 + 2;
        D.34712 = *D.34711;
        D.34713 = (int) D.34712;
        __result = D.34710 - D.34713;
        D.34714 = __s2_len > 2;
        D.34694 = __result == 0;
        D.34715 = D.34714 & D.34694;
        if (D.34715 != 0) goto <D.34716>; else goto <D.34717>;
        <D.34716>:
        D.34718 = &MEM[(void *)"ptr" + 3B];
        D.34719 = *D.34718;
        D.34720 = (int) D.34719;
        D.34721 = __s2 + 3;
        D.34722 = *D.34721;
        D.34723 = (int) D.34722;
        __result = D.34720 - D.34723;
        <D.34717>:
        <D.34707>:
        <D.34697>:
      }
      D.27584 = __result;
    }
    iftmp.323 = -D.27584;
    goto <D.34724>;
    <D.34687>:
    iftmp.323 = __builtin_strcmp (typename, "ptr");
    <D.34724>:
    D.27585 = iftmp.323;
  }
  if (D.27585 == 0) goto <D.34725>; else goto <D.34726>;
  <D.34725>:
  klass = mono_defaults.int_class;
  goto <D.34727>;
  <D.34726>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.34729>; else goto <D.34730>;
    <D.34729>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.34731 = "void";
      D.34732 = MEM[(const unsigned char *)D.34731];
      D.34733 = (int) D.34732;
      D.34734 = *__s2;
      D.34735 = (int) D.34734;
      __result = D.34733 - D.34735;
      {
        D.34736 = __s2_len != 0;
        D.34737 = __result == 0;
        D.34738 = D.34736 & D.34737;
        if (D.34738 != 0) goto <D.34739>; else goto <D.34740>;
        <D.34739>:
        D.34741 = &MEM[(void *)"void" + 1B];
        D.34742 = *D.34741;
        D.34743 = (int) D.34742;
        D.34744 = __s2 + 1;
        D.34745 = *D.34744;
        D.34746 = (int) D.34745;
        __result = D.34743 - D.34746;
        D.34747 = __s2_len > 1;
        D.34737 = __result == 0;
        D.34748 = D.34747 & D.34737;
        if (D.34748 != 0) goto <D.34749>; else goto <D.34750>;
        <D.34749>:
        D.34751 = &MEM[(void *)"void" + 2B];
        D.34752 = *D.34751;
        D.34753 = (int) D.34752;
        D.34754 = __s2 + 2;
        D.34755 = *D.34754;
        D.34756 = (int) D.34755;
        __result = D.34753 - D.34756;
        D.34757 = __s2_len > 2;
        D.34737 = __result == 0;
        D.34758 = D.34757 & D.34737;
        if (D.34758 != 0) goto <D.34759>; else goto <D.34760>;
        <D.34759>:
        D.34761 = &MEM[(void *)"void" + 3B];
        D.34762 = *D.34761;
        D.34763 = (int) D.34762;
        D.34764 = __s2 + 3;
        D.34765 = *D.34764;
        D.34766 = (int) D.34765;
        __result = D.34763 - D.34766;
        <D.34760>:
        <D.34750>:
        <D.34740>:
      }
      D.27593 = __result;
    }
    iftmp.324 = -D.27593;
    goto <D.34767>;
    <D.34730>:
    iftmp.324 = __builtin_strcmp (typename, "void");
    <D.34767>:
    D.27594 = iftmp.324;
  }
  if (D.27594 == 0) goto <D.34768>; else goto <D.34769>;
  <D.34768>:
  klass = mono_defaults.void_class;
  goto <D.34770>;
  <D.34769>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.34772>; else goto <D.34773>;
    <D.34772>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.34774 = "int32";
      D.34775 = MEM[(const unsigned char *)D.34774];
      D.34776 = (int) D.34775;
      D.34777 = *__s2;
      D.34778 = (int) D.34777;
      __result = D.34776 - D.34778;
      {
        D.34779 = __s2_len != 0;
        D.34780 = __result == 0;
        D.34781 = D.34779 & D.34780;
        if (D.34781 != 0) goto <D.34782>; else goto <D.34783>;
        <D.34782>:
        D.34784 = &MEM[(void *)"int32" + 1B];
        D.34785 = *D.34784;
        D.34786 = (int) D.34785;
        D.34787 = __s2 + 1;
        D.34788 = *D.34787;
        D.34789 = (int) D.34788;
        __result = D.34786 - D.34789;
        D.34790 = __s2_len > 1;
        D.34780 = __result == 0;
        D.34791 = D.34790 & D.34780;
        if (D.34791 != 0) goto <D.34792>; else goto <D.34793>;
        <D.34792>:
        D.34794 = &MEM[(void *)"int32" + 2B];
        D.34795 = *D.34794;
        D.34796 = (int) D.34795;
        D.34797 = __s2 + 2;
        D.34798 = *D.34797;
        D.34799 = (int) D.34798;
        __result = D.34796 - D.34799;
        D.34800 = __s2_len > 2;
        D.34780 = __result == 0;
        D.34801 = D.34800 & D.34780;
        if (D.34801 != 0) goto <D.34802>; else goto <D.34803>;
        <D.34802>:
        D.34804 = &MEM[(void *)"int32" + 3B];
        D.34805 = *D.34804;
        D.34806 = (int) D.34805;
        D.34807 = __s2 + 3;
        D.34808 = *D.34807;
        D.34809 = (int) D.34808;
        __result = D.34806 - D.34809;
        <D.34803>:
        <D.34793>:
        <D.34783>:
      }
      D.27602 = __result;
    }
    iftmp.325 = -D.27602;
    goto <D.34810>;
    <D.34773>:
    iftmp.325 = __builtin_strcmp (typename, "int32");
    <D.34810>:
    D.27603 = iftmp.325;
  }
  if (D.27603 == 0) goto <D.34811>; else goto <D.34812>;
  <D.34811>:
  klass = mono_defaults.int32_class;
  goto <D.34813>;
  <D.34812>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 6;
    if (__s2_len <= 3) goto <D.34815>; else goto <D.34816>;
    <D.34815>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.34817 = "uint32";
      D.34818 = MEM[(const unsigned char *)D.34817];
      D.34819 = (int) D.34818;
      D.34820 = *__s2;
      D.34821 = (int) D.34820;
      __result = D.34819 - D.34821;
      {
        D.34822 = __s2_len != 0;
        D.34823 = __result == 0;
        D.34824 = D.34822 & D.34823;
        if (D.34824 != 0) goto <D.34825>; else goto <D.34826>;
        <D.34825>:
        D.34827 = &MEM[(void *)"uint32" + 1B];
        D.34828 = *D.34827;
        D.34829 = (int) D.34828;
        D.34830 = __s2 + 1;
        D.34831 = *D.34830;
        D.34832 = (int) D.34831;
        __result = D.34829 - D.34832;
        D.34833 = __s2_len > 1;
        D.34823 = __result == 0;
        D.34834 = D.34833 & D.34823;
        if (D.34834 != 0) goto <D.34835>; else goto <D.34836>;
        <D.34835>:
        D.34837 = &MEM[(void *)"uint32" + 2B];
        D.34838 = *D.34837;
        D.34839 = (int) D.34838;
        D.34840 = __s2 + 2;
        D.34841 = *D.34840;
        D.34842 = (int) D.34841;
        __result = D.34839 - D.34842;
        D.34843 = __s2_len > 2;
        D.34823 = __result == 0;
        D.34844 = D.34843 & D.34823;
        if (D.34844 != 0) goto <D.34845>; else goto <D.34846>;
        <D.34845>:
        D.34847 = &MEM[(void *)"uint32" + 3B];
        D.34848 = *D.34847;
        D.34849 = (int) D.34848;
        D.34850 = __s2 + 3;
        D.34851 = *D.34850;
        D.34852 = (int) D.34851;
        __result = D.34849 - D.34852;
        <D.34846>:
        <D.34836>:
        <D.34826>:
      }
      D.27611 = __result;
    }
    iftmp.326 = -D.27611;
    goto <D.34853>;
    <D.34816>:
    iftmp.326 = __builtin_strcmp (typename, "uint32");
    <D.34853>:
    D.27612 = iftmp.326;
  }
  if (D.27612 == 0) goto <D.34854>; else goto <D.34855>;
  <D.34854>:
  klass = mono_defaults.uint32_class;
  goto <D.34856>;
  <D.34855>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.34858>; else goto <D.34859>;
    <D.34858>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.34860 = "int8";
      D.34861 = MEM[(const unsigned char *)D.34860];
      D.34862 = (int) D.34861;
      D.34863 = *__s2;
      D.34864 = (int) D.34863;
      __result = D.34862 - D.34864;
      {
        D.34865 = __s2_len != 0;
        D.34866 = __result == 0;
        D.34867 = D.34865 & D.34866;
        if (D.34867 != 0) goto <D.34868>; else goto <D.34869>;
        <D.34868>:
        D.34870 = &MEM[(void *)"int8" + 1B];
        D.34871 = *D.34870;
        D.34872 = (int) D.34871;
        D.34873 = __s2 + 1;
        D.34874 = *D.34873;
        D.34875 = (int) D.34874;
        __result = D.34872 - D.34875;
        D.34876 = __s2_len > 1;
        D.34866 = __result == 0;
        D.34877 = D.34876 & D.34866;
        if (D.34877 != 0) goto <D.34878>; else goto <D.34879>;
        <D.34878>:
        D.34880 = &MEM[(void *)"int8" + 2B];
        D.34881 = *D.34880;
        D.34882 = (int) D.34881;
        D.34883 = __s2 + 2;
        D.34884 = *D.34883;
        D.34885 = (int) D.34884;
        __result = D.34882 - D.34885;
        D.34886 = __s2_len > 2;
        D.34866 = __result == 0;
        D.34887 = D.34886 & D.34866;
        if (D.34887 != 0) goto <D.34888>; else goto <D.34889>;
        <D.34888>:
        D.34890 = &MEM[(void *)"int8" + 3B];
        D.34891 = *D.34890;
        D.34892 = (int) D.34891;
        D.34893 = __s2 + 3;
        D.34894 = *D.34893;
        D.34895 = (int) D.34894;
        __result = D.34892 - D.34895;
        <D.34889>:
        <D.34879>:
        <D.34869>:
      }
      D.27620 = __result;
    }
    iftmp.327 = -D.27620;
    goto <D.34896>;
    <D.34859>:
    iftmp.327 = __builtin_strcmp (typename, "int8");
    <D.34896>:
    D.27621 = iftmp.327;
  }
  if (D.27621 == 0) goto <D.34897>; else goto <D.34898>;
  <D.34897>:
  klass = mono_defaults.sbyte_class;
  goto <D.34899>;
  <D.34898>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.34901>; else goto <D.34902>;
    <D.34901>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.34903 = "uint8";
      D.34904 = MEM[(const unsigned char *)D.34903];
      D.34905 = (int) D.34904;
      D.34906 = *__s2;
      D.34907 = (int) D.34906;
      __result = D.34905 - D.34907;
      {
        D.34908 = __s2_len != 0;
        D.34909 = __result == 0;
        D.34910 = D.34908 & D.34909;
        if (D.34910 != 0) goto <D.34911>; else goto <D.34912>;
        <D.34911>:
        D.34913 = &MEM[(void *)"uint8" + 1B];
        D.34914 = *D.34913;
        D.34915 = (int) D.34914;
        D.34916 = __s2 + 1;
        D.34917 = *D.34916;
        D.34918 = (int) D.34917;
        __result = D.34915 - D.34918;
        D.34919 = __s2_len > 1;
        D.34909 = __result == 0;
        D.34920 = D.34919 & D.34909;
        if (D.34920 != 0) goto <D.34921>; else goto <D.34922>;
        <D.34921>:
        D.34923 = &MEM[(void *)"uint8" + 2B];
        D.34924 = *D.34923;
        D.34925 = (int) D.34924;
        D.34926 = __s2 + 2;
        D.34927 = *D.34926;
        D.34928 = (int) D.34927;
        __result = D.34925 - D.34928;
        D.34929 = __s2_len > 2;
        D.34909 = __result == 0;
        D.34930 = D.34929 & D.34909;
        if (D.34930 != 0) goto <D.34931>; else goto <D.34932>;
        <D.34931>:
        D.34933 = &MEM[(void *)"uint8" + 3B];
        D.34934 = *D.34933;
        D.34935 = (int) D.34934;
        D.34936 = __s2 + 3;
        D.34937 = *D.34936;
        D.34938 = (int) D.34937;
        __result = D.34935 - D.34938;
        <D.34932>:
        <D.34922>:
        <D.34912>:
      }
      D.27629 = __result;
    }
    iftmp.328 = -D.27629;
    goto <D.34939>;
    <D.34902>:
    iftmp.328 = __builtin_strcmp (typename, "uint8");
    <D.34939>:
    D.27630 = iftmp.328;
  }
  if (D.27630 == 0) goto <D.34940>; else goto <D.34941>;
  <D.34940>:
  klass = mono_defaults.byte_class;
  goto <D.34942>;
  <D.34941>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.34944>; else goto <D.34945>;
    <D.34944>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.34946 = "int16";
      D.34947 = MEM[(const unsigned char *)D.34946];
      D.34948 = (int) D.34947;
      D.34949 = *__s2;
      D.34950 = (int) D.34949;
      __result = D.34948 - D.34950;
      {
        D.34951 = __s2_len != 0;
        D.34952 = __result == 0;
        D.34953 = D.34951 & D.34952;
        if (D.34953 != 0) goto <D.34954>; else goto <D.34955>;
        <D.34954>:
        D.34956 = &MEM[(void *)"int16" + 1B];
        D.34957 = *D.34956;
        D.34958 = (int) D.34957;
        D.34959 = __s2 + 1;
        D.34960 = *D.34959;
        D.34961 = (int) D.34960;
        __result = D.34958 - D.34961;
        D.34962 = __s2_len > 1;
        D.34952 = __result == 0;
        D.34963 = D.34962 & D.34952;
        if (D.34963 != 0) goto <D.34964>; else goto <D.34965>;
        <D.34964>:
        D.34966 = &MEM[(void *)"int16" + 2B];
        D.34967 = *D.34966;
        D.34968 = (int) D.34967;
        D.34969 = __s2 + 2;
        D.34970 = *D.34969;
        D.34971 = (int) D.34970;
        __result = D.34968 - D.34971;
        D.34972 = __s2_len > 2;
        D.34952 = __result == 0;
        D.34973 = D.34972 & D.34952;
        if (D.34973 != 0) goto <D.34974>; else goto <D.34975>;
        <D.34974>:
        D.34976 = &MEM[(void *)"int16" + 3B];
        D.34977 = *D.34976;
        D.34978 = (int) D.34977;
        D.34979 = __s2 + 3;
        D.34980 = *D.34979;
        D.34981 = (int) D.34980;
        __result = D.34978 - D.34981;
        <D.34975>:
        <D.34965>:
        <D.34955>:
      }
      D.27638 = __result;
    }
    iftmp.329 = -D.27638;
    goto <D.34982>;
    <D.34945>:
    iftmp.329 = __builtin_strcmp (typename, "int16");
    <D.34982>:
    D.27639 = iftmp.329;
  }
  if (D.27639 == 0) goto <D.34983>; else goto <D.34984>;
  <D.34983>:
  klass = mono_defaults.int16_class;
  goto <D.34985>;
  <D.34984>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 6;
    if (__s2_len <= 3) goto <D.34987>; else goto <D.34988>;
    <D.34987>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.34989 = "uint16";
      D.34990 = MEM[(const unsigned char *)D.34989];
      D.34991 = (int) D.34990;
      D.34992 = *__s2;
      D.34993 = (int) D.34992;
      __result = D.34991 - D.34993;
      {
        D.34994 = __s2_len != 0;
        D.34995 = __result == 0;
        D.34996 = D.34994 & D.34995;
        if (D.34996 != 0) goto <D.34997>; else goto <D.34998>;
        <D.34997>:
        D.34999 = &MEM[(void *)"uint16" + 1B];
        D.35000 = *D.34999;
        D.35001 = (int) D.35000;
        D.35002 = __s2 + 1;
        D.35003 = *D.35002;
        D.35004 = (int) D.35003;
        __result = D.35001 - D.35004;
        D.35005 = __s2_len > 1;
        D.34995 = __result == 0;
        D.35006 = D.35005 & D.34995;
        if (D.35006 != 0) goto <D.35007>; else goto <D.35008>;
        <D.35007>:
        D.35009 = &MEM[(void *)"uint16" + 2B];
        D.35010 = *D.35009;
        D.35011 = (int) D.35010;
        D.35012 = __s2 + 2;
        D.35013 = *D.35012;
        D.35014 = (int) D.35013;
        __result = D.35011 - D.35014;
        D.35015 = __s2_len > 2;
        D.34995 = __result == 0;
        D.35016 = D.35015 & D.34995;
        if (D.35016 != 0) goto <D.35017>; else goto <D.35018>;
        <D.35017>:
        D.35019 = &MEM[(void *)"uint16" + 3B];
        D.35020 = *D.35019;
        D.35021 = (int) D.35020;
        D.35022 = __s2 + 3;
        D.35023 = *D.35022;
        D.35024 = (int) D.35023;
        __result = D.35021 - D.35024;
        <D.35018>:
        <D.35008>:
        <D.34998>:
      }
      D.27647 = __result;
    }
    iftmp.330 = -D.27647;
    goto <D.35025>;
    <D.34988>:
    iftmp.330 = __builtin_strcmp (typename, "uint16");
    <D.35025>:
    D.27648 = iftmp.330;
  }
  if (D.27648 == 0) goto <D.35026>; else goto <D.35027>;
  <D.35026>:
  klass = mono_defaults.uint16_class;
  goto <D.35028>;
  <D.35027>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.35030>; else goto <D.35031>;
    <D.35030>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.35032 = "long";
      D.35033 = MEM[(const unsigned char *)D.35032];
      D.35034 = (int) D.35033;
      D.35035 = *__s2;
      D.35036 = (int) D.35035;
      __result = D.35034 - D.35036;
      {
        D.35037 = __s2_len != 0;
        D.35038 = __result == 0;
        D.35039 = D.35037 & D.35038;
        if (D.35039 != 0) goto <D.35040>; else goto <D.35041>;
        <D.35040>:
        D.35042 = &MEM[(void *)"long" + 1B];
        D.35043 = *D.35042;
        D.35044 = (int) D.35043;
        D.35045 = __s2 + 1;
        D.35046 = *D.35045;
        D.35047 = (int) D.35046;
        __result = D.35044 - D.35047;
        D.35048 = __s2_len > 1;
        D.35038 = __result == 0;
        D.35049 = D.35048 & D.35038;
        if (D.35049 != 0) goto <D.35050>; else goto <D.35051>;
        <D.35050>:
        D.35052 = &MEM[(void *)"long" + 2B];
        D.35053 = *D.35052;
        D.35054 = (int) D.35053;
        D.35055 = __s2 + 2;
        D.35056 = *D.35055;
        D.35057 = (int) D.35056;
        __result = D.35054 - D.35057;
        D.35058 = __s2_len > 2;
        D.35038 = __result == 0;
        D.35059 = D.35058 & D.35038;
        if (D.35059 != 0) goto <D.35060>; else goto <D.35061>;
        <D.35060>:
        D.35062 = &MEM[(void *)"long" + 3B];
        D.35063 = *D.35062;
        D.35064 = (int) D.35063;
        D.35065 = __s2 + 3;
        D.35066 = *D.35065;
        D.35067 = (int) D.35066;
        __result = D.35064 - D.35067;
        <D.35061>:
        <D.35051>:
        <D.35041>:
      }
      D.27656 = __result;
    }
    iftmp.331 = -D.27656;
    goto <D.35068>;
    <D.35031>:
    iftmp.331 = __builtin_strcmp (typename, "long");
    <D.35068>:
    D.27657 = iftmp.331;
  }
  if (D.27657 == 0) goto <D.35069>; else goto <D.35070>;
  <D.35069>:
  klass = mono_defaults.int64_class;
  goto <D.35071>;
  <D.35070>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.35073>; else goto <D.35074>;
    <D.35073>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.35075 = "ulong";
      D.35076 = MEM[(const unsigned char *)D.35075];
      D.35077 = (int) D.35076;
      D.35078 = *__s2;
      D.35079 = (int) D.35078;
      __result = D.35077 - D.35079;
      {
        D.35080 = __s2_len != 0;
        D.35081 = __result == 0;
        D.35082 = D.35080 & D.35081;
        if (D.35082 != 0) goto <D.35083>; else goto <D.35084>;
        <D.35083>:
        D.35085 = &MEM[(void *)"ulong" + 1B];
        D.35086 = *D.35085;
        D.35087 = (int) D.35086;
        D.35088 = __s2 + 1;
        D.35089 = *D.35088;
        D.35090 = (int) D.35089;
        __result = D.35087 - D.35090;
        D.35091 = __s2_len > 1;
        D.35081 = __result == 0;
        D.35092 = D.35091 & D.35081;
        if (D.35092 != 0) goto <D.35093>; else goto <D.35094>;
        <D.35093>:
        D.35095 = &MEM[(void *)"ulong" + 2B];
        D.35096 = *D.35095;
        D.35097 = (int) D.35096;
        D.35098 = __s2 + 2;
        D.35099 = *D.35098;
        D.35100 = (int) D.35099;
        __result = D.35097 - D.35100;
        D.35101 = __s2_len > 2;
        D.35081 = __result == 0;
        D.35102 = D.35101 & D.35081;
        if (D.35102 != 0) goto <D.35103>; else goto <D.35104>;
        <D.35103>:
        D.35105 = &MEM[(void *)"ulong" + 3B];
        D.35106 = *D.35105;
        D.35107 = (int) D.35106;
        D.35108 = __s2 + 3;
        D.35109 = *D.35108;
        D.35110 = (int) D.35109;
        __result = D.35107 - D.35110;
        <D.35104>:
        <D.35094>:
        <D.35084>:
      }
      D.27665 = __result;
    }
    iftmp.332 = -D.27665;
    goto <D.35111>;
    <D.35074>:
    iftmp.332 = __builtin_strcmp (typename, "ulong");
    <D.35111>:
    D.27666 = iftmp.332;
  }
  if (D.27666 == 0) goto <D.35112>; else goto <D.35113>;
  <D.35112>:
  klass = mono_defaults.uint64_class;
  goto <D.35114>;
  <D.35113>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.35116>; else goto <D.35117>;
    <D.35116>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.35118 = "float";
      D.35119 = MEM[(const unsigned char *)D.35118];
      D.35120 = (int) D.35119;
      D.35121 = *__s2;
      D.35122 = (int) D.35121;
      __result = D.35120 - D.35122;
      {
        D.35123 = __s2_len != 0;
        D.35124 = __result == 0;
        D.35125 = D.35123 & D.35124;
        if (D.35125 != 0) goto <D.35126>; else goto <D.35127>;
        <D.35126>:
        D.35128 = &MEM[(void *)"float" + 1B];
        D.35129 = *D.35128;
        D.35130 = (int) D.35129;
        D.35131 = __s2 + 1;
        D.35132 = *D.35131;
        D.35133 = (int) D.35132;
        __result = D.35130 - D.35133;
        D.35134 = __s2_len > 1;
        D.35124 = __result == 0;
        D.35135 = D.35134 & D.35124;
        if (D.35135 != 0) goto <D.35136>; else goto <D.35137>;
        <D.35136>:
        D.35138 = &MEM[(void *)"float" + 2B];
        D.35139 = *D.35138;
        D.35140 = (int) D.35139;
        D.35141 = __s2 + 2;
        D.35142 = *D.35141;
        D.35143 = (int) D.35142;
        __result = D.35140 - D.35143;
        D.35144 = __s2_len > 2;
        D.35124 = __result == 0;
        D.35145 = D.35144 & D.35124;
        if (D.35145 != 0) goto <D.35146>; else goto <D.35147>;
        <D.35146>:
        D.35148 = &MEM[(void *)"float" + 3B];
        D.35149 = *D.35148;
        D.35150 = (int) D.35149;
        D.35151 = __s2 + 3;
        D.35152 = *D.35151;
        D.35153 = (int) D.35152;
        __result = D.35150 - D.35153;
        <D.35147>:
        <D.35137>:
        <D.35127>:
      }
      D.27674 = __result;
    }
    iftmp.333 = -D.27674;
    goto <D.35154>;
    <D.35117>:
    iftmp.333 = __builtin_strcmp (typename, "float");
    <D.35154>:
    D.27675 = iftmp.333;
  }
  if (D.27675 == 0) goto <D.35155>; else goto <D.35156>;
  <D.35155>:
  klass = mono_defaults.single_class;
  goto <D.35157>;
  <D.35156>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 6;
    if (__s2_len <= 3) goto <D.35159>; else goto <D.35160>;
    <D.35159>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.35161 = "double";
      D.35162 = MEM[(const unsigned char *)D.35161];
      D.35163 = (int) D.35162;
      D.35164 = *__s2;
      D.35165 = (int) D.35164;
      __result = D.35163 - D.35165;
      {
        D.35166 = __s2_len != 0;
        D.35167 = __result == 0;
        D.35168 = D.35166 & D.35167;
        if (D.35168 != 0) goto <D.35169>; else goto <D.35170>;
        <D.35169>:
        D.35171 = &MEM[(void *)"double" + 1B];
        D.35172 = *D.35171;
        D.35173 = (int) D.35172;
        D.35174 = __s2 + 1;
        D.35175 = *D.35174;
        D.35176 = (int) D.35175;
        __result = D.35173 - D.35176;
        D.35177 = __s2_len > 1;
        D.35167 = __result == 0;
        D.35178 = D.35177 & D.35167;
        if (D.35178 != 0) goto <D.35179>; else goto <D.35180>;
        <D.35179>:
        D.35181 = &MEM[(void *)"double" + 2B];
        D.35182 = *D.35181;
        D.35183 = (int) D.35182;
        D.35184 = __s2 + 2;
        D.35185 = *D.35184;
        D.35186 = (int) D.35185;
        __result = D.35183 - D.35186;
        D.35187 = __s2_len > 2;
        D.35167 = __result == 0;
        D.35188 = D.35187 & D.35167;
        if (D.35188 != 0) goto <D.35189>; else goto <D.35190>;
        <D.35189>:
        D.35191 = &MEM[(void *)"double" + 3B];
        D.35192 = *D.35191;
        D.35193 = (int) D.35192;
        D.35194 = __s2 + 3;
        D.35195 = *D.35194;
        D.35196 = (int) D.35195;
        __result = D.35193 - D.35196;
        <D.35190>:
        <D.35180>:
        <D.35170>:
      }
      D.27683 = __result;
    }
    iftmp.334 = -D.27683;
    goto <D.35197>;
    <D.35160>:
    iftmp.334 = __builtin_strcmp (typename, "double");
    <D.35197>:
    D.27684 = iftmp.334;
  }
  if (D.27684 == 0) goto <D.35198>; else goto <D.35199>;
  <D.35198>:
  klass = mono_defaults.double_class;
  goto <D.35200>;
  <D.35199>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 6;
    if (__s2_len <= 3) goto <D.35202>; else goto <D.35203>;
    <D.35202>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.35204 = "object";
      D.35205 = MEM[(const unsigned char *)D.35204];
      D.35206 = (int) D.35205;
      D.35207 = *__s2;
      D.35208 = (int) D.35207;
      __result = D.35206 - D.35208;
      {
        D.35209 = __s2_len != 0;
        D.35210 = __result == 0;
        D.35211 = D.35209 & D.35210;
        if (D.35211 != 0) goto <D.35212>; else goto <D.35213>;
        <D.35212>:
        D.35214 = &MEM[(void *)"object" + 1B];
        D.35215 = *D.35214;
        D.35216 = (int) D.35215;
        D.35217 = __s2 + 1;
        D.35218 = *D.35217;
        D.35219 = (int) D.35218;
        __result = D.35216 - D.35219;
        D.35220 = __s2_len > 1;
        D.35210 = __result == 0;
        D.35221 = D.35220 & D.35210;
        if (D.35221 != 0) goto <D.35222>; else goto <D.35223>;
        <D.35222>:
        D.35224 = &MEM[(void *)"object" + 2B];
        D.35225 = *D.35224;
        D.35226 = (int) D.35225;
        D.35227 = __s2 + 2;
        D.35228 = *D.35227;
        D.35229 = (int) D.35228;
        __result = D.35226 - D.35229;
        D.35230 = __s2_len > 2;
        D.35210 = __result == 0;
        D.35231 = D.35230 & D.35210;
        if (D.35231 != 0) goto <D.35232>; else goto <D.35233>;
        <D.35232>:
        D.35234 = &MEM[(void *)"object" + 3B];
        D.35235 = *D.35234;
        D.35236 = (int) D.35235;
        D.35237 = __s2 + 3;
        D.35238 = *D.35237;
        D.35239 = (int) D.35238;
        __result = D.35236 - D.35239;
        <D.35233>:
        <D.35223>:
        <D.35213>:
      }
      D.27692 = __result;
    }
    iftmp.335 = -D.27692;
    goto <D.35240>;
    <D.35203>:
    iftmp.335 = __builtin_strcmp (typename, "object");
    <D.35240>:
    D.27693 = iftmp.335;
  }
  if (D.27693 == 0) goto <D.35241>; else goto <D.35242>;
  <D.35241>:
  klass = mono_defaults.object_class;
  goto <D.35243>;
  <D.35242>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 3;
    if (__s2_len <= 3) goto <D.35245>; else goto <D.35246>;
    <D.35245>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.35247 = "obj";
      D.35248 = MEM[(const unsigned char *)D.35247];
      D.35249 = (int) D.35248;
      D.35250 = *__s2;
      D.35251 = (int) D.35250;
      __result = D.35249 - D.35251;
      {
        D.35252 = __s2_len != 0;
        D.35253 = __result == 0;
        D.35254 = D.35252 & D.35253;
        if (D.35254 != 0) goto <D.35255>; else goto <D.35256>;
        <D.35255>:
        D.35257 = &MEM[(void *)"obj" + 1B];
        D.35258 = *D.35257;
        D.35259 = (int) D.35258;
        D.35260 = __s2 + 1;
        D.35261 = *D.35260;
        D.35262 = (int) D.35261;
        __result = D.35259 - D.35262;
        D.35263 = __s2_len > 1;
        D.35253 = __result == 0;
        D.35264 = D.35263 & D.35253;
        if (D.35264 != 0) goto <D.35265>; else goto <D.35266>;
        <D.35265>:
        D.35267 = &MEM[(void *)"obj" + 2B];
        D.35268 = *D.35267;
        D.35269 = (int) D.35268;
        D.35270 = __s2 + 2;
        D.35271 = *D.35270;
        D.35272 = (int) D.35271;
        __result = D.35269 - D.35272;
        D.35273 = __s2_len > 2;
        D.35253 = __result == 0;
        D.35274 = D.35273 & D.35253;
        if (D.35274 != 0) goto <D.35275>; else goto <D.35276>;
        <D.35275>:
        D.35277 = &MEM[(void *)"obj" + 3B];
        D.35278 = *D.35277;
        D.35279 = (int) D.35278;
        D.35280 = __s2 + 3;
        D.35281 = *D.35280;
        D.35282 = (int) D.35281;
        __result = D.35279 - D.35282;
        <D.35276>:
        <D.35266>:
        <D.35256>:
      }
      D.27701 = __result;
    }
    iftmp.336 = -D.27701;
    goto <D.35283>;
    <D.35246>:
    iftmp.336 = __builtin_strcmp (typename, "obj");
    <D.35283>:
    D.27702 = iftmp.336;
  }
  if (D.27702 == 0) goto <D.35284>; else goto <D.35285>;
  <D.35284>:
  klass = mono_defaults.object_class;
  goto <D.35286>;
  <D.35285>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 6;
    if (__s2_len <= 3) goto <D.35288>; else goto <D.35289>;
    <D.35288>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.35290 = "string";
      D.35291 = MEM[(const unsigned char *)D.35290];
      D.35292 = (int) D.35291;
      D.35293 = *__s2;
      D.35294 = (int) D.35293;
      __result = D.35292 - D.35294;
      {
        D.35295 = __s2_len != 0;
        D.35296 = __result == 0;
        D.35297 = D.35295 & D.35296;
        if (D.35297 != 0) goto <D.35298>; else goto <D.35299>;
        <D.35298>:
        D.35300 = &MEM[(void *)"string" + 1B];
        D.35301 = *D.35300;
        D.35302 = (int) D.35301;
        D.35303 = __s2 + 1;
        D.35304 = *D.35303;
        D.35305 = (int) D.35304;
        __result = D.35302 - D.35305;
        D.35306 = __s2_len > 1;
        D.35296 = __result == 0;
        D.35307 = D.35306 & D.35296;
        if (D.35307 != 0) goto <D.35308>; else goto <D.35309>;
        <D.35308>:
        D.35310 = &MEM[(void *)"string" + 2B];
        D.35311 = *D.35310;
        D.35312 = (int) D.35311;
        D.35313 = __s2 + 2;
        D.35314 = *D.35313;
        D.35315 = (int) D.35314;
        __result = D.35312 - D.35315;
        D.35316 = __s2_len > 2;
        D.35296 = __result == 0;
        D.35317 = D.35316 & D.35296;
        if (D.35317 != 0) goto <D.35318>; else goto <D.35319>;
        <D.35318>:
        D.35320 = &MEM[(void *)"string" + 3B];
        D.35321 = *D.35320;
        D.35322 = (int) D.35321;
        D.35323 = __s2 + 3;
        D.35324 = *D.35323;
        D.35325 = (int) D.35324;
        __result = D.35322 - D.35325;
        <D.35319>:
        <D.35309>:
        <D.35299>:
      }
      D.27710 = __result;
    }
    iftmp.337 = -D.27710;
    goto <D.35326>;
    <D.35289>:
    iftmp.337 = __builtin_strcmp (typename, "string");
    <D.35326>:
    D.27711 = iftmp.337;
  }
  if (D.27711 == 0) goto <D.35327>; else goto <D.35328>;
  <D.35327>:
  klass = mono_defaults.string_class;
  goto <D.35329>;
  <D.35328>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.35331>; else goto <D.35332>;
    <D.35331>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.35333 = "bool";
      D.35334 = MEM[(const unsigned char *)D.35333];
      D.35335 = (int) D.35334;
      D.35336 = *__s2;
      D.35337 = (int) D.35336;
      __result = D.35335 - D.35337;
      {
        D.35338 = __s2_len != 0;
        D.35339 = __result == 0;
        D.35340 = D.35338 & D.35339;
        if (D.35340 != 0) goto <D.35341>; else goto <D.35342>;
        <D.35341>:
        D.35343 = &MEM[(void *)"bool" + 1B];
        D.35344 = *D.35343;
        D.35345 = (int) D.35344;
        D.35346 = __s2 + 1;
        D.35347 = *D.35346;
        D.35348 = (int) D.35347;
        __result = D.35345 - D.35348;
        D.35349 = __s2_len > 1;
        D.35339 = __result == 0;
        D.35350 = D.35349 & D.35339;
        if (D.35350 != 0) goto <D.35351>; else goto <D.35352>;
        <D.35351>:
        D.35353 = &MEM[(void *)"bool" + 2B];
        D.35354 = *D.35353;
        D.35355 = (int) D.35354;
        D.35356 = __s2 + 2;
        D.35357 = *D.35356;
        D.35358 = (int) D.35357;
        __result = D.35355 - D.35358;
        D.35359 = __s2_len > 2;
        D.35339 = __result == 0;
        D.35360 = D.35359 & D.35339;
        if (D.35360 != 0) goto <D.35361>; else goto <D.35362>;
        <D.35361>:
        D.35363 = &MEM[(void *)"bool" + 3B];
        D.35364 = *D.35363;
        D.35365 = (int) D.35364;
        D.35366 = __s2 + 3;
        D.35367 = *D.35366;
        D.35368 = (int) D.35367;
        __result = D.35365 - D.35368;
        <D.35362>:
        <D.35352>:
        <D.35342>:
      }
      D.27719 = __result;
    }
    iftmp.338 = -D.27719;
    goto <D.35369>;
    <D.35332>:
    iftmp.338 = __builtin_strcmp (typename, "bool");
    <D.35369>:
    D.27720 = iftmp.338;
  }
  if (D.27720 == 0) goto <D.35370>; else goto <D.35371>;
  <D.35370>:
  klass = mono_defaults.boolean_class;
  goto <D.35372>;
  <D.35371>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 7;
    if (__s2_len <= 3) goto <D.35374>; else goto <D.35375>;
    <D.35374>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.35376 = "boolean";
      D.35377 = MEM[(const unsigned char *)D.35376];
      D.35378 = (int) D.35377;
      D.35379 = *__s2;
      D.35380 = (int) D.35379;
      __result = D.35378 - D.35380;
      {
        D.35381 = __s2_len != 0;
        D.35382 = __result == 0;
        D.35383 = D.35381 & D.35382;
        if (D.35383 != 0) goto <D.35384>; else goto <D.35385>;
        <D.35384>:
        D.35386 = &MEM[(void *)"boolean" + 1B];
        D.35387 = *D.35386;
        D.35388 = (int) D.35387;
        D.35389 = __s2 + 1;
        D.35390 = *D.35389;
        D.35391 = (int) D.35390;
        __result = D.35388 - D.35391;
        D.35392 = __s2_len > 1;
        D.35382 = __result == 0;
        D.35393 = D.35392 & D.35382;
        if (D.35393 != 0) goto <D.35394>; else goto <D.35395>;
        <D.35394>:
        D.35396 = &MEM[(void *)"boolean" + 2B];
        D.35397 = *D.35396;
        D.35398 = (int) D.35397;
        D.35399 = __s2 + 2;
        D.35400 = *D.35399;
        D.35401 = (int) D.35400;
        __result = D.35398 - D.35401;
        D.35402 = __s2_len > 2;
        D.35382 = __result == 0;
        D.35403 = D.35402 & D.35382;
        if (D.35403 != 0) goto <D.35404>; else goto <D.35405>;
        <D.35404>:
        D.35406 = &MEM[(void *)"boolean" + 3B];
        D.35407 = *D.35406;
        D.35408 = (int) D.35407;
        D.35409 = __s2 + 3;
        D.35410 = *D.35409;
        D.35411 = (int) D.35410;
        __result = D.35408 - D.35411;
        <D.35405>:
        <D.35395>:
        <D.35385>:
      }
      D.27728 = __result;
    }
    iftmp.339 = -D.27728;
    goto <D.35412>;
    <D.35375>:
    iftmp.339 = __builtin_strcmp (typename, "boolean");
    <D.35412>:
    D.27729 = iftmp.339;
  }
  if (D.27729 == 0) goto <D.35413>; else goto <D.35414>;
  <D.35413>:
  klass = mono_defaults.boolean_class;
  goto <D.35415>;
  <D.35414>:
  monoeg_g_log (0B, 4, "%s", typename);
  <D.27730>:
  goto <D.27730>;
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 8265);
  <D.35415>:
  <D.35372>:
  <D.35329>:
  <D.35286>:
  <D.35243>:
  <D.35200>:
  <D.35157>:
  <D.35114>:
  <D.35071>:
  <D.35028>:
  <D.34985>:
  <D.34942>:
  <D.34899>:
  <D.34856>:
  <D.34813>:
  <D.34770>:
  <D.34727>:
  <D.34684>:
  D.35416 = &klass->byval_arg;
  return D.35416;
}


mono_find_jit_icall_by_name (const char * name)
{
  struct GHashTable * jit_icall_hash_name.340;
  _Bool D.35419;
  long int D.35420;
  long int D.35421;
  struct MonoJitICallInfo * D.35424;
  struct MonoJitICallInfo * info;

  jit_icall_hash_name.340 = jit_icall_hash_name;
  D.35419 = jit_icall_hash_name.340 == 0B;
  D.35420 = (long int) D.35419;
  D.35421 = __builtin_expect (D.35420, 0);
  if (D.35421 != 0) goto <D.35422>; else goto <D.35423>;
  <D.35422>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8331, "jit_icall_hash_name");
  <D.35423>:
  mono_icall_lock ();
  jit_icall_hash_name.340 = jit_icall_hash_name;
  info = monoeg_g_hash_table_lookup (jit_icall_hash_name.340, name);
  mono_icall_unlock ();
  D.35424 = info;
  return D.35424;
}


mono_find_jit_icall_by_addr (const void * addr)
{
  struct GHashTable * jit_icall_hash_addr.341;
  _Bool D.35427;
  long int D.35428;
  long int D.35429;
  struct MonoJitICallInfo * D.35432;
  struct MonoJitICallInfo * info;

  jit_icall_hash_addr.341 = jit_icall_hash_addr;
  D.35427 = jit_icall_hash_addr.341 == 0B;
  D.35428 = (long int) D.35427;
  D.35429 = __builtin_expect (D.35428, 0);
  if (D.35429 != 0) goto <D.35430>; else goto <D.35431>;
  <D.35430>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8343, "jit_icall_hash_addr");
  <D.35431>:
  mono_icall_lock ();
  jit_icall_hash_addr.341 = jit_icall_hash_addr;
  info = monoeg_g_hash_table_lookup (jit_icall_hash_addr.341, addr);
  mono_icall_unlock ();
  D.35432 = info;
  return D.35432;
}


mono_get_jit_icall_info ()
{
  struct GHashTable * D.35434;

  D.35434 = jit_icall_hash_name;
  return D.35434;
}


mono_lookup_jit_icall_symbol (const char * name)
{
  struct GHashTable * jit_icall_hash_name.342;
  const char * D.35439;
  struct MonoJitICallInfo * info;
  const char * res;

  res = 0B;
  mono_icall_lock ();
  jit_icall_hash_name.342 = jit_icall_hash_name;
  info = monoeg_g_hash_table_lookup (jit_icall_hash_name.342, name);
  if (info != 0B) goto <D.35437>; else goto <D.35438>;
  <D.35437>:
  res = info->c_symbol;
  <D.35438>:
  mono_icall_unlock ();
  D.35439 = res;
  return D.35439;
}


mono_register_jit_icall_wrapper (struct MonoJitICallInfo * info, const void * wrapper)
{
  struct GHashTable * jit_icall_hash_addr.343;

  mono_icall_lock ();
  jit_icall_hash_addr.343 = jit_icall_hash_addr;
  monoeg_g_hash_table_insert_replace (jit_icall_hash_addr.343, wrapper, info, 0);
  mono_icall_unlock ();
}


mono_register_jit_icall_full (const void * func, const char * name, struct MonoMethodSignature * sig, gboolean is_save, const char * c_symbol)
{
  _Bool D.35442;
  long int D.35443;
  long int D.35444;
  _Bool D.35447;
  long int D.35448;
  long int D.35449;
  struct GHashTable * jit_icall_hash_name.344;
  struct GHashTable * jit_icall_hash_name.345;
  struct GHashTable * jit_icall_hash_addr.346;
  void * D.35457;
  const char * D.35463;
  struct GHashTable * jit_icall_hash_addr.347;
  struct MonoJitICallInfo * D.35465;
  struct MonoJitICallInfo * info;

  D.35442 = func == 0B;
  D.35443 = (long int) D.35442;
  D.35444 = __builtin_expect (D.35443, 0);
  if (D.35444 != 0) goto <D.35445>; else goto <D.35446>;
  <D.35445>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8396, "func");
  <D.35446>:
  D.35447 = name == 0B;
  D.35448 = (long int) D.35447;
  D.35449 = __builtin_expect (D.35448, 0);
  if (D.35449 != 0) goto <D.35450>; else goto <D.35451>;
  <D.35450>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8397, "name");
  <D.35451>:
  mono_icall_lock ();
  jit_icall_hash_name.344 = jit_icall_hash_name;
  if (jit_icall_hash_name.344 == 0B) goto <D.35453>; else goto <D.35454>;
  <D.35453>:
  jit_icall_hash_name.345 = monoeg_g_hash_table_new_full (monoeg_g_str_hash, monoeg_g_str_equal, 0B, monoeg_g_free);
  jit_icall_hash_name = jit_icall_hash_name.345;
  jit_icall_hash_addr.346 = monoeg_g_hash_table_new (0B, 0B);
  jit_icall_hash_addr = jit_icall_hash_addr.346;
  <D.35454>:
  jit_icall_hash_name.344 = jit_icall_hash_name;
  D.35457 = monoeg_g_hash_table_lookup (jit_icall_hash_name.344, name);
  if (D.35457 != 0B) goto <D.35458>; else goto <D.35459>;
  <D.35458>:
  monoeg_g_log (0B, 16, "jit icall already defined \"%s\"\n", name);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 8408);
  <D.35459>:
  info = monoeg_malloc0 (24);
  info->name = name;
  info->func = func;
  info->sig = sig;
  info->c_symbol = c_symbol;
  if (is_save != 0) goto <D.35460>; else goto <D.35461>;
  <D.35460>:
  info->wrapper = func;
  goto <D.35462>;
  <D.35461>:
  info->wrapper = 0B;
  <D.35462>:
  jit_icall_hash_name.344 = jit_icall_hash_name;
  D.35463 = info->name;
  monoeg_g_hash_table_insert_replace (jit_icall_hash_name.344, D.35463, info, 0);
  jit_icall_hash_addr.347 = jit_icall_hash_addr;
  monoeg_g_hash_table_insert_replace (jit_icall_hash_addr.347, func, info, 0);
  mono_icall_unlock ();
  D.35465 = info;
  return D.35465;
}


mono_register_jit_icall (const void * func, const char * name, struct MonoMethodSignature * sig, gboolean is_save)
{
  struct MonoJitICallInfo * D.35467;

  D.35467 = mono_register_jit_icall_full (func, name, sig, is_save, 0B);
  return D.35467;
}