ves_icall_System_Globalization_CultureInfo_construct_datetime_format (struct MonoCultureInfo * this)
{
  int D.16727;
  _Bool D.16728;
  long int D.16729;
  long int D.16730;
  unsigned char D.16733;
  const stridx_t[7] * D.16734;
  struct MonoArray * D.16735;
  struct MonoArray * * D.16736;
  const stridx_t[13] * D.16737;
  struct MonoArray * D.16738;
  struct MonoArray * * D.16739;
  short unsigned int D.16740;
  sizetype D.16741;
  const char * D.16742;
  struct MonoString * D.16743;
  struct MonoString * * D.16744;
  signed char D.16745;
  unsigned int D.16746;
  short unsigned int D.16747;
  sizetype D.16748;
  const char * D.16749;
  struct MonoString * D.16750;
  struct MonoString * * D.16751;
  const stridx_t[7] * D.16752;
  struct MonoArray * D.16753;
  struct MonoArray * * D.16754;
  const stridx_t[7] * D.16755;
  struct MonoArray * D.16756;
  struct MonoArray * * D.16757;
  signed char D.16758;
  unsigned int D.16759;
  short unsigned int D.16760;
  sizetype D.16761;
  const char * D.16762;
  struct MonoString * D.16763;
  struct MonoString * * D.16764;
  short unsigned int D.16765;
  sizetype D.16766;
  const char * D.16767;
  struct MonoString * D.16768;
  struct MonoString * * D.16769;
  short unsigned int D.16770;
  sizetype D.16771;
  const char * D.16772;
  struct MonoString * D.16773;
  struct MonoString * * D.16774;
  const stridx_t[13] * D.16775;
  struct MonoArray * D.16776;
  struct MonoArray * * D.16777;
  short unsigned int D.16778;
  sizetype D.16779;
  const char * D.16780;
  struct MonoString * D.16781;
  struct MonoString * * D.16782;
  short unsigned int D.16783;
  sizetype D.16784;
  const char * D.16785;
  struct MonoString * D.16786;
  struct MonoString * * D.16787;
  short unsigned int D.16788;
  sizetype D.16789;
  const char * D.16790;
  struct MonoString * D.16791;
  struct MonoString * * D.16792;
  short unsigned int D.16793;
  sizetype D.16794;
  const char * D.16795;
  struct MonoString * D.16796;
  struct MonoString * * D.16797;
  short unsigned int D.16798;
  sizetype D.16799;
  const char * D.16800;
  struct MonoString * D.16801;
  struct MonoString * * D.16802;
  const stridx_t[14] * D.16803;
  struct MonoArray * D.16804;
  struct MonoArray * * D.16805;
  const stridx_t[8] * D.16806;
  struct MonoArray * D.16807;
  struct MonoArray * * D.16808;
  const stridx_t[12] * D.16809;
  struct MonoArray * D.16810;
  struct MonoArray * * D.16811;
  const stridx_t[9] * D.16812;
  struct MonoArray * D.16813;
  struct MonoArray * * D.16814;
  const stridx_t[13] * D.16815;
  struct MonoArray * D.16816;
  struct MonoArray * * D.16817;
  const stridx_t[13] * D.16818;
  struct MonoArray * D.16819;
  struct MonoArray * * D.16820;
  struct MonoDomain * domain;
  struct MonoDateTimeFormatInfo * datetime;
  const struct DateTimeFormatEntry * dfe;

  D.16727 = this->datetime_index;
  D.16728 = D.16727 < 0;
  D.16729 = (long int) D.16728;
  D.16730 = __builtin_expect (D.16729, 0);
  if (D.16730 != 0) goto <D.16731>; else goto <D.16732>;
  <D.16731>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "locales.c", 169, "this->datetime_index >= 0");
  <D.16732>:
  datetime = this->datetime_format;
  D.16727 = this->datetime_index;
  dfe = &datetime_format_entries[D.16727];
  domain = mono_domain_get ();
  D.16733 = this->is_read_only;
  datetime->readOnly = D.16733;
  D.16734 = &dfe->abbreviated_day_names;
  D.16735 = create_names_array_idx (D.16734, 7);
  D.16736 = &datetime->AbbreviatedDayNames;
  mono_gc_wbarrier_set_field (datetime, D.16736, D.16735);
  D.16737 = &dfe->abbreviated_month_names;
  D.16738 = create_names_array_idx (D.16737, 13);
  D.16739 = &datetime->AbbreviatedMonthNames;
  mono_gc_wbarrier_set_field (datetime, D.16739, D.16738);
  D.16740 = dfe->am_designator;
  D.16741 = (sizetype) D.16740;
  D.16742 = &locale_strings + D.16741;
  D.16743 = mono_string_new (domain, D.16742);
  D.16744 = &datetime->AMDesignator;
  mono_gc_wbarrier_set_field (datetime, D.16744, D.16743);
  D.16745 = dfe->calendar_week_rule;
  D.16746 = (unsigned int) D.16745;
  datetime->CalendarWeekRule = D.16746;
  D.16747 = dfe->date_separator;
  D.16748 = (sizetype) D.16747;
  D.16749 = &locale_strings + D.16748;
  D.16750 = mono_string_new (domain, D.16749);
  D.16751 = &datetime->DateSeparator;
  mono_gc_wbarrier_set_field (datetime, D.16751, D.16750);
  D.16752 = &dfe->day_names;
  D.16753 = create_names_array_idx (D.16752, 7);
  D.16754 = &datetime->DayNames;
  mono_gc_wbarrier_set_field (datetime, D.16754, D.16753);
  D.16755 = &dfe->shortest_day_names;
  D.16756 = create_names_array_idx (D.16755, 7);
  D.16757 = &datetime->ShortestDayNames;
  mono_gc_wbarrier_set_field (datetime, D.16757, D.16756);
  D.16758 = dfe->first_day_of_week;
  D.16759 = (unsigned int) D.16758;
  datetime->FirstDayOfWeek = D.16759;
  D.16760 = dfe->long_date_pattern;
  D.16761 = (sizetype) D.16760;
  D.16762 = &locale_strings + D.16761;
  D.16763 = mono_string_new (domain, D.16762);
  D.16764 = &datetime->LongDatePattern;
  mono_gc_wbarrier_set_field (datetime, D.16764, D.16763);
  D.16765 = dfe->long_time_pattern;
  D.16766 = (sizetype) D.16765;
  D.16767 = &locale_strings + D.16766;
  D.16768 = mono_string_new (domain, D.16767);
  D.16769 = &datetime->LongTimePattern;
  mono_gc_wbarrier_set_field (datetime, D.16769, D.16768);
  D.16770 = dfe->month_day_pattern;
  D.16771 = (sizetype) D.16770;
  D.16772 = &locale_strings + D.16771;
  D.16773 = mono_string_new (domain, D.16772);
  D.16774 = &datetime->MonthDayPattern;
  mono_gc_wbarrier_set_field (datetime, D.16774, D.16773);
  D.16775 = &dfe->month_names;
  D.16776 = create_names_array_idx (D.16775, 13);
  D.16777 = &datetime->MonthNames;
  mono_gc_wbarrier_set_field (datetime, D.16777, D.16776);
  D.16778 = dfe->pm_designator;
  D.16779 = (sizetype) D.16778;
  D.16780 = &locale_strings + D.16779;
  D.16781 = mono_string_new (domain, D.16780);
  D.16782 = &datetime->PMDesignator;
  mono_gc_wbarrier_set_field (datetime, D.16782, D.16781);
  D.16783 = dfe->short_date_pattern;
  D.16784 = (sizetype) D.16783;
  D.16785 = &locale_strings + D.16784;
  D.16786 = mono_string_new (domain, D.16785);
  D.16787 = &datetime->ShortDatePattern;
  mono_gc_wbarrier_set_field (datetime, D.16787, D.16786);
  D.16788 = dfe->short_time_pattern;
  D.16789 = (sizetype) D.16788;
  D.16790 = &locale_strings + D.16789;
  D.16791 = mono_string_new (domain, D.16790);
  D.16792 = &datetime->ShortTimePattern;
  mono_gc_wbarrier_set_field (datetime, D.16792, D.16791);
  D.16793 = dfe->time_separator;
  D.16794 = (sizetype) D.16793;
  D.16795 = &locale_strings + D.16794;
  D.16796 = mono_string_new (domain, D.16795);
  D.16797 = &datetime->TimeSeparator;
  mono_gc_wbarrier_set_field (datetime, D.16797, D.16796);
  D.16798 = dfe->year_month_pattern;
  D.16799 = (sizetype) D.16798;
  D.16800 = &locale_strings + D.16799;
  D.16801 = mono_string_new (domain, D.16800);
  D.16802 = &datetime->YearMonthPattern;
  mono_gc_wbarrier_set_field (datetime, D.16802, D.16801);
  D.16803 = &dfe->short_date_patterns;
  D.16804 = create_names_array_idx_dynamic (D.16803, 14);
  D.16805 = &datetime->ShortDatePatterns;
  mono_gc_wbarrier_set_field (datetime, D.16805, D.16804);
  D.16806 = &dfe->long_date_patterns;
  D.16807 = create_names_array_idx_dynamic (D.16806, 8);
  D.16808 = &datetime->LongDatePatterns;
  mono_gc_wbarrier_set_field (datetime, D.16808, D.16807);
  D.16809 = &dfe->short_time_patterns;
  D.16810 = create_names_array_idx_dynamic (D.16809, 12);
  D.16811 = &datetime->ShortTimePatterns;
  mono_gc_wbarrier_set_field (datetime, D.16811, D.16810);
  D.16812 = &dfe->long_time_patterns;
  D.16813 = create_names_array_idx_dynamic (D.16812, 9);
  D.16814 = &datetime->LongTimePatterns;
  mono_gc_wbarrier_set_field (datetime, D.16814, D.16813);
  D.16815 = &dfe->month_genitive_names;
  D.16816 = create_names_array_idx (D.16815, 13);
  D.16817 = &datetime->GenitiveMonthNames;
  mono_gc_wbarrier_set_field (datetime, D.16817, D.16816);
  D.16818 = &dfe->abbreviated_month_genitive_names;
  D.16819 = create_names_array_idx (D.16818, 13);
  D.16820 = &datetime->GenitiveAbbreviatedMonthNames;
  mono_gc_wbarrier_set_field (datetime, D.16820, D.16819);
}


create_names_array_idx_dynamic (const guint16 * names, int ml)
{
  struct MonoArray * D.16823;
  long unsigned int D.16824;
  long unsigned int D.16825;
  const guint16 * D.16826;
  short unsigned int D.16827;
  long unsigned int D.16829;
  struct MonoClass * D.16473;
  struct MonoClass * tmp_klass.0;
  struct MonoClass * D.16833;
  struct MonoClass * tmp_klass.1;
  _Bool D.16835;
  long int D.16836;
  long int D.16837;
  struct MonoDomain * D.16840;
  struct MonoVTable * D.16841;
  long unsigned int D.16842;
  sizetype D.16843;
  const char * D.16844;
  struct MonoString * D.16845;
  struct MonoArray * ret;
  struct MonoDomain * domain;
  int i;
  int len;

  len = 0;
  if (names == 0B) goto <D.16821>; else goto <D.16822>;
  <D.16821>:
  D.16823 = 0B;
  return D.16823;
  <D.16822>:
  domain = mono_domain_get ();
  i = 0;
  goto <D.16471>;
  <D.16470>:
  D.16824 = (long unsigned int) i;
  D.16825 = D.16824 * 2;
  D.16826 = names + D.16825;
  D.16827 = *D.16826;
  if (D.16827 == 0) goto <D.16469>; else goto <D.16828>;
  <D.16828>:
  len = len + 1;
  i = i + 1;
  <D.16471>:
  if (i < ml) goto <D.16470>; else goto <D.16469>;
  <D.16469>:
  D.16829 = (long unsigned int) len;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.0 = tmp_klass;
      if (tmp_klass.0 == 0B) goto <D.16831>; else goto <D.16832>;
      <D.16831>:
      D.16833 = mono_get_string_class ();
      tmp_klass.1 = mono_array_class_get (D.16833, 1);
      tmp_klass = tmp_klass.1;
      tmp_klass.0 = tmp_klass;
      D.16835 = tmp_klass.0 == 0B;
      D.16836 = (long int) D.16835;
      D.16837 = __builtin_expect (D.16836, 0);
      if (D.16837 != 0) goto <D.16838>; else goto <D.16839>;
      <D.16838>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "locales.c", 152, "tmp_klass");
      <D.16839>:
      <D.16832>:
    }
    D.16473 = tmp_klass;
  }
  D.16840 = mono_domain_get ();
  D.16841 = mono_class_vtable (D.16840, D.16473);
  ret = mono_array_new_specific (D.16841, D.16829);
  i = 0;
  goto <D.16476>;
  <D.16475>:
  {
    void * * __p;

    D.16842 = (long unsigned int) i;
    __p = mono_array_addr_with_size (ret, 8, D.16842);
    D.16824 = (long unsigned int) i;
    D.16825 = D.16824 * 2;
    D.16826 = names + D.16825;
    D.16827 = *D.16826;
    D.16843 = (sizetype) D.16827;
    D.16844 = &locale_strings + D.16843;
    D.16845 = mono_string_new (domain, D.16844);
    mono_gc_wbarrier_set_arrayref (ret, __p, D.16845);
  }
  i = i + 1;
  <D.16476>:
  if (i < len) goto <D.16475>; else goto <D.16477>;
  <D.16477>:
  D.16823 = ret;
  return D.16823;
}


create_names_array_idx (const guint16 * names, int ml)
{
  struct MonoArray * D.16849;
  long unsigned int D.16850;
  struct MonoClass * D.16456;
  struct MonoClass * tmp_klass.2;
  struct MonoClass * D.16854;
  struct MonoClass * tmp_klass.3;
  _Bool D.16856;
  long int D.16857;
  long int D.16858;
  struct MonoDomain * D.16861;
  struct MonoVTable * D.16862;
  long unsigned int D.16863;
  long unsigned int D.16864;
  long unsigned int D.16865;
  const guint16 * D.16866;
  short unsigned int D.16867;
  sizetype D.16868;
  const char * D.16869;
  struct MonoString * D.16870;
  struct MonoArray * ret;
  struct MonoDomain * domain;
  int i;

  if (names == 0B) goto <D.16847>; else goto <D.16848>;
  <D.16847>:
  D.16849 = 0B;
  return D.16849;
  <D.16848>:
  domain = mono_domain_get ();
  D.16850 = (long unsigned int) ml;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.2 = tmp_klass;
      if (tmp_klass.2 == 0B) goto <D.16852>; else goto <D.16853>;
      <D.16852>:
      D.16854 = mono_get_string_class ();
      tmp_klass.3 = mono_array_class_get (D.16854, 1);
      tmp_klass = tmp_klass.3;
      tmp_klass.2 = tmp_klass;
      D.16856 = tmp_klass.2 == 0B;
      D.16857 = (long int) D.16856;
      D.16858 = __builtin_expect (D.16857, 0);
      if (D.16858 != 0) goto <D.16859>; else goto <D.16860>;
      <D.16859>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "locales.c", 126, "tmp_klass");
      <D.16860>:
      <D.16853>:
    }
    D.16456 = tmp_klass;
  }
  D.16861 = mono_domain_get ();
  D.16862 = mono_class_vtable (D.16861, D.16456);
  ret = mono_array_new_specific (D.16862, D.16850);
  i = 0;
  goto <D.16459>;
  <D.16458>:
  {
    void * * __p;

    D.16863 = (long unsigned int) i;
    __p = mono_array_addr_with_size (ret, 8, D.16863);
    D.16864 = (long unsigned int) i;
    D.16865 = D.16864 * 2;
    D.16866 = names + D.16865;
    D.16867 = *D.16866;
    D.16868 = (sizetype) D.16867;
    D.16869 = &locale_strings + D.16868;
    D.16870 = mono_string_new (domain, D.16869);
    mono_gc_wbarrier_set_arrayref (ret, __p, D.16870);
  }
  i = i + 1;
  <D.16459>:
  if (i < ml) goto <D.16458>; else goto <D.16460>;
  <D.16460>:
  D.16849 = ret;
  return D.16849;
}


ves_icall_System_Globalization_CultureInfo_construct_number_format (struct MonoCultureInfo * this)
{
  struct MonoNumberFormatInfo * D.16872;
  _Bool D.16873;
  long int D.16874;
  long int D.16875;
  int D.16878;
  unsigned char D.16881;
  signed char D.16882;
  int D.16883;
  short unsigned int D.16884;
  sizetype D.16885;
  const char * D.16886;
  struct MonoString * D.16887;
  struct MonoString * * D.16888;
  short unsigned int D.16889;
  sizetype D.16890;
  const char * D.16891;
  struct MonoString * D.16892;
  struct MonoString * * D.16893;
  const gint[2] * D.16894;
  struct MonoArray * D.16895;
  struct MonoArray * * D.16896;
  signed char D.16897;
  int D.16898;
  signed char D.16899;
  int D.16900;
  short unsigned int D.16901;
  sizetype D.16902;
  const char * D.16903;
  struct MonoString * D.16904;
  struct MonoString * * D.16905;
  short unsigned int D.16906;
  sizetype D.16907;
  const char * D.16908;
  struct MonoString * D.16909;
  struct MonoString * * D.16910;
  short unsigned int D.16911;
  sizetype D.16912;
  const char * D.16913;
  struct MonoString * D.16914;
  struct MonoString * * D.16915;
  short unsigned int D.16916;
  sizetype D.16917;
  const char * D.16918;
  struct MonoString * D.16919;
  struct MonoString * * D.16920;
  signed char D.16921;
  unsigned int D.16922;
  short unsigned int D.16923;
  sizetype D.16924;
  const char * D.16925;
  struct MonoString * D.16926;
  struct MonoString * * D.16927;
  short unsigned int D.16928;
  sizetype D.16929;
  const char * D.16930;
  struct MonoString * D.16931;
  struct MonoString * * D.16932;
  const gint[2] * D.16933;
  struct MonoArray * D.16934;
  struct MonoArray * * D.16935;
  signed char D.16936;
  int D.16937;
  signed char D.16938;
  int D.16939;
  short unsigned int D.16940;
  sizetype D.16941;
  const char * D.16942;
  struct MonoString * D.16943;
  struct MonoString * * D.16944;
  short unsigned int D.16945;
  sizetype D.16946;
  const char * D.16947;
  struct MonoString * D.16948;
  struct MonoString * * D.16949;
  const gint[2] * D.16950;
  struct MonoArray * D.16951;
  struct MonoArray * * D.16952;
  signed char D.16953;
  int D.16954;
  signed char D.16955;
  int D.16956;
  short unsigned int D.16957;
  sizetype D.16958;
  const char * D.16959;
  struct MonoString * D.16960;
  struct MonoString * * D.16961;
  short unsigned int D.16962;
  sizetype D.16963;
  const char * D.16964;
  struct MonoString * D.16965;
  struct MonoString * * D.16966;
  short unsigned int D.16967;
  sizetype D.16968;
  const char * D.16969;
  struct MonoString * D.16970;
  struct MonoString * * D.16971;
  short unsigned int D.16972;
  sizetype D.16973;
  const char * D.16974;
  struct MonoString * D.16975;
  struct MonoString * * D.16976;
  struct MonoDomain * domain;
  struct MonoNumberFormatInfo * number;
  const struct NumberFormatEntry * nfe;

  D.16872 = this->number_format;
  D.16873 = D.16872 == 0B;
  D.16874 = (long int) D.16873;
  D.16875 = __builtin_expect (D.16874, 0);
  if (D.16875 != 0) goto <D.16876>; else goto <D.16877>;
  <D.16876>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "locales.c", 217, "this->number_format != 0");
  <D.16877>:
  D.16878 = this->number_index;
  if (D.16878 < 0) goto <D.16879>; else goto <D.16880>;
  <D.16879>:
  return;
  <D.16880>:
  number = this->number_format;
  D.16878 = this->number_index;
  nfe = &number_format_entries[D.16878];
  domain = mono_domain_get ();
  D.16881 = this->is_read_only;
  number->readOnly = D.16881;
  D.16882 = nfe->currency_decimal_digits;
  D.16883 = (int) D.16882;
  number->currencyDecimalDigits = D.16883;
  D.16884 = nfe->currency_decimal_separator;
  D.16885 = (sizetype) D.16884;
  D.16886 = &locale_strings + D.16885;
  D.16887 = mono_string_new (domain, D.16886);
  D.16888 = &number->currencyDecimalSeparator;
  mono_gc_wbarrier_set_field (number, D.16888, D.16887);
  D.16889 = nfe->currency_group_separator;
  D.16890 = (sizetype) D.16889;
  D.16891 = &locale_strings + D.16890;
  D.16892 = mono_string_new (domain, D.16891);
  D.16893 = &number->currencyGroupSeparator;
  mono_gc_wbarrier_set_field (number, D.16893, D.16892);
  D.16894 = &nfe->currency_group_sizes;
  D.16895 = create_group_sizes_array (D.16894, 2);
  D.16896 = &number->currencyGroupSizes;
  mono_gc_wbarrier_set_field (number, D.16896, D.16895);
  D.16897 = nfe->currency_negative_pattern;
  D.16898 = (int) D.16897;
  number->currencyNegativePattern = D.16898;
  D.16899 = nfe->currency_positive_pattern;
  D.16900 = (int) D.16899;
  number->currencyPositivePattern = D.16900;
  D.16901 = nfe->currency_symbol;
  D.16902 = (sizetype) D.16901;
  D.16903 = &locale_strings + D.16902;
  D.16904 = mono_string_new (domain, D.16903);
  D.16905 = &number->currencySymbol;
  mono_gc_wbarrier_set_field (number, D.16905, D.16904);
  D.16906 = nfe->nan_symbol;
  D.16907 = (sizetype) D.16906;
  D.16908 = &locale_strings + D.16907;
  D.16909 = mono_string_new (domain, D.16908);
  D.16910 = &number->naNSymbol;
  mono_gc_wbarrier_set_field (number, D.16910, D.16909);
  D.16911 = nfe->negative_infinity_symbol;
  D.16912 = (sizetype) D.16911;
  D.16913 = &locale_strings + D.16912;
  D.16914 = mono_string_new (domain, D.16913);
  D.16915 = &number->negativeInfinitySymbol;
  mono_gc_wbarrier_set_field (number, D.16915, D.16914);
  D.16916 = nfe->negative_sign;
  D.16917 = (sizetype) D.16916;
  D.16918 = &locale_strings + D.16917;
  D.16919 = mono_string_new (domain, D.16918);
  D.16920 = &number->negativeSign;
  mono_gc_wbarrier_set_field (number, D.16920, D.16919);
  D.16921 = nfe->number_decimal_digits;
  D.16922 = (unsigned int) D.16921;
  number->numberDecimalDigits = D.16922;
  D.16923 = nfe->number_decimal_separator;
  D.16924 = (sizetype) D.16923;
  D.16925 = &locale_strings + D.16924;
  D.16926 = mono_string_new (domain, D.16925);
  D.16927 = &number->numberDecimalSeparator;
  mono_gc_wbarrier_set_field (number, D.16927, D.16926);
  D.16928 = nfe->number_group_separator;
  D.16929 = (sizetype) D.16928;
  D.16930 = &locale_strings + D.16929;
  D.16931 = mono_string_new (domain, D.16930);
  D.16932 = &number->numberGroupSeparator;
  mono_gc_wbarrier_set_field (number, D.16932, D.16931);
  D.16933 = &nfe->number_group_sizes;
  D.16934 = create_group_sizes_array (D.16933, 2);
  D.16935 = &number->numberGroupSizes;
  mono_gc_wbarrier_set_field (number, D.16935, D.16934);
  D.16936 = nfe->number_negative_pattern;
  D.16937 = (int) D.16936;
  number->numberNegativePattern = D.16937;
  D.16938 = nfe->percent_decimal_digits;
  D.16939 = (int) D.16938;
  number->percentDecimalDigits = D.16939;
  D.16940 = nfe->percent_decimal_separator;
  D.16941 = (sizetype) D.16940;
  D.16942 = &locale_strings + D.16941;
  D.16943 = mono_string_new (domain, D.16942);
  D.16944 = &number->percentDecimalSeparator;
  mono_gc_wbarrier_set_field (number, D.16944, D.16943);
  D.16945 = nfe->percent_group_separator;
  D.16946 = (sizetype) D.16945;
  D.16947 = &locale_strings + D.16946;
  D.16948 = mono_string_new (domain, D.16947);
  D.16949 = &number->percentGroupSeparator;
  mono_gc_wbarrier_set_field (number, D.16949, D.16948);
  D.16950 = &nfe->percent_group_sizes;
  D.16951 = create_group_sizes_array (D.16950, 2);
  D.16952 = &number->percentGroupSizes;
  mono_gc_wbarrier_set_field (number, D.16952, D.16951);
  D.16953 = nfe->percent_negative_pattern;
  D.16954 = (int) D.16953;
  number->percentNegativePattern = D.16954;
  D.16955 = nfe->percent_positive_pattern;
  D.16956 = (int) D.16955;
  number->percentPositivePattern = D.16956;
  D.16957 = nfe->percent_symbol;
  D.16958 = (sizetype) D.16957;
  D.16959 = &locale_strings + D.16958;
  D.16960 = mono_string_new (domain, D.16959);
  D.16961 = &number->percentSymbol;
  mono_gc_wbarrier_set_field (number, D.16961, D.16960);
  D.16962 = nfe->per_mille_symbol;
  D.16963 = (sizetype) D.16962;
  D.16964 = &locale_strings + D.16963;
  D.16965 = mono_string_new (domain, D.16964);
  D.16966 = &number->perMilleSymbol;
  mono_gc_wbarrier_set_field (number, D.16966, D.16965);
  D.16967 = nfe->positive_infinity_symbol;
  D.16968 = (sizetype) D.16967;
  D.16969 = &locale_strings + D.16968;
  D.16970 = mono_string_new (domain, D.16969);
  D.16971 = &number->positiveInfinitySymbol;
  mono_gc_wbarrier_set_field (number, D.16971, D.16970);
  D.16972 = nfe->positive_sign;
  D.16973 = (sizetype) D.16972;
  D.16974 = &locale_strings + D.16973;
  D.16975 = mono_string_new (domain, D.16974);
  D.16976 = &number->positiveSign;
  mono_gc_wbarrier_set_field (number, D.16976, D.16975);
}


create_group_sizes_array (const gint * gs, gint ml)
{
  long unsigned int D.16978;
  long unsigned int D.16979;
  const gint * D.16980;
  int D.16981;
  long unsigned int D.16983;
  struct MonoClass * D.16443;
  struct MonoClass * tmp_klass.4;
  struct MonoClass * D.16987;
  struct MonoClass * tmp_klass.5;
  _Bool D.16989;
  long int D.16990;
  long int D.16991;
  struct MonoDomain * D.16994;
  struct MonoVTable * D.16995;
  long unsigned int D.16996;
  struct MonoArray * D.16997;
  struct MonoArray * ret;
  int i;
  int len;

  len = 0;
  i = 0;
  goto <D.16441>;
  <D.16440>:
  D.16978 = (long unsigned int) i;
  D.16979 = D.16978 * 4;
  D.16980 = gs + D.16979;
  D.16981 = *D.16980;
  if (D.16981 == -1) goto <D.16439>; else goto <D.16982>;
  <D.16982>:
  len = len + 1;
  i = i + 1;
  <D.16441>:
  if (i < ml) goto <D.16440>; else goto <D.16439>;
  <D.16439>:
  D.16983 = (long unsigned int) len;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.4 = tmp_klass;
      if (tmp_klass.4 == 0B) goto <D.16985>; else goto <D.16986>;
      <D.16985>:
      D.16987 = mono_get_int32_class ();
      tmp_klass.5 = mono_array_class_get (D.16987, 1);
      tmp_klass = tmp_klass.5;
      tmp_klass.4 = tmp_klass;
      D.16989 = tmp_klass.4 == 0B;
      D.16990 = (long int) D.16989;
      D.16991 = __builtin_expect (D.16990, 0);
      if (D.16991 != 0) goto <D.16992>; else goto <D.16993>;
      <D.16992>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "locales.c", 106, "tmp_klass");
      <D.16993>:
      <D.16986>:
    }
    D.16443 = tmp_klass;
  }
  D.16994 = mono_domain_get ();
  D.16995 = mono_class_vtable (D.16994, D.16443);
  ret = mono_array_new_specific (D.16995, D.16983);
  i = 0;
  goto <D.16446>;
  <D.16445>:
  {
    gint32 * __p;

    D.16996 = (long unsigned int) i;
    __p = mono_array_addr_with_size (ret, 4, D.16996);
    D.16978 = (long unsigned int) i;
    D.16979 = D.16978 * 4;
    D.16980 = gs + D.16979;
    D.16981 = *D.16980;
    *__p = D.16981;
  }
  i = i + 1;
  <D.16446>:
  if (i < len) goto <D.16445>; else goto <D.16447>;
  <D.16447>:
  D.16997 = ret;
  return D.16997;
}


ves_icall_System_Globalization_CultureInfo_get_current_locale_name ()
{
  struct MonoString * D.17001;
  gchar * locale;
  struct MonoString * ret;
  struct MonoDomain * domain;

  locale = get_current_locale_name ();
  if (locale == 0B) goto <D.16999>; else goto <D.17000>;
  <D.16999>:
  D.17001 = 0B;
  return D.17001;
  <D.17000>:
  domain = mono_domain_get ();
  ret = mono_string_new (domain, locale);
  monoeg_g_free (locale);
  D.17001 = ret;
  return D.17001;
}


get_current_locale_name ()
{
  gchar * D.17005;
  char * locale;
  char * p;
  char * ret;

  locale = get_posix_locale ();
  if (locale == 0B) goto <D.17003>; else goto <D.17004>;
  <D.17003>:
  D.17005 = 0B;
  return D.17005;
  <D.17004>:
  p = __builtin_strchr (locale, 46);
  if (p != 0B) goto <D.17006>; else goto <D.17007>;
  <D.17006>:
  *p = 0;
  <D.17007>:
  p = __builtin_strchr (locale, 64);
  if (p != 0B) goto <D.17008>; else goto <D.17009>;
  <D.17008>:
  *p = 0;
  <D.17009>:
  p = __builtin_strchr (locale, 95);
  if (p != 0B) goto <D.17010>; else goto <D.17011>;
  <D.17010>:
  *p = 45;
  <D.17011>:
  ret = monoeg_g_ascii_strdown (locale, -1);
  monoeg_g_free (locale);
  D.17005 = ret;
  return D.17005;
}


get_posix_locale ()
{
  char * D.17019;
  int D.16521;
  int iftmp.6;
  int D.16520;
  const char[2] * D.17023;
  unsigned char D.17024;
  int D.17025;
  unsigned char D.17026;
  int D.17027;
  _Bool D.17028;
  _Bool D.17029;
  _Bool D.17030;
  const unsigned char * D.17033;
  unsigned char D.17034;
  int D.17035;
  const unsigned char * D.17036;
  unsigned char D.17037;
  int D.17038;
  _Bool D.17039;
  _Bool D.17040;
  const unsigned char * D.17043;
  unsigned char D.17044;
  int D.17045;
  const unsigned char * D.17046;
  unsigned char D.17047;
  int D.17048;
  _Bool D.17049;
  _Bool D.17050;
  const unsigned char * D.17053;
  unsigned char D.17054;
  int D.17055;
  const unsigned char * D.17056;
  unsigned char D.17057;
  int D.17058;
  const char * locale;

  locale = monoeg_g_getenv ("LC_ALL");
  if (locale == 0B) goto <D.17013>; else goto <D.17014>;
  <D.17013>:
  locale = monoeg_g_getenv ("LANG");
  if (locale == 0B) goto <D.17015>; else goto <D.17016>;
  <D.17015>:
  locale = setlocale (6, 0B);
  <D.17016>:
  <D.17014>:
  if (locale == 0B) goto <D.17017>; else goto <D.17018>;
  <D.17017>:
  D.17019 = 0B;
  return D.17019;
  <D.17018>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 1;
    if (__s2_len <= 3) goto <D.17021>; else goto <D.17022>;
    <D.17021>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = locale;
      D.17023 = "C";
      D.17024 = MEM[(const unsigned char *)D.17023];
      D.17025 = (int) D.17024;
      D.17026 = *__s2;
      D.17027 = (int) D.17026;
      __result = D.17025 - D.17027;
      {
        D.17028 = __s2_len != 0;
        D.17029 = __result == 0;
        D.17030 = D.17028 & D.17029;
        if (D.17030 != 0) goto <D.17031>; else goto <D.17032>;
        <D.17031>:
        D.17033 = &MEM[(void *)"C" + 1B];
        D.17034 = *D.17033;
        D.17035 = (int) D.17034;
        D.17036 = __s2 + 1;
        D.17037 = *D.17036;
        D.17038 = (int) D.17037;
        __result = D.17035 - D.17038;
        D.17039 = __s2_len > 1;
        D.17029 = __result == 0;
        D.17040 = D.17039 & D.17029;
        if (D.17040 != 0) goto <D.17041>; else goto <D.17042>;
        <D.17041>:
        D.17043 = &MEM[(void *)"C" + 2B];
        D.17044 = *D.17043;
        D.17045 = (int) D.17044;
        D.17046 = __s2 + 2;
        D.17047 = *D.17046;
        D.17048 = (int) D.17047;
        __result = D.17045 - D.17048;
        D.17049 = __s2_len > 2;
        D.17029 = __result == 0;
        D.17050 = D.17049 & D.17029;
        if (D.17050 != 0) goto <D.17051>; else goto <D.17052>;
        <D.17051>:
        D.17053 = &MEM[(void *)"C" + 3B];
        D.17054 = *D.17053;
        D.17055 = (int) D.17054;
        D.17056 = __s2 + 3;
        D.17057 = *D.17056;
        D.17058 = (int) D.17057;
        __result = D.17055 - D.17058;
        <D.17052>:
        <D.17042>:
        <D.17032>:
      }
      D.16520 = __result;
    }
    iftmp.6 = -D.16520;
    goto <D.17059>;
    <D.17022>:
    iftmp.6 = __builtin_strcmp (locale, "C");
    <D.17059>:
    D.16521 = iftmp.6;
  }
  if (D.16521 == 0) goto <D.17060>; else goto <D.17061>;
  <D.17060>:
  D.17019 = 0B;
  return D.17019;
  <D.17061>:
  D.17019 = monoeg_strdup (locale);
  return D.17019;
}


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

  if (str != 0B) goto <D.17063>; else goto <D.17064>;
  <D.17063>:
  D.17065 = __strdup (str);
  return D.17065;
  <D.17064>:
  D.17065 = 0B;
  return D.17065;
}


ves_icall_System_Globalization_CultureInfo_construct_internal_locale_from_lcid (struct MonoCultureInfo * this, gint lcid)
{
  MonoBoolean D.17069;
  const struct CultureInfoEntry * ci;

  ci = culture_info_entry_from_lcid (lcid);
  if (ci == 0B) goto <D.17067>; else goto <D.17068>;
  <D.17067>:
  D.17069 = 0;
  return D.17069;
  <D.17068>:
  D.17069 = construct_culture (this, ci);
  return D.17069;
}


culture_info_entry_from_lcid (int lcid)
{
  const struct CultureInfoEntry * D.17071;
  const struct CultureInfoEntry * ci;

  ci = mono_binary_search (&lcid, &culture_entries, 283, 56, culture_lcid_locator);
  D.17071 = ci;
  return D.17071;
}


culture_lcid_locator (const void * a, const void * b)
{
  int D.17073;
  int D.17074;
  short int D.17075;
  int D.17076;
  const int * lcid;
  const struct CultureInfoEntry * bb;

  lcid = a;
  bb = b;
  D.17074 = *lcid;
  D.17075 = bb->lcid;
  D.17076 = (int) D.17075;
  D.17073 = D.17074 - D.17076;
  return D.17073;
}


construct_culture (struct MonoCultureInfo * this, const struct CultureInfoEntry * ci)
{
  short int D.17078;
  int D.17079;
  short unsigned int D.17080;
  sizetype D.17081;
  const char * D.17082;
  struct MonoString * D.17083;
  struct MonoString * * D.17084;
  short unsigned int D.17085;
  sizetype D.17086;
  const char * D.17087;
  struct MonoString * D.17088;
  struct MonoString * * D.17089;
  short unsigned int D.17090;
  sizetype D.17091;
  const char * D.17092;
  struct MonoString * D.17093;
  struct MonoString * * D.17094;
  short unsigned int D.17095;
  sizetype D.17096;
  const char * D.17097;
  struct MonoString * D.17098;
  struct MonoString * * D.17099;
  short unsigned int D.17100;
  sizetype D.17101;
  const char * D.17102;
  struct MonoString * D.17103;
  struct MonoString * * D.17104;
  short unsigned int D.17105;
  sizetype D.17106;
  const char * D.17107;
  struct MonoString * D.17108;
  struct MonoString * * D.17109;
  short unsigned int D.17110;
  sizetype D.17113;
  const char * D.17114;
  struct MonoString * D.17115;
  struct MonoString * * D.17116;
  const stridx_t[4] * D.17117;
  struct MonoArray * D.17118;
  struct MonoArray * * D.17119;
  short int D.17120;
  int D.17121;
  short int D.17122;
  int D.17123;
  short int D.17124;
  int D.17125;
  short int D.17126;
  int D.17127;
  const struct TextInfoEntry * D.17128;
  MonoBoolean D.17129;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.17078 = ci->lcid;
  D.17079 = (int) D.17078;
  this->lcid = D.17079;
  D.17080 = ci->name;
  D.17081 = (sizetype) D.17080;
  D.17082 = &locale_strings + D.17081;
  D.17083 = mono_string_new (domain, D.17082);
  D.17084 = &this->name;
  mono_gc_wbarrier_set_field (this, D.17084, D.17083);
  D.17085 = ci->englishname;
  D.17086 = (sizetype) D.17085;
  D.17087 = &locale_strings + D.17086;
  D.17088 = mono_string_new (domain, D.17087);
  D.17089 = &this->englishname;
  mono_gc_wbarrier_set_field (this, D.17089, D.17088);
  D.17090 = ci->nativename;
  D.17091 = (sizetype) D.17090;
  D.17092 = &locale_strings + D.17091;
  D.17093 = mono_string_new (domain, D.17092);
  D.17094 = &this->nativename;
  mono_gc_wbarrier_set_field (this, D.17094, D.17093);
  D.17095 = ci->win3lang;
  D.17096 = (sizetype) D.17095;
  D.17097 = &locale_strings + D.17096;
  D.17098 = mono_string_new (domain, D.17097);
  D.17099 = &this->win3lang;
  mono_gc_wbarrier_set_field (this, D.17099, D.17098);
  D.17100 = ci->iso3lang;
  D.17101 = (sizetype) D.17100;
  D.17102 = &locale_strings + D.17101;
  D.17103 = mono_string_new (domain, D.17102);
  D.17104 = &this->iso3lang;
  mono_gc_wbarrier_set_field (this, D.17104, D.17103);
  D.17105 = ci->iso2lang;
  D.17106 = (sizetype) D.17105;
  D.17107 = &locale_strings + D.17106;
  D.17108 = mono_string_new (domain, D.17107);
  D.17109 = &this->iso2lang;
  mono_gc_wbarrier_set_field (this, D.17109, D.17108);
  D.17110 = ci->territory;
  if (D.17110 != 0) goto <D.17111>; else goto <D.17112>;
  <D.17111>:
  D.17110 = ci->territory;
  D.17113 = (sizetype) D.17110;
  D.17114 = &locale_strings + D.17113;
  D.17115 = mono_string_new (domain, D.17114);
  D.17116 = &this->territory;
  mono_gc_wbarrier_set_field (this, D.17116, D.17115);
  <D.17112>:
  D.17117 = &ci->native_calendar_names;
  D.17118 = create_names_array_idx (D.17117, 4);
  D.17119 = &this->native_calendar_names;
  mono_gc_wbarrier_set_field (this, D.17119, D.17118);
  D.17120 = ci->parent_lcid;
  D.17121 = (int) D.17120;
  this->parent_lcid = D.17121;
  D.17122 = ci->datetime_format_index;
  D.17123 = (int) D.17122;
  this->datetime_index = D.17123;
  D.17124 = ci->number_format_index;
  D.17125 = (int) D.17124;
  this->number_index = D.17125;
  D.17126 = ci->calendar_type;
  D.17127 = (int) D.17126;
  this->calendar_type = D.17127;
  D.17128 = &ci->text_info;
  this->text_info_data = D.17128;
  D.17129 = 1;
  return D.17129;
}


ves_icall_System_Globalization_CultureInfo_construct_internal_locale_from_name (struct MonoCultureInfo * this, struct MonoString * name)
{
  MonoBoolean D.17133;
  short int D.17134;
  int D.17135;
  const struct CultureInfoEntry * D.17136;
  const struct CultureInfoNameEntry * ne;
  char * n;

  n = mono_string_to_utf8 (name);
  ne = mono_binary_search (n, &culture_name_entries, 283, 4, culture_name_locator);
  if (ne == 0B) goto <D.17131>; else goto <D.17132>;
  <D.17131>:
  monoeg_g_free (n);
  D.17133 = 0;
  return D.17133;
  <D.17132>:
  monoeg_g_free (n);
  D.17134 = ne->culture_entry_index;
  D.17135 = (int) D.17134;
  D.17136 = &culture_entries[D.17135];
  D.17133 = construct_culture (this, D.17136);
  return D.17133;
}


culture_name_locator (const void * a, const void * b)
{
  int ret.7;
  short unsigned int D.17138;
  sizetype D.17139;
  const char * D.17140;
  int D.17141;
  const char * aa;
  const struct CultureInfoNameEntry * bb;
  int ret;

  aa = a;
  bb = b;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.17138 = bb->name;
    D.17139 = (sizetype) D.17138;
    D.17140 = &locale_strings + D.17139;
    ret.7 = __builtin_strcmp (aa, D.17140);
  }
  ret = ret.7;
  D.17141 = ret;
  return D.17141;
}


ves_icall_System_Globalization_RegionInfo_construct_internal_region_from_lcid (struct MonoRegionInfo * this, gint lcid)
{
  MonoBoolean D.17145;
  const struct RegionInfoEntry * ri;

  ri = region_info_entry_from_lcid (lcid);
  if (ri == 0B) goto <D.17143>; else goto <D.17144>;
  <D.17143>:
  D.17145 = 0;
  return D.17145;
  <D.17144>:
  D.17145 = construct_region (this, ri);
  return D.17145;
}


region_info_entry_from_lcid (int lcid)
{
  const struct RegionInfoEntry * D.17149;
  short int D.17150;
  int D.17151;
  const struct RegionInfoEntry * entry;
  const struct CultureInfoEntry * ne;

  ne = mono_binary_search (&lcid, &culture_entries, 283, 56, culture_lcid_locator);
  if (ne == 0B) goto <D.17147>; else goto <D.17148>;
  <D.17147>:
  D.17149 = 0B;
  return D.17149;
  <D.17148>:
  D.17150 = ne->region_entry_index;
  D.17151 = (int) D.17150;
  entry = &region_entries[D.17151];
  D.17149 = entry;
  return D.17149;
}


construct_region (struct MonoRegionInfo * this, const struct RegionInfoEntry * ri)
{
  short int D.17153;
  int D.17154;
  short unsigned int D.17155;
  sizetype D.17156;
  const char * D.17157;
  struct MonoString * D.17158;
  struct MonoString * * D.17159;
  short unsigned int D.17160;
  sizetype D.17161;
  const char * D.17162;
  struct MonoString * D.17163;
  struct MonoString * * D.17164;
  short unsigned int D.17165;
  sizetype D.17166;
  const char * D.17167;
  struct MonoString * D.17168;
  struct MonoString * * D.17169;
  short unsigned int D.17170;
  sizetype D.17171;
  const char * D.17172;
  struct MonoString * D.17173;
  struct MonoString * * D.17174;
  short unsigned int D.17175;
  sizetype D.17176;
  const char * D.17177;
  struct MonoString * D.17178;
  struct MonoString * * D.17179;
  short unsigned int D.17180;
  sizetype D.17181;
  const char * D.17182;
  struct MonoString * D.17183;
  struct MonoString * * D.17184;
  short unsigned int D.17185;
  sizetype D.17186;
  const char * D.17187;
  struct MonoString * D.17188;
  struct MonoString * * D.17189;
  short unsigned int D.17190;
  sizetype D.17191;
  const char * D.17192;
  struct MonoString * D.17193;
  struct MonoString * * D.17194;
  short unsigned int D.17195;
  sizetype D.17196;
  const char * D.17197;
  struct MonoString * D.17198;
  struct MonoString * * D.17199;
  MonoBoolean D.17200;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.17153 = ri->geo_id;
  D.17154 = (int) D.17153;
  this->geo_id = D.17154;
  D.17155 = ri->iso2name;
  D.17156 = (sizetype) D.17155;
  D.17157 = &locale_strings + D.17156;
  D.17158 = mono_string_new (domain, D.17157);
  D.17159 = &this->iso2name;
  mono_gc_wbarrier_set_field (this, D.17159, D.17158);
  D.17160 = ri->iso3name;
  D.17161 = (sizetype) D.17160;
  D.17162 = &locale_strings + D.17161;
  D.17163 = mono_string_new (domain, D.17162);
  D.17164 = &this->iso3name;
  mono_gc_wbarrier_set_field (this, D.17164, D.17163);
  D.17165 = ri->win3name;
  D.17166 = (sizetype) D.17165;
  D.17167 = &locale_strings + D.17166;
  D.17168 = mono_string_new (domain, D.17167);
  D.17169 = &this->win3name;
  mono_gc_wbarrier_set_field (this, D.17169, D.17168);
  D.17170 = ri->english_name;
  D.17171 = (sizetype) D.17170;
  D.17172 = &locale_strings + D.17171;
  D.17173 = mono_string_new (domain, D.17172);
  D.17174 = &this->english_name;
  mono_gc_wbarrier_set_field (this, D.17174, D.17173);
  D.17175 = ri->native_name;
  D.17176 = (sizetype) D.17175;
  D.17177 = &locale_strings + D.17176;
  D.17178 = mono_string_new (domain, D.17177);
  D.17179 = &this->native_name;
  mono_gc_wbarrier_set_field (this, D.17179, D.17178);
  D.17180 = ri->currency_symbol;
  D.17181 = (sizetype) D.17180;
  D.17182 = &locale_strings + D.17181;
  D.17183 = mono_string_new (domain, D.17182);
  D.17184 = &this->currency_symbol;
  mono_gc_wbarrier_set_field (this, D.17184, D.17183);
  D.17185 = ri->iso_currency_symbol;
  D.17186 = (sizetype) D.17185;
  D.17187 = &locale_strings + D.17186;
  D.17188 = mono_string_new (domain, D.17187);
  D.17189 = &this->iso_currency_symbol;
  mono_gc_wbarrier_set_field (this, D.17189, D.17188);
  D.17190 = ri->currency_english_name;
  D.17191 = (sizetype) D.17190;
  D.17192 = &locale_strings + D.17191;
  D.17193 = mono_string_new (domain, D.17192);
  D.17194 = &this->currency_english_name;
  mono_gc_wbarrier_set_field (this, D.17194, D.17193);
  D.17195 = ri->currency_native_name;
  D.17196 = (sizetype) D.17195;
  D.17197 = &locale_strings + D.17196;
  D.17198 = mono_string_new (domain, D.17197);
  D.17199 = &this->currency_native_name;
  mono_gc_wbarrier_set_field (this, D.17199, D.17198);
  D.17200 = 1;
  return D.17200;
}


ves_icall_System_Globalization_RegionInfo_construct_internal_region_from_name (struct MonoRegionInfo * this, struct MonoString * name)
{
  MonoBoolean D.17204;
  short int D.17205;
  int D.17206;
  const struct RegionInfoEntry * D.17207;
  const struct RegionInfoNameEntry * ne;
  char * n;

  n = mono_string_to_utf8 (name);
  ne = mono_binary_search (n, &region_name_entries, 120, 4, region_name_locator);
  if (ne == 0B) goto <D.17202>; else goto <D.17203>;
  <D.17202>:
  monoeg_g_free (n);
  D.17204 = 0;
  return D.17204;
  <D.17203>:
  monoeg_g_free (n);
  D.17205 = ne->region_entry_index;
  D.17206 = (int) D.17205;
  D.17207 = &region_entries[D.17206];
  D.17204 = construct_region (this, D.17207);
  return D.17204;
}


region_name_locator (const void * a, const void * b)
{
  int ret.8;
  short unsigned int D.17209;
  sizetype D.17210;
  const char * D.17211;
  int D.17212;
  const char * aa;
  const struct RegionInfoNameEntry * bb;
  int ret;

  aa = a;
  bb = b;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.17209 = bb->name;
    D.17210 = (sizetype) D.17209;
    D.17211 = &locale_strings + D.17210;
    ret.8 = __builtin_strcmp (aa, D.17211);
  }
  ret = ret.8;
  D.17212 = ret;
  return D.17212;
}


ves_icall_System_Globalization_CultureInfo_internal_get_cultures (MonoBoolean neutral, MonoBoolean specific, MonoBoolean installed)
{
  short unsigned int D.17214;
  _Bool D.17215;
  _Bool D.17218;
  _Bool D.17219;
  _Bool D.17220;
  _Bool D.17222;
  _Bool D.17223;
  _Bool D.17224;
  struct MonoImage * D.17225;
  long unsigned int D.17228;
  struct MonoArray * D.17231;
  int len.9;
  long unsigned int D.17235;
  int len.10;
  long unsigned int D.17240;
  struct MonoArray * ret;
  struct MonoClass * class;
  struct MonoCultureInfo * culture;
  struct MonoDomain * domain;
  const struct CultureInfoEntry * ci;
  gint i;
  gint len;
  gboolean is_neutral;

  domain = mono_domain_get ();
  len = 0;
  i = 0;
  goto <D.16570>;
  <D.16569>:
  ci = &culture_entries[i];
  D.17214 = ci->territory;
  D.17215 = D.17214 == 0;
  is_neutral = (gboolean) D.17215;
  D.17218 = neutral != 0;
  D.17219 = is_neutral != 0;
  D.17220 = D.17218 & D.17219;
  if (D.17220 != 0) goto <D.17216>; else goto <D.17221>;
  <D.17221>:
  D.17222 = specific != 0;
  D.17223 = is_neutral == 0;
  D.17224 = D.17222 & D.17223;
  if (D.17224 != 0) goto <D.17216>; else goto <D.17217>;
  <D.17216>:
  len = len + 1;
  <D.17217>:
  i = i + 1;
  <D.16570>:
  if (i <= 282) goto <D.16569>; else goto <D.16571>;
  <D.16571>:
  D.17225 = mono_get_corlib ();
  class = mono_class_from_name (D.17225, "System.Globalization", "CultureInfo");
  if (neutral != 0) goto <D.17226>; else goto <D.17227>;
  <D.17226>:
  len = len + 1;
  <D.17227>:
  D.17228 = (long unsigned int) len;
  ret = mono_array_new (domain, class, D.17228);
  if (len == 0) goto <D.17229>; else goto <D.17230>;
  <D.17229>:
  D.17231 = ret;
  return D.17231;
  <D.17230>:
  len = 0;
  if (neutral != 0) goto <D.17232>; else goto <D.17233>;
  <D.17232>:
  {
    void * * __p;

    len.9 = len;
    len = len.9 + 1;
    D.17235 = (long unsigned int) len.9;
    __p = mono_array_addr_with_size (ret, 8, D.17235);
    mono_gc_wbarrier_set_arrayref (ret, __p, 0B);
  }
  <D.17233>:
  i = 0;
  goto <D.16575>;
  <D.16574>:
  ci = &culture_entries[i];
  D.17214 = ci->territory;
  D.17215 = D.17214 == 0;
  is_neutral = (gboolean) D.17215;
  D.17218 = neutral != 0;
  D.17219 = is_neutral != 0;
  D.17220 = D.17218 & D.17219;
  if (D.17220 != 0) goto <D.17236>; else goto <D.17238>;
  <D.17238>:
  D.17222 = specific != 0;
  D.17223 = is_neutral == 0;
  D.17224 = D.17222 & D.17223;
  if (D.17224 != 0) goto <D.17236>; else goto <D.17237>;
  <D.17236>:
  culture = mono_object_new (domain, class);
  mono_runtime_object_init (culture);
  construct_culture (culture, ci);
  culture->use_user_override = 1;
  {
    void * * __p;

    len.10 = len;
    len = len.10 + 1;
    D.17240 = (long unsigned int) len.10;
    __p = mono_array_addr_with_size (ret, 8, D.17240);
    mono_gc_wbarrier_set_arrayref (ret, __p, culture);
  }
  <D.17237>:
  i = i + 1;
  <D.16575>:
  if (i <= 282) goto <D.16574>; else goto <D.16576>;
  <D.16576>:
  D.17231 = ret;
  return D.17231;
}


ves_icall_System_Globalization_CompareInfo_construct_compareinfo (struct MonoCompareInfo * comp, struct MonoString * locale)
{

}


ves_icall_System_Globalization_CompareInfo_internal_compare (struct MonoCompareInfo * this, struct MonoString * str1, gint32 off1, gint32 len1, struct MonoString * str2, gint32 off2, gint32 len2, gint32 options)
{
  int D.17242;

  D.17242 = string_invariant_compare (str1, off1, len1, str2, off2, len2, options);
  return D.17242;
}


string_invariant_compare (struct MonoString * str1, gint32 off1, gint32 len1, struct MonoString * str2, gint32 off2, gint32 len2, gint32 options)
{
  mono_unichar2 * D.17247;
  long unsigned int D.17248;
  long unsigned int D.17249;
  mono_unichar2 * D.17250;
  long unsigned int D.17251;
  long unsigned int D.17252;
  _Bool D.17253;
  _Bool D.17254;
  _Bool D.17255;
  long unsigned int D.17257;
  long unsigned int D.17258;
  gunichar2 * D.17259;
  short unsigned int D.17260;
  int D.17261;
  gunichar2 * D.17262;
  short unsigned int D.17263;
  int D.17264;
  gint32 D.17267;
  sizetype D.17270;
  gunichar2 * D.17271;
  short unsigned int D.17272;
  int D.17273;
  gunichar2 * D.17274;
  short unsigned int D.17275;
  int D.17276;
  gint32 length;
  gint32 charcmp;
  gunichar2 * ustr1;
  gunichar2 * ustr2;
  gint32 pos;

  if (len1 >= len2) goto <D.17244>; else goto <D.17245>;
  <D.17244>:
  length = len1;
  goto <D.17246>;
  <D.17245>:
  length = len2;
  <D.17246>:
  D.17247 = mono_string_chars (str1);
  D.17248 = (long unsigned int) off1;
  D.17249 = D.17248 * 2;
  ustr1 = D.17247 + D.17249;
  D.17250 = mono_string_chars (str2);
  D.17251 = (long unsigned int) off2;
  D.17252 = D.17251 * 2;
  ustr2 = D.17250 + D.17252;
  pos = 0;
  pos = 0;
  goto <D.16658>;
  <D.16657>:
  D.17253 = pos >= len1;
  D.17254 = pos >= len2;
  D.17255 = D.17253 | D.17254;
  if (D.17255 != 0) goto <D.16656>; else goto <D.17256>;
  <D.17256>:
  D.17257 = (long unsigned int) pos;
  D.17258 = D.17257 * 2;
  D.17259 = ustr2 + D.17258;
  D.17260 = *D.17259;
  D.17261 = (int) D.17260;
  D.17257 = (long unsigned int) pos;
  D.17258 = D.17257 * 2;
  D.17262 = ustr1 + D.17258;
  D.17263 = *D.17262;
  D.17264 = (int) D.17263;
  charcmp = string_invariant_compare_char (D.17264, D.17261, options);
  if (charcmp != 0) goto <D.17265>; else goto <D.17266>;
  <D.17265>:
  D.17267 = charcmp;
  return D.17267;
  <D.17266>:
  pos = pos + 1;
  <D.16658>:
  if (pos != length) goto <D.16657>; else goto <D.16656>;
  <D.16656>:
  if (pos == length) goto <D.17268>; else goto <D.17269>;
  <D.17268>:
  D.17257 = (long unsigned int) pos;
  D.17258 = D.17257 * 2;
  D.17270 = D.17258 + 18446744073709551614;
  D.17271 = ustr2 + D.17270;
  D.17272 = *D.17271;
  D.17273 = (int) D.17272;
  D.17257 = (long unsigned int) pos;
  D.17258 = D.17257 * 2;
  D.17270 = D.17258 + 18446744073709551614;
  D.17274 = ustr1 + D.17270;
  D.17275 = *D.17274;
  D.17276 = (int) D.17275;
  D.17267 = string_invariant_compare_char (D.17276, D.17273, options);
  return D.17267;
  <D.17269>:
  if (pos >= len1) goto <D.17277>; else goto <D.17278>;
  <D.17277>:
  if (pos >= len2) goto <D.17279>; else goto <D.17280>;
  <D.17279>:
  D.17267 = 0;
  return D.17267;
  <D.17280>:
  D.17267 = -1;
  return D.17267;
  <D.17278>:
  if (pos >= len2) goto <D.17281>; else goto <D.17282>;
  <D.17281>:
  D.17267 = 1;
  return D.17267;
  <D.17282>:
  D.17257 = (long unsigned int) pos;
  D.17258 = D.17257 * 2;
  D.17259 = ustr2 + D.17258;
  D.17260 = *D.17259;
  D.17261 = (int) D.17260;
  D.17257 = (long unsigned int) pos;
  D.17258 = D.17257 * 2;
  D.17262 = ustr1 + D.17258;
  D.17263 = *D.17262;
  D.17264 = (int) D.17263;
  D.17267 = string_invariant_compare_char (D.17264, D.17261, options);
  return D.17267;
}


string_invariant_compare_char (gunichar2 c1, gunichar2 c2, gint32 options)
{
  int D.17284;
  gint32 D.17287;
  int D.17288;
  int D.17289;
  int D.17290;
  unsigned int D.17293;
  unsigned int D.17294;
  gunichar iftmp.11;
  gunichar iftmp.12;
  unsigned int D.17303;
  gint32 iftmp.13;
  _Bool D.17308;
  gint32 result;

  D.17284 = options & 1073741824;
  if (D.17284 != 0) goto <D.17285>; else goto <D.17286>;
  <D.17285>:
  D.17288 = (int) c1;
  D.17289 = (int) c2;
  D.17287 = D.17288 - D.17289;
  return D.17287;
  <D.17286>:
  D.17290 = options & 1;
  if (D.17290 != 0) goto <D.17291>; else goto <D.17292>;
  <D.17291>:
  {
    GUnicodeType c1type;
    GUnicodeType c2type;

    D.17293 = (unsigned int) c1;
    c1type = monoeg_g_unichar_type (D.17293);
    D.17294 = (unsigned int) c2;
    c2type = monoeg_g_unichar_type (D.17294);
    if (c1type != 5) goto <D.17296>; else goto <D.17297>;
    <D.17296>:
    D.17293 = (unsigned int) c1;
    iftmp.11 = monoeg_g_unichar_tolower (D.17293);
    goto <D.17298>;
    <D.17297>:
    iftmp.11 = (gunichar) c1;
    <D.17298>:
    if (c2type != 5) goto <D.17300>; else goto <D.17301>;
    <D.17300>:
    D.17294 = (unsigned int) c2;
    iftmp.12 = monoeg_g_unichar_tolower (D.17294);
    goto <D.17302>;
    <D.17301>:
    iftmp.12 = (gunichar) c2;
    <D.17302>:
    D.17303 = iftmp.11 - iftmp.12;
    result = (gint32) D.17303;
  }
  goto <D.17304>;
  <D.17292>:
  D.17288 = (int) c1;
  D.17289 = (int) c2;
  result = D.17288 - D.17289;
  <D.17304>:
  if (result >= 0) goto <D.17306>; else goto <D.17307>;
  <D.17306>:
  D.17308 = result > 0;
  iftmp.13 = (gint32) D.17308;
  goto <D.17309>;
  <D.17307>:
  iftmp.13 = -1;
  <D.17309>:
  D.17287 = iftmp.13;
  return D.17287;
}


ves_icall_System_Globalization_CompareInfo_free_internal_collator (struct MonoCompareInfo * this)
{

}


ves_icall_System_Globalization_CompareInfo_assign_sortkey (struct MonoCompareInfo * this, struct MonoSortKey * key, struct MonoString * source, gint32 options)
{
  long unsigned int D.17311;
  struct MonoClass * D.17312;
  struct MonoDomain * D.17313;
  long unsigned int D.17314;
  mono_unichar2 * D.17315;
  long unsigned int D.17316;
  long unsigned int D.17317;
  mono_unichar2 * D.17318;
  short unsigned int D.17319;
  unsigned char D.17320;
  struct MonoArray * * D.17321;
  struct MonoArray * arr;
  gint32 keylen;
  gint32 i;

  keylen = mono_string_length (source);
  D.17311 = (long unsigned int) keylen;
  D.17312 = mono_get_byte_class ();
  D.17313 = mono_domain_get ();
  arr = mono_array_new (D.17313, D.17312, D.17311);
  i = 0;
  goto <D.16605>;
  <D.16604>:
  {
    guint8 * __p;

    D.17314 = (long unsigned int) i;
    __p = mono_array_addr_with_size (arr, 1, D.17314);
    D.17315 = mono_string_chars (source);
    D.17316 = (long unsigned int) i;
    D.17317 = D.17316 * 2;
    D.17318 = D.17315 + D.17317;
    D.17319 = *D.17318;
    D.17320 = (unsigned char) D.17319;
    *__p = D.17320;
  }
  i = i + 1;
  <D.16605>:
  if (i < keylen) goto <D.16604>; else goto <D.16606>;
  <D.16606>:
  D.17321 = &key->key;
  mono_gc_wbarrier_set_field (key, D.17321, arr);
}


ves_icall_System_Globalization_CompareInfo_internal_index (struct MonoCompareInfo * this, struct MonoString * source, gint32 sindex, gint32 count, struct MonoString * value, gint32 options, MonoBoolean first)
{
  int D.17322;
  int D.17323;

  D.17323 = (int) first;
  D.17322 = string_invariant_indexof (source, sindex, count, value, D.17323);
  return D.17322;
}


string_invariant_indexof (struct MonoString * source, gint32 sindex, gint32 count, struct MonoString * value, MonoBoolean first)
{
  gint32 D.17329;
  int D.17330;
  long unsigned int D.17331;
  long unsigned int D.17332;
  gunichar2 * D.17333;
  short unsigned int D.17334;
  long unsigned int D.17335;
  long unsigned int D.17336;
  gunichar2 * D.17337;
  short unsigned int D.17338;
  int D.17339;
  int D.17340;
  long unsigned int D.17341;
  long unsigned int D.17342;
  long unsigned int D.17343;
  long unsigned int D.17344;
  const void * D.17345;
  int D.17346;
  int D.17349;
  gint32 lencmpstr;
  gunichar2 * src;
  gunichar2 * cmpstr;
  gint32 pos;
  gint32 i;

  lencmpstr = mono_string_length (value);
  src = mono_string_chars (source);
  cmpstr = mono_string_chars (value);
  if (first != 0) goto <D.17325>; else goto <D.17326>;
  <D.17325>:
  count = count - lencmpstr;
  pos = sindex;
  goto <D.16698>;
  <D.16697>:
  i = 0;
  goto <D.16695>;
  <D.16694>:
  i = i + 1;
  if (i == lencmpstr) goto <D.17327>; else goto <D.17328>;
  <D.17327>:
  D.17329 = pos;
  return D.17329;
  <D.17328>:
  <D.16695>:
  D.17330 = pos + i;
  D.17331 = (long unsigned int) D.17330;
  D.17332 = D.17331 * 2;
  D.17333 = src + D.17332;
  D.17334 = *D.17333;
  D.17335 = (long unsigned int) i;
  D.17336 = D.17335 * 2;
  D.17337 = cmpstr + D.17336;
  D.17338 = *D.17337;
  if (D.17334 == D.17338) goto <D.16694>; else goto <D.16696>;
  <D.16696>:
  pos = pos + 1;
  <D.16698>:
  D.17339 = sindex + count;
  if (D.17339 >= pos) goto <D.16697>; else goto <D.16699>;
  <D.16699>:
  D.17329 = -1;
  return D.17329;
  <D.17326>:
  D.17340 = sindex - lencmpstr;
  pos = D.17340 + 1;
  goto <D.16701>;
  <D.16700>:
  D.17341 = (long unsigned int) lencmpstr;
  D.17342 = D.17341 * 2;
  D.17343 = (long unsigned int) pos;
  D.17344 = D.17343 * 2;
  D.17345 = src + D.17344;
  D.17346 = memcmp (D.17345, cmpstr, D.17342);
  if (D.17346 == 0) goto <D.17347>; else goto <D.17348>;
  <D.17347>:
  D.17329 = pos;
  return D.17329;
  <D.17348>:
  pos = pos + -1;
  <D.16701>:
  D.17349 = sindex - count;
  if (D.17349 < pos) goto <D.16700>; else goto <D.16702>;
  <D.16702>:
  D.17329 = -1;
  return D.17329;
}


ves_icall_System_Globalization_CompareInfo_internal_index_char (struct MonoCompareInfo * this, struct MonoString * source, gint32 sindex, gint32 count, gunichar2 value, gint32 options, MonoBoolean first)
{
  int D.17351;
  int D.17352;
  int D.17353;

  D.17352 = (int) first;
  D.17353 = (int) value;
  D.17351 = string_invariant_indexof_char (source, sindex, count, D.17353, D.17352);
  return D.17351;
}


string_invariant_indexof_char (struct MonoString * source, gint32 sindex, gint32 count, gunichar2 value, MonoBoolean first)
{
  long unsigned int D.17357;
  long unsigned int D.17358;
  gunichar2 * D.17359;
  short unsigned int D.17360;
  gint32 D.17363;
  int D.17364;
  int D.17367;
  gint32 pos;
  gunichar2 * src;

  src = mono_string_chars (source);
  if (first != 0) goto <D.17355>; else goto <D.17356>;
  <D.17355>:
  pos = sindex;
  goto <D.16713>;
  <D.16712>:
  D.17357 = (long unsigned int) pos;
  D.17358 = D.17357 * 2;
  D.17359 = src + D.17358;
  D.17360 = *D.17359;
  if (D.17360 == value) goto <D.17361>; else goto <D.17362>;
  <D.17361>:
  D.17363 = pos;
  return D.17363;
  <D.17362>:
  pos = pos + 1;
  <D.16713>:
  D.17364 = count + sindex;
  if (D.17364 != pos) goto <D.16712>; else goto <D.16714>;
  <D.16714>:
  D.17363 = -1;
  return D.17363;
  <D.17356>:
  pos = sindex;
  goto <D.16716>;
  <D.16715>:
  D.17357 = (long unsigned int) pos;
  D.17358 = D.17357 * 2;
  D.17359 = src + D.17358;
  D.17360 = *D.17359;
  if (D.17360 == value) goto <D.17365>; else goto <D.17366>;
  <D.17365>:
  D.17363 = pos;
  return D.17363;
  <D.17366>:
  pos = pos + -1;
  <D.16716>:
  D.17367 = sindex - count;
  if (D.17367 < pos) goto <D.16715>; else goto <D.16717>;
  <D.16717>:
  D.17363 = -1;
  return D.17363;
}


ves_icall_System_Threading_Thread_current_lcid ()
{
  int D.17369;

  D.17369 = 127;
  return D.17369;
}


ves_icall_System_String_InternalReplace_Str_Comp (struct MonoString * this, struct MonoString * old, struct MonoString * new, struct MonoCompareInfo * comp)
{
  struct MonoString * D.17371;

  D.17371 = string_invariant_replace (this, old, new);
  return D.17371;
}


string_invariant_replace (struct MonoString * me, struct MonoString * oldValue, struct MonoString * newValue)
{
  long unsigned int D.17378;
  long unsigned int D.17379;
  long unsigned int D.17380;
  long unsigned int D.17381;
  const void * D.17382;
  int D.17383;
  int D.17387;
  struct MonoString * D.17390;
  int D.17391;
  int D.17392;
  int D.17394;
  struct MonoDomain * D.17399;
  long unsigned int D.17402;
  long unsigned int D.17403;
  long unsigned int D.17404;
  long unsigned int D.17405;
  gunichar2 * D.17406;
  gunichar2 * D.17409;
  short unsigned int D.17410;
  struct MonoString * ret;
  gunichar2 * src;
  gunichar2 * dest;
  gunichar2 * oldstr;
  gunichar2 * newstr;
  gint32 i;
  gint32 destpos;
  gint32 occurr;
  gint32 newsize;
  gint32 oldstrlen;
  gint32 newstrlen;
  gint32 srclen;

  dest = 0B;
  newstr = 0B;
  occurr = 0;
  destpos = 0;
  oldstr = mono_string_chars (oldValue);
  oldstrlen = mono_string_length (oldValue);
  if (newValue != 0B) goto <D.17373>; else goto <D.17374>;
  <D.17373>:
  newstr = mono_string_chars (newValue);
  newstrlen = mono_string_length (newValue);
  goto <D.17375>;
  <D.17374>:
  newstrlen = 0;
  <D.17375>:
  src = mono_string_chars (me);
  srclen = mono_string_length (me);
  if (oldstrlen != newstrlen) goto <D.17376>; else goto <D.17377>;
  <D.17376>:
  i = 0;
  goto <D.16677>;
  <D.16676>:
  D.17378 = (long unsigned int) oldstrlen;
  D.17379 = D.17378 * 2;
  D.17380 = (long unsigned int) i;
  D.17381 = D.17380 * 2;
  D.17382 = src + D.17381;
  D.17383 = memcmp (D.17382, oldstr, D.17379);
  if (D.17383 == 0) goto <D.17384>; else goto <D.17385>;
  <D.17384>:
  occurr = occurr + 1;
  i = i + oldstrlen;
  goto <D.17386>;
  <D.17385>:
  i = i + 1;
  <D.17386>:
  <D.16677>:
  D.17387 = srclen - oldstrlen;
  if (D.17387 >= i) goto <D.16676>; else goto <D.16678>;
  <D.16678>:
  if (occurr == 0) goto <D.17388>; else goto <D.17389>;
  <D.17388>:
  D.17390 = me;
  return D.17390;
  <D.17389>:
  D.17391 = newstrlen - oldstrlen;
  D.17392 = D.17391 * occurr;
  newsize = D.17392 + srclen;
  goto <D.17393>;
  <D.17377>:
  newsize = srclen;
  <D.17393>:
  ret = 0B;
  i = 0;
  goto <D.16679>;
  <D.16680>:
  D.17378 = (long unsigned int) oldstrlen;
  D.17379 = D.17378 * 2;
  D.17380 = (long unsigned int) i;
  D.17381 = D.17380 * 2;
  D.17382 = src + D.17381;
  D.17394 = memcmp (D.17382, oldstr, D.17379);
  if (D.17394 == 0) goto <D.17395>; else goto <D.17396>;
  <D.17395>:
  if (ret == 0B) goto <D.17397>; else goto <D.17398>;
  <D.17397>:
  D.17399 = mono_domain_get ();
  ret = mono_string_new_size (D.17399, newsize);
  dest = mono_string_chars (ret);
  D.17380 = (long unsigned int) i;
  D.17381 = D.17380 * 2;
  memcpy (dest, src, D.17381);
  <D.17398>:
  if (newstrlen > 0) goto <D.17400>; else goto <D.17401>;
  <D.17400>:
  D.17402 = (long unsigned int) newstrlen;
  D.17403 = D.17402 * 2;
  D.17404 = (long unsigned int) destpos;
  D.17405 = D.17404 * 2;
  D.17406 = dest + D.17405;
  memcpy (D.17406, newstr, D.17403);
  destpos = destpos + newstrlen;
  <D.17401>:
  i = i + oldstrlen;
  // predicted unlikely by continue predictor.
  goto <D.16679>;
  <D.17396>:
  if (ret != 0B) goto <D.17407>; else goto <D.17408>;
  <D.17407>:
  D.17404 = (long unsigned int) destpos;
  D.17405 = D.17404 * 2;
  D.17406 = dest + D.17405;
  D.17380 = (long unsigned int) i;
  D.17381 = D.17380 * 2;
  D.17409 = src + D.17381;
  D.17410 = *D.17409;
  *D.17406 = D.17410;
  <D.17408>:
  destpos = destpos + 1;
  i = i + 1;
  <D.16679>:
  if (i < srclen) goto <D.16680>; else goto <D.16681>;
  <D.16681>:
  if (ret == 0B) goto <D.17411>; else goto <D.17412>;
  <D.17411>:
  D.17390 = me;
  return D.17390;
  <D.17412>:
  D.17390 = ret;
  return D.17390;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.17414;
  long unsigned int D.17415;

  D.17415 = __builtin_object_size (__dest, 0);
  D.17414 = __builtin___memcpy_chk (__dest, __src, __len, D.17415);
  return D.17414;
}


load_normalization_resource (guint8 * * argProps, guint8 * * argMappedChars, guint8 * * argCharMapIndex, guint8 * * argHelperIndex, guint8 * * argMapIdxToComposite, guint8 * * argCombiningClass)
{
  *argProps = &props;
  *argMappedChars = &mappedChars;
  *argCharMapIndex = &charMapIndex;
  *argHelperIndex = &helperIndex;
  *argMapIdxToComposite = &mapIdxToComposite;
  *argCombiningClass = &combiningClass;
}


