__attribute__((visibility ("hidden")))
ves_icall_System_Globalization_CultureInfo_construct_datetime_format (struct MonoCultureInfo * this)
{
  int D.16844;
  _Bool D.16845;
  long int D.16846;
  long int D.16847;
  unsigned char D.16850;
  struct MonoArray * * D.16851;
  const stridx_t[7] * D.16852;
  struct MonoArray * D.16853;
  struct MonoArray * * D.16854;
  const stridx_t[13] * D.16855;
  struct MonoArray * D.16856;
  struct MonoString * * D.16857;
  short unsigned int D.16858;
  sizetype D.16859;
  const char * D.16860;
  struct MonoString * D.16861;
  signed char D.16862;
  unsigned int D.16863;
  struct MonoString * * D.16864;
  short unsigned int D.16865;
  sizetype D.16866;
  const char * D.16867;
  struct MonoString * D.16868;
  struct MonoArray * * D.16869;
  const stridx_t[7] * D.16870;
  struct MonoArray * D.16871;
  struct MonoArray * * D.16872;
  const stridx_t[7] * D.16873;
  struct MonoArray * D.16874;
  signed char D.16875;
  unsigned int D.16876;
  struct MonoString * * D.16877;
  short unsigned int D.16878;
  sizetype D.16879;
  const char * D.16880;
  struct MonoString * D.16881;
  struct MonoString * * D.16882;
  short unsigned int D.16883;
  sizetype D.16884;
  const char * D.16885;
  struct MonoString * D.16886;
  struct MonoString * * D.16887;
  short unsigned int D.16888;
  sizetype D.16889;
  const char * D.16890;
  struct MonoString * D.16891;
  struct MonoArray * * D.16892;
  const stridx_t[13] * D.16893;
  struct MonoArray * D.16894;
  struct MonoString * * D.16895;
  short unsigned int D.16896;
  sizetype D.16897;
  const char * D.16898;
  struct MonoString * D.16899;
  struct MonoString * * 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 MonoArray * * D.16920;
  const stridx_t[14] * D.16921;
  struct MonoArray * D.16922;
  struct MonoArray * * D.16923;
  const stridx_t[8] * D.16924;
  struct MonoArray * D.16925;
  struct MonoArray * * D.16926;
  const stridx_t[12] * D.16927;
  struct MonoArray * D.16928;
  struct MonoArray * * D.16929;
  const stridx_t[9] * D.16930;
  struct MonoArray * D.16931;
  struct MonoArray * * D.16932;
  const stridx_t[13] * D.16933;
  struct MonoArray * D.16934;
  struct MonoArray * * D.16935;
  const stridx_t[13] * D.16936;
  struct MonoArray * D.16937;
  struct MonoDomain * domain;
  struct MonoDateTimeFormatInfo * datetime;
  const struct DateTimeFormatEntry * dfe;

  D.16844 = this->datetime_index;
  D.16845 = D.16844 < 0;
  D.16846 = (long int) D.16845;
  D.16847 = __builtin_expect (D.16846, 0);
  if (D.16847 != 0) goto <D.16848>; else goto <D.16849>;
  <D.16848>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "locales.c", 169, "this->datetime_index >= 0");
  <D.16849>:
  datetime = this->datetime_format;
  D.16844 = this->datetime_index;
  dfe = &datetime_format_entries[D.16844];
  domain = mono_domain_get ();
  D.16850 = this->is_read_only;
  datetime->readOnly = D.16850;
  D.16851 = &datetime->AbbreviatedDayNames;
  D.16852 = &dfe->abbreviated_day_names;
  D.16853 = create_names_array_idx (D.16852, 7);
  mono_gc_wbarrier_set_field (datetime, D.16851, D.16853);
  D.16854 = &datetime->AbbreviatedMonthNames;
  D.16855 = &dfe->abbreviated_month_names;
  D.16856 = create_names_array_idx (D.16855, 13);
  mono_gc_wbarrier_set_field (datetime, D.16854, D.16856);
  D.16857 = &datetime->AMDesignator;
  D.16858 = dfe->am_designator;
  D.16859 = (sizetype) D.16858;
  D.16860 = &locale_strings + D.16859;
  D.16861 = mono_string_new (domain, D.16860);
  mono_gc_wbarrier_set_field (datetime, D.16857, D.16861);
  D.16862 = dfe->calendar_week_rule;
  D.16863 = (unsigned int) D.16862;
  datetime->CalendarWeekRule = D.16863;
  D.16864 = &datetime->DateSeparator;
  D.16865 = dfe->date_separator;
  D.16866 = (sizetype) D.16865;
  D.16867 = &locale_strings + D.16866;
  D.16868 = mono_string_new (domain, D.16867);
  mono_gc_wbarrier_set_field (datetime, D.16864, D.16868);
  D.16869 = &datetime->DayNames;
  D.16870 = &dfe->day_names;
  D.16871 = create_names_array_idx (D.16870, 7);
  mono_gc_wbarrier_set_field (datetime, D.16869, D.16871);
  D.16872 = &datetime->ShortestDayNames;
  D.16873 = &dfe->shortest_day_names;
  D.16874 = create_names_array_idx (D.16873, 7);
  mono_gc_wbarrier_set_field (datetime, D.16872, D.16874);
  D.16875 = dfe->first_day_of_week;
  D.16876 = (unsigned int) D.16875;
  datetime->FirstDayOfWeek = D.16876;
  D.16877 = &datetime->LongDatePattern;
  D.16878 = dfe->long_date_pattern;
  D.16879 = (sizetype) D.16878;
  D.16880 = &locale_strings + D.16879;
  D.16881 = mono_string_new (domain, D.16880);
  mono_gc_wbarrier_set_field (datetime, D.16877, D.16881);
  D.16882 = &datetime->LongTimePattern;
  D.16883 = dfe->long_time_pattern;
  D.16884 = (sizetype) D.16883;
  D.16885 = &locale_strings + D.16884;
  D.16886 = mono_string_new (domain, D.16885);
  mono_gc_wbarrier_set_field (datetime, D.16882, D.16886);
  D.16887 = &datetime->MonthDayPattern;
  D.16888 = dfe->month_day_pattern;
  D.16889 = (sizetype) D.16888;
  D.16890 = &locale_strings + D.16889;
  D.16891 = mono_string_new (domain, D.16890);
  mono_gc_wbarrier_set_field (datetime, D.16887, D.16891);
  D.16892 = &datetime->MonthNames;
  D.16893 = &dfe->month_names;
  D.16894 = create_names_array_idx (D.16893, 13);
  mono_gc_wbarrier_set_field (datetime, D.16892, D.16894);
  D.16895 = &datetime->PMDesignator;
  D.16896 = dfe->pm_designator;
  D.16897 = (sizetype) D.16896;
  D.16898 = &locale_strings + D.16897;
  D.16899 = mono_string_new (domain, D.16898);
  mono_gc_wbarrier_set_field (datetime, D.16895, D.16899);
  D.16900 = &datetime->ShortDatePattern;
  D.16901 = dfe->short_date_pattern;
  D.16902 = (sizetype) D.16901;
  D.16903 = &locale_strings + D.16902;
  D.16904 = mono_string_new (domain, D.16903);
  mono_gc_wbarrier_set_field (datetime, D.16900, D.16904);
  D.16905 = &datetime->ShortTimePattern;
  D.16906 = dfe->short_time_pattern;
  D.16907 = (sizetype) D.16906;
  D.16908 = &locale_strings + D.16907;
  D.16909 = mono_string_new (domain, D.16908);
  mono_gc_wbarrier_set_field (datetime, D.16905, D.16909);
  D.16910 = &datetime->TimeSeparator;
  D.16911 = dfe->time_separator;
  D.16912 = (sizetype) D.16911;
  D.16913 = &locale_strings + D.16912;
  D.16914 = mono_string_new (domain, D.16913);
  mono_gc_wbarrier_set_field (datetime, D.16910, D.16914);
  D.16915 = &datetime->YearMonthPattern;
  D.16916 = dfe->year_month_pattern;
  D.16917 = (sizetype) D.16916;
  D.16918 = &locale_strings + D.16917;
  D.16919 = mono_string_new (domain, D.16918);
  mono_gc_wbarrier_set_field (datetime, D.16915, D.16919);
  D.16920 = &datetime->ShortDatePatterns;
  D.16921 = &dfe->short_date_patterns;
  D.16922 = create_names_array_idx_dynamic (D.16921, 14);
  mono_gc_wbarrier_set_field (datetime, D.16920, D.16922);
  D.16923 = &datetime->LongDatePatterns;
  D.16924 = &dfe->long_date_patterns;
  D.16925 = create_names_array_idx_dynamic (D.16924, 8);
  mono_gc_wbarrier_set_field (datetime, D.16923, D.16925);
  D.16926 = &datetime->ShortTimePatterns;
  D.16927 = &dfe->short_time_patterns;
  D.16928 = create_names_array_idx_dynamic (D.16927, 12);
  mono_gc_wbarrier_set_field (datetime, D.16926, D.16928);
  D.16929 = &datetime->LongTimePatterns;
  D.16930 = &dfe->long_time_patterns;
  D.16931 = create_names_array_idx_dynamic (D.16930, 9);
  mono_gc_wbarrier_set_field (datetime, D.16929, D.16931);
  D.16932 = &datetime->GenitiveMonthNames;
  D.16933 = &dfe->month_genitive_names;
  D.16934 = create_names_array_idx (D.16933, 13);
  mono_gc_wbarrier_set_field (datetime, D.16932, D.16934);
  D.16935 = &datetime->GenitiveAbbreviatedMonthNames;
  D.16936 = &dfe->abbreviated_month_genitive_names;
  D.16937 = create_names_array_idx (D.16936, 13);
  mono_gc_wbarrier_set_field (datetime, D.16935, D.16937);
}


create_names_array_idx_dynamic (const guint16 * names, int ml)
{
  struct MonoArray * D.16940;
  long unsigned int D.16941;
  long unsigned int D.16942;
  const guint16 * D.16943;
  short unsigned int D.16944;
  struct MonoDomain * D.16946;
  struct MonoClass * D.16599;
  struct MonoClass * tmp_klass.0;
  struct MonoClass * D.16950;
  struct MonoClass * tmp_klass.1;
  _Bool D.16952;
  long int D.16953;
  long int D.16954;
  struct MonoVTable * D.16957;
  long unsigned int D.16958;
  long unsigned int D.16959;
  sizetype D.16960;
  const char * D.16961;
  struct MonoString * D.16962;
  struct MonoArray * ret;
  struct MonoDomain * domain;
  int i;
  int len;

  len = 0;
  if (names == 0B) goto <D.16938>; else goto <D.16939>;
  <D.16938>:
  D.16940 = 0B;
  return D.16940;
  <D.16939>:
  domain = mono_domain_get ();
  i = 0;
  goto <D.16597>;
  <D.16596>:
  D.16941 = (long unsigned int) i;
  D.16942 = D.16941 * 2;
  D.16943 = names + D.16942;
  D.16944 = *D.16943;
  if (D.16944 == 0) goto <D.16595>; else goto <D.16945>;
  <D.16945>:
  len = len + 1;
  i = i + 1;
  <D.16597>:
  if (i < ml) goto <D.16596>; else goto <D.16595>;
  <D.16595>:
  D.16946 = mono_domain_get ();
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.0 = tmp_klass;
      if (tmp_klass.0 == 0B) goto <D.16948>; else goto <D.16949>;
      <D.16948>:
      D.16950 = mono_get_string_class ();
      tmp_klass.1 = mono_array_class_get (D.16950, 1);
      tmp_klass = tmp_klass.1;
      tmp_klass.0 = tmp_klass;
      D.16952 = tmp_klass.0 == 0B;
      D.16953 = (long int) D.16952;
      D.16954 = __builtin_expect (D.16953, 0);
      if (D.16954 != 0) goto <D.16955>; else goto <D.16956>;
      <D.16955>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "locales.c", 152, "tmp_klass");
      <D.16956>:
      <D.16949>:
    }
    D.16599 = tmp_klass;
  }
  D.16957 = mono_class_vtable (D.16946, D.16599);
  D.16958 = (long unsigned int) len;
  ret = mono_array_new_specific (D.16957, D.16958);
  i = 0;
  goto <D.16602>;
  <D.16601>:
  {
    void * * __p;

    D.16959 = (long unsigned int) i;
    __p = mono_array_addr_with_size (ret, 8, D.16959);
    D.16941 = (long unsigned int) i;
    D.16942 = D.16941 * 2;
    D.16943 = names + D.16942;
    D.16944 = *D.16943;
    D.16960 = (sizetype) D.16944;
    D.16961 = &locale_strings + D.16960;
    D.16962 = mono_string_new (domain, D.16961);
    mono_gc_wbarrier_set_arrayref (ret, __p, D.16962);
  }
  i = i + 1;
  <D.16602>:
  if (i < len) goto <D.16601>; else goto <D.16603>;
  <D.16603>:
  D.16940 = ret;
  return D.16940;
}


create_names_array_idx (const guint16 * names, int ml)
{
  struct MonoArray * D.16966;
  struct MonoDomain * D.16967;
  struct MonoClass * D.16582;
  struct MonoClass * tmp_klass.2;
  struct MonoClass * D.16971;
  struct MonoClass * tmp_klass.3;
  _Bool D.16973;
  long int D.16974;
  long int D.16975;
  struct MonoVTable * D.16978;
  long unsigned int D.16979;
  long unsigned int D.16980;
  long unsigned int D.16981;
  long unsigned int D.16982;
  const guint16 * D.16983;
  short unsigned int D.16984;
  sizetype D.16985;
  const char * D.16986;
  struct MonoString * D.16987;
  struct MonoArray * ret;
  struct MonoDomain * domain;
  int i;

  if (names == 0B) goto <D.16964>; else goto <D.16965>;
  <D.16964>:
  D.16966 = 0B;
  return D.16966;
  <D.16965>:
  domain = mono_domain_get ();
  D.16967 = mono_domain_get ();
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.2 = tmp_klass;
      if (tmp_klass.2 == 0B) goto <D.16969>; else goto <D.16970>;
      <D.16969>:
      D.16971 = mono_get_string_class ();
      tmp_klass.3 = mono_array_class_get (D.16971, 1);
      tmp_klass = tmp_klass.3;
      tmp_klass.2 = tmp_klass;
      D.16973 = tmp_klass.2 == 0B;
      D.16974 = (long int) D.16973;
      D.16975 = __builtin_expect (D.16974, 0);
      if (D.16975 != 0) goto <D.16976>; else goto <D.16977>;
      <D.16976>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "locales.c", 126, "tmp_klass");
      <D.16977>:
      <D.16970>:
    }
    D.16582 = tmp_klass;
  }
  D.16978 = mono_class_vtable (D.16967, D.16582);
  D.16979 = (long unsigned int) ml;
  ret = mono_array_new_specific (D.16978, D.16979);
  i = 0;
  goto <D.16585>;
  <D.16584>:
  {
    void * * __p;

    D.16980 = (long unsigned int) i;
    __p = mono_array_addr_with_size (ret, 8, D.16980);
    D.16981 = (long unsigned int) i;
    D.16982 = D.16981 * 2;
    D.16983 = names + D.16982;
    D.16984 = *D.16983;
    D.16985 = (sizetype) D.16984;
    D.16986 = &locale_strings + D.16985;
    D.16987 = mono_string_new (domain, D.16986);
    mono_gc_wbarrier_set_arrayref (ret, __p, D.16987);
  }
  i = i + 1;
  <D.16585>:
  if (i < ml) goto <D.16584>; else goto <D.16586>;
  <D.16586>:
  D.16966 = ret;
  return D.16966;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Globalization_CultureInfo_construct_number_format (struct MonoCultureInfo * this)
{
  struct MonoNumberFormatInfo * D.16989;
  _Bool D.16990;
  long int D.16991;
  long int D.16992;
  int D.16995;
  unsigned char D.16998;
  signed char D.16999;
  int D.17000;
  struct MonoString * * D.17001;
  short unsigned int D.17002;
  sizetype D.17003;
  const char * D.17004;
  struct MonoString * D.17005;
  struct MonoString * * D.17006;
  short unsigned int D.17007;
  sizetype D.17008;
  const char * D.17009;
  struct MonoString * D.17010;
  struct MonoArray * * D.17011;
  const gint[2] * D.17012;
  struct MonoArray * D.17013;
  signed char D.17014;
  int D.17015;
  signed char D.17016;
  int D.17017;
  struct MonoString * * D.17018;
  short unsigned int D.17019;
  sizetype D.17020;
  const char * D.17021;
  struct MonoString * D.17022;
  struct MonoString * * D.17023;
  short unsigned int D.17024;
  sizetype D.17025;
  const char * D.17026;
  struct MonoString * D.17027;
  struct MonoString * * D.17028;
  short unsigned int D.17029;
  sizetype D.17030;
  const char * D.17031;
  struct MonoString * D.17032;
  struct MonoString * * D.17033;
  short unsigned int D.17034;
  sizetype D.17035;
  const char * D.17036;
  struct MonoString * D.17037;
  signed char D.17038;
  unsigned int D.17039;
  struct MonoString * * D.17040;
  short unsigned int D.17041;
  sizetype D.17042;
  const char * D.17043;
  struct MonoString * D.17044;
  struct MonoString * * D.17045;
  short unsigned int D.17046;
  sizetype D.17047;
  const char * D.17048;
  struct MonoString * D.17049;
  struct MonoArray * * D.17050;
  const gint[2] * D.17051;
  struct MonoArray * D.17052;
  signed char D.17053;
  int D.17054;
  signed char D.17055;
  int D.17056;
  struct MonoString * * D.17057;
  short unsigned int D.17058;
  sizetype D.17059;
  const char * D.17060;
  struct MonoString * D.17061;
  struct MonoString * * D.17062;
  short unsigned int D.17063;
  sizetype D.17064;
  const char * D.17065;
  struct MonoString * D.17066;
  struct MonoArray * * D.17067;
  const gint[2] * D.17068;
  struct MonoArray * D.17069;
  signed char D.17070;
  int D.17071;
  signed char D.17072;
  int D.17073;
  struct MonoString * * D.17074;
  short unsigned int D.17075;
  sizetype D.17076;
  const char * D.17077;
  struct MonoString * D.17078;
  struct MonoString * * 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 MonoDomain * domain;
  struct MonoNumberFormatInfo * number;
  const struct NumberFormatEntry * nfe;

  D.16989 = this->number_format;
  D.16990 = D.16989 == 0B;
  D.16991 = (long int) D.16990;
  D.16992 = __builtin_expect (D.16991, 0);
  if (D.16992 != 0) goto <D.16993>; else goto <D.16994>;
  <D.16993>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "locales.c", 217, "this->number_format != 0");
  <D.16994>:
  D.16995 = this->number_index;
  if (D.16995 < 0) goto <D.16996>; else goto <D.16997>;
  <D.16996>:
  return;
  <D.16997>:
  number = this->number_format;
  D.16995 = this->number_index;
  nfe = &number_format_entries[D.16995];
  domain = mono_domain_get ();
  D.16998 = this->is_read_only;
  number->readOnly = D.16998;
  D.16999 = nfe->currency_decimal_digits;
  D.17000 = (int) D.16999;
  number->currencyDecimalDigits = D.17000;
  D.17001 = &number->currencyDecimalSeparator;
  D.17002 = nfe->currency_decimal_separator;
  D.17003 = (sizetype) D.17002;
  D.17004 = &locale_strings + D.17003;
  D.17005 = mono_string_new (domain, D.17004);
  mono_gc_wbarrier_set_field (number, D.17001, D.17005);
  D.17006 = &number->currencyGroupSeparator;
  D.17007 = nfe->currency_group_separator;
  D.17008 = (sizetype) D.17007;
  D.17009 = &locale_strings + D.17008;
  D.17010 = mono_string_new (domain, D.17009);
  mono_gc_wbarrier_set_field (number, D.17006, D.17010);
  D.17011 = &number->currencyGroupSizes;
  D.17012 = &nfe->currency_group_sizes;
  D.17013 = create_group_sizes_array (D.17012, 2);
  mono_gc_wbarrier_set_field (number, D.17011, D.17013);
  D.17014 = nfe->currency_negative_pattern;
  D.17015 = (int) D.17014;
  number->currencyNegativePattern = D.17015;
  D.17016 = nfe->currency_positive_pattern;
  D.17017 = (int) D.17016;
  number->currencyPositivePattern = D.17017;
  D.17018 = &number->currencySymbol;
  D.17019 = nfe->currency_symbol;
  D.17020 = (sizetype) D.17019;
  D.17021 = &locale_strings + D.17020;
  D.17022 = mono_string_new (domain, D.17021);
  mono_gc_wbarrier_set_field (number, D.17018, D.17022);
  D.17023 = &number->naNSymbol;
  D.17024 = nfe->nan_symbol;
  D.17025 = (sizetype) D.17024;
  D.17026 = &locale_strings + D.17025;
  D.17027 = mono_string_new (domain, D.17026);
  mono_gc_wbarrier_set_field (number, D.17023, D.17027);
  D.17028 = &number->negativeInfinitySymbol;
  D.17029 = nfe->negative_infinity_symbol;
  D.17030 = (sizetype) D.17029;
  D.17031 = &locale_strings + D.17030;
  D.17032 = mono_string_new (domain, D.17031);
  mono_gc_wbarrier_set_field (number, D.17028, D.17032);
  D.17033 = &number->negativeSign;
  D.17034 = nfe->negative_sign;
  D.17035 = (sizetype) D.17034;
  D.17036 = &locale_strings + D.17035;
  D.17037 = mono_string_new (domain, D.17036);
  mono_gc_wbarrier_set_field (number, D.17033, D.17037);
  D.17038 = nfe->number_decimal_digits;
  D.17039 = (unsigned int) D.17038;
  number->numberDecimalDigits = D.17039;
  D.17040 = &number->numberDecimalSeparator;
  D.17041 = nfe->number_decimal_separator;
  D.17042 = (sizetype) D.17041;
  D.17043 = &locale_strings + D.17042;
  D.17044 = mono_string_new (domain, D.17043);
  mono_gc_wbarrier_set_field (number, D.17040, D.17044);
  D.17045 = &number->numberGroupSeparator;
  D.17046 = nfe->number_group_separator;
  D.17047 = (sizetype) D.17046;
  D.17048 = &locale_strings + D.17047;
  D.17049 = mono_string_new (domain, D.17048);
  mono_gc_wbarrier_set_field (number, D.17045, D.17049);
  D.17050 = &number->numberGroupSizes;
  D.17051 = &nfe->number_group_sizes;
  D.17052 = create_group_sizes_array (D.17051, 2);
  mono_gc_wbarrier_set_field (number, D.17050, D.17052);
  D.17053 = nfe->number_negative_pattern;
  D.17054 = (int) D.17053;
  number->numberNegativePattern = D.17054;
  D.17055 = nfe->percent_decimal_digits;
  D.17056 = (int) D.17055;
  number->percentDecimalDigits = D.17056;
  D.17057 = &number->percentDecimalSeparator;
  D.17058 = nfe->percent_decimal_separator;
  D.17059 = (sizetype) D.17058;
  D.17060 = &locale_strings + D.17059;
  D.17061 = mono_string_new (domain, D.17060);
  mono_gc_wbarrier_set_field (number, D.17057, D.17061);
  D.17062 = &number->percentGroupSeparator;
  D.17063 = nfe->percent_group_separator;
  D.17064 = (sizetype) D.17063;
  D.17065 = &locale_strings + D.17064;
  D.17066 = mono_string_new (domain, D.17065);
  mono_gc_wbarrier_set_field (number, D.17062, D.17066);
  D.17067 = &number->percentGroupSizes;
  D.17068 = &nfe->percent_group_sizes;
  D.17069 = create_group_sizes_array (D.17068, 2);
  mono_gc_wbarrier_set_field (number, D.17067, D.17069);
  D.17070 = nfe->percent_negative_pattern;
  D.17071 = (int) D.17070;
  number->percentNegativePattern = D.17071;
  D.17072 = nfe->percent_positive_pattern;
  D.17073 = (int) D.17072;
  number->percentPositivePattern = D.17073;
  D.17074 = &number->percentSymbol;
  D.17075 = nfe->percent_symbol;
  D.17076 = (sizetype) D.17075;
  D.17077 = &locale_strings + D.17076;
  D.17078 = mono_string_new (domain, D.17077);
  mono_gc_wbarrier_set_field (number, D.17074, D.17078);
  D.17079 = &number->perMilleSymbol;
  D.17080 = nfe->per_mille_symbol;
  D.17081 = (sizetype) D.17080;
  D.17082 = &locale_strings + D.17081;
  D.17083 = mono_string_new (domain, D.17082);
  mono_gc_wbarrier_set_field (number, D.17079, D.17083);
  D.17084 = &number->positiveInfinitySymbol;
  D.17085 = nfe->positive_infinity_symbol;
  D.17086 = (sizetype) D.17085;
  D.17087 = &locale_strings + D.17086;
  D.17088 = mono_string_new (domain, D.17087);
  mono_gc_wbarrier_set_field (number, D.17084, D.17088);
  D.17089 = &number->positiveSign;
  D.17090 = nfe->positive_sign;
  D.17091 = (sizetype) D.17090;
  D.17092 = &locale_strings + D.17091;
  D.17093 = mono_string_new (domain, D.17092);
  mono_gc_wbarrier_set_field (number, D.17089, D.17093);
}


create_group_sizes_array (const gint * gs, gint ml)
{
  long unsigned int D.17095;
  long unsigned int D.17096;
  const gint * D.17097;
  int D.17098;
  struct MonoDomain * D.17100;
  struct MonoClass * D.16569;
  struct MonoClass * tmp_klass.4;
  struct MonoClass * D.17104;
  struct MonoClass * tmp_klass.5;
  _Bool D.17106;
  long int D.17107;
  long int D.17108;
  struct MonoVTable * D.17111;
  long unsigned int D.17112;
  long unsigned int D.17113;
  struct MonoArray * D.17114;
  struct MonoArray * ret;
  int i;
  int len;

  len = 0;
  i = 0;
  goto <D.16567>;
  <D.16566>:
  D.17095 = (long unsigned int) i;
  D.17096 = D.17095 * 4;
  D.17097 = gs + D.17096;
  D.17098 = *D.17097;
  if (D.17098 == -1) goto <D.16565>; else goto <D.17099>;
  <D.17099>:
  len = len + 1;
  i = i + 1;
  <D.16567>:
  if (i < ml) goto <D.16566>; else goto <D.16565>;
  <D.16565>:
  D.17100 = mono_domain_get ();
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.4 = tmp_klass;
      if (tmp_klass.4 == 0B) goto <D.17102>; else goto <D.17103>;
      <D.17102>:
      D.17104 = mono_get_int32_class ();
      tmp_klass.5 = mono_array_class_get (D.17104, 1);
      tmp_klass = tmp_klass.5;
      tmp_klass.4 = tmp_klass;
      D.17106 = tmp_klass.4 == 0B;
      D.17107 = (long int) D.17106;
      D.17108 = __builtin_expect (D.17107, 0);
      if (D.17108 != 0) goto <D.17109>; else goto <D.17110>;
      <D.17109>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "locales.c", 106, "tmp_klass");
      <D.17110>:
      <D.17103>:
    }
    D.16569 = tmp_klass;
  }
  D.17111 = mono_class_vtable (D.17100, D.16569);
  D.17112 = (long unsigned int) len;
  ret = mono_array_new_specific (D.17111, D.17112);
  i = 0;
  goto <D.16572>;
  <D.16571>:
  {
    gint32 * __p;

    D.17113 = (long unsigned int) i;
    __p = mono_array_addr_with_size (ret, 4, D.17113);
    D.17095 = (long unsigned int) i;
    D.17096 = D.17095 * 4;
    D.17097 = gs + D.17096;
    D.17098 = *D.17097;
    *__p = D.17098;
  }
  i = i + 1;
  <D.16572>:
  if (i < len) goto <D.16571>; else goto <D.16573>;
  <D.16573>:
  D.17114 = ret;
  return D.17114;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Globalization_CultureInfo_get_current_locale_name ()
{
  struct MonoString * D.17118;
  gchar * locale;
  struct MonoString * ret;
  struct MonoDomain * domain;

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


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

  locale = get_posix_locale ();
  if (locale == 0B) goto <D.17120>; else goto <D.17121>;
  <D.17120>:
  D.17122 = 0B;
  return D.17122;
  <D.17121>:
  p = __builtin_strchr (locale, 46);
  if (p != 0B) goto <D.17123>; else goto <D.17124>;
  <D.17123>:
  *p = 0;
  <D.17124>:
  p = __builtin_strchr (locale, 64);
  if (p != 0B) goto <D.17125>; else goto <D.17126>;
  <D.17125>:
  *p = 0;
  <D.17126>:
  p = __builtin_strchr (locale, 95);
  if (p != 0B) goto <D.17127>; else goto <D.17128>;
  <D.17127>:
  *p = 45;
  <D.17128>:
  ret = monoeg_g_ascii_strdown (locale, -1);
  monoeg_g_free (locale);
  D.17122 = ret;
  return D.17122;
}


get_posix_locale ()
{
  char * D.17136;
  int D.17137;
  const char * locale;

  locale = monoeg_g_getenv ("LC_ALL");
  if (locale == 0B) goto <D.17130>; else goto <D.17131>;
  <D.17130>:
  locale = monoeg_g_getenv ("LANG");
  if (locale == 0B) goto <D.17132>; else goto <D.17133>;
  <D.17132>:
  locale = setlocale (6, 0B);
  <D.17133>:
  <D.17131>:
  if (locale == 0B) goto <D.17134>; else goto <D.17135>;
  <D.17134>:
  D.17136 = 0B;
  return D.17136;
  <D.17135>:
  D.17137 = strcmp (locale, "C");
  if (D.17137 == 0) goto <D.17138>; else goto <D.17139>;
  <D.17138>:
  D.17136 = 0B;
  return D.17136;
  <D.17139>:
  D.17136 = monoeg_strdup (locale);
  return D.17136;
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.6;
  int iftmp.7;
  int D.17149;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.17142>; else goto <D.17143>;
  <D.17142>:
  if (__ret == 1) goto <D.17145>; else goto <D.17146>;
  <D.17145>:
  iftmp.7 = -1;
  goto <D.17147>;
  <D.17146>:
  iftmp.7 = 1;
  <D.17147>:
  iftmp.6 = iftmp.7;
  goto <D.17148>;
  <D.17143>:
  iftmp.6 = 0;
  <D.17148>:
  __ret = iftmp.6;
  D.17149 = __ret;
  return D.17149;
}


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

  if (str != 0B) goto <D.17151>; else goto <D.17152>;
  <D.17151>:
  D.17153 = __strdup (str);
  return D.17153;
  <D.17152>:
  D.17153 = 0B;
  return D.17153;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Globalization_CultureInfo_construct_internal_locale_from_lcid (struct MonoCultureInfo * this, gint lcid)
{
  MonoBoolean D.17157;
  const struct CultureInfoEntry * ci;

  ci = culture_info_entry_from_lcid (lcid);
  if (ci == 0B) goto <D.17155>; else goto <D.17156>;
  <D.17155>:
  D.17157 = 0;
  return D.17157;
  <D.17156>:
  D.17157 = construct_culture (this, ci);
  return D.17157;
}


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

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


culture_lcid_locator (const void * a, const void * b)
{
  int D.17161;
  int D.17162;
  short int D.17163;
  int D.17164;
  const int * lcid;
  const struct CultureInfoEntry * bb;

  lcid = a;
  bb = b;
  D.17162 = *lcid;
  D.17163 = bb->lcid;
  D.17164 = (int) D.17163;
  D.17161 = D.17162 - D.17164;
  return D.17161;
}


construct_culture (struct MonoCultureInfo * this, const struct CultureInfoEntry * ci)
{
  short int D.17166;
  int D.17167;
  struct MonoString * * D.17168;
  short unsigned int D.17169;
  sizetype D.17170;
  const char * D.17171;
  struct MonoString * D.17172;
  struct MonoString * * D.17173;
  short unsigned int D.17174;
  sizetype D.17175;
  const char * D.17176;
  struct MonoString * D.17177;
  struct MonoString * * D.17178;
  short unsigned int D.17179;
  sizetype D.17180;
  const char * D.17181;
  struct MonoString * D.17182;
  struct MonoString * * D.17183;
  short unsigned int D.17184;
  sizetype D.17185;
  const char * D.17186;
  struct MonoString * D.17187;
  struct MonoString * * D.17188;
  short unsigned int D.17189;
  sizetype D.17190;
  const char * D.17191;
  struct MonoString * D.17192;
  struct MonoString * * D.17193;
  short unsigned int D.17194;
  sizetype D.17195;
  const char * D.17196;
  struct MonoString * D.17197;
  short unsigned int D.17198;
  struct MonoString * * D.17201;
  sizetype D.17202;
  const char * D.17203;
  struct MonoString * D.17204;
  struct MonoArray * * D.17205;
  const stridx_t[4] * D.17206;
  struct MonoArray * D.17207;
  short int D.17208;
  int D.17209;
  short int D.17210;
  int D.17211;
  short int D.17212;
  int D.17213;
  short int D.17214;
  int D.17215;
  const struct TextInfoEntry * D.17216;
  MonoBoolean D.17217;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.17166 = ci->lcid;
  D.17167 = (int) D.17166;
  this->lcid = D.17167;
  D.17168 = &this->name;
  D.17169 = ci->name;
  D.17170 = (sizetype) D.17169;
  D.17171 = &locale_strings + D.17170;
  D.17172 = mono_string_new (domain, D.17171);
  mono_gc_wbarrier_set_field (this, D.17168, D.17172);
  D.17173 = &this->englishname;
  D.17174 = ci->englishname;
  D.17175 = (sizetype) D.17174;
  D.17176 = &locale_strings + D.17175;
  D.17177 = mono_string_new (domain, D.17176);
  mono_gc_wbarrier_set_field (this, D.17173, D.17177);
  D.17178 = &this->nativename;
  D.17179 = ci->nativename;
  D.17180 = (sizetype) D.17179;
  D.17181 = &locale_strings + D.17180;
  D.17182 = mono_string_new (domain, D.17181);
  mono_gc_wbarrier_set_field (this, D.17178, D.17182);
  D.17183 = &this->win3lang;
  D.17184 = ci->win3lang;
  D.17185 = (sizetype) D.17184;
  D.17186 = &locale_strings + D.17185;
  D.17187 = mono_string_new (domain, D.17186);
  mono_gc_wbarrier_set_field (this, D.17183, D.17187);
  D.17188 = &this->iso3lang;
  D.17189 = ci->iso3lang;
  D.17190 = (sizetype) D.17189;
  D.17191 = &locale_strings + D.17190;
  D.17192 = mono_string_new (domain, D.17191);
  mono_gc_wbarrier_set_field (this, D.17188, D.17192);
  D.17193 = &this->iso2lang;
  D.17194 = ci->iso2lang;
  D.17195 = (sizetype) D.17194;
  D.17196 = &locale_strings + D.17195;
  D.17197 = mono_string_new (domain, D.17196);
  mono_gc_wbarrier_set_field (this, D.17193, D.17197);
  D.17198 = ci->territory;
  if (D.17198 != 0) goto <D.17199>; else goto <D.17200>;
  <D.17199>:
  D.17201 = &this->territory;
  D.17198 = ci->territory;
  D.17202 = (sizetype) D.17198;
  D.17203 = &locale_strings + D.17202;
  D.17204 = mono_string_new (domain, D.17203);
  mono_gc_wbarrier_set_field (this, D.17201, D.17204);
  <D.17200>:
  D.17205 = &this->native_calendar_names;
  D.17206 = &ci->native_calendar_names;
  D.17207 = create_names_array_idx (D.17206, 4);
  mono_gc_wbarrier_set_field (this, D.17205, D.17207);
  D.17208 = ci->parent_lcid;
  D.17209 = (int) D.17208;
  this->parent_lcid = D.17209;
  D.17210 = ci->datetime_format_index;
  D.17211 = (int) D.17210;
  this->datetime_index = D.17211;
  D.17212 = ci->number_format_index;
  D.17213 = (int) D.17212;
  this->number_index = D.17213;
  D.17214 = ci->calendar_type;
  D.17215 = (int) D.17214;
  this->calendar_type = D.17215;
  D.17216 = &ci->text_info;
  this->text_info_data = D.17216;
  D.17217 = 1;
  return D.17217;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Globalization_CultureInfo_construct_internal_locale_from_name (struct MonoCultureInfo * this, struct MonoString * name)
{
  MonoBoolean D.17221;
  short int D.17222;
  int D.17223;
  const struct CultureInfoEntry * D.17224;
  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.17219>; else goto <D.17220>;
  <D.17219>:
  monoeg_g_free (n);
  D.17221 = 0;
  return D.17221;
  <D.17220>:
  monoeg_g_free (n);
  D.17222 = ne->culture_entry_index;
  D.17223 = (int) D.17222;
  D.17224 = &culture_entries[D.17223];
  D.17221 = construct_culture (this, D.17224);
  return D.17221;
}


culture_name_locator (const void * a, const void * b)
{
  short unsigned int D.17226;
  sizetype D.17227;
  const char * D.17228;
  int D.17229;
  const char * aa;
  const struct CultureInfoNameEntry * bb;
  int ret;

  aa = a;
  bb = b;
  D.17226 = bb->name;
  D.17227 = (sizetype) D.17226;
  D.17228 = &locale_strings + D.17227;
  ret = strcmp (aa, D.17228);
  D.17229 = ret;
  return D.17229;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Globalization_RegionInfo_construct_internal_region_from_lcid (struct MonoRegionInfo * this, gint lcid)
{
  MonoBoolean D.17233;
  const struct RegionInfoEntry * ri;

  ri = region_info_entry_from_lcid (lcid);
  if (ri == 0B) goto <D.17231>; else goto <D.17232>;
  <D.17231>:
  D.17233 = 0;
  return D.17233;
  <D.17232>:
  D.17233 = construct_region (this, ri);
  return D.17233;
}


region_info_entry_from_lcid (int lcid)
{
  const struct RegionInfoEntry * D.17237;
  short int D.17238;
  int D.17239;
  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.17235>; else goto <D.17236>;
  <D.17235>:
  D.17237 = 0B;
  return D.17237;
  <D.17236>:
  D.17238 = ne->region_entry_index;
  D.17239 = (int) D.17238;
  entry = &region_entries[D.17239];
  D.17237 = entry;
  return D.17237;
}


construct_region (struct MonoRegionInfo * this, const struct RegionInfoEntry * ri)
{
  short int D.17241;
  int D.17242;
  struct MonoString * * D.17243;
  short unsigned int D.17244;
  sizetype D.17245;
  const char * D.17246;
  struct MonoString * D.17247;
  struct MonoString * * D.17248;
  short unsigned int D.17249;
  sizetype D.17250;
  const char * D.17251;
  struct MonoString * D.17252;
  struct MonoString * * D.17253;
  short unsigned int D.17254;
  sizetype D.17255;
  const char * D.17256;
  struct MonoString * D.17257;
  struct MonoString * * D.17258;
  short unsigned int D.17259;
  sizetype D.17260;
  const char * D.17261;
  struct MonoString * D.17262;
  struct MonoString * * D.17263;
  short unsigned int D.17264;
  sizetype D.17265;
  const char * D.17266;
  struct MonoString * D.17267;
  struct MonoString * * D.17268;
  short unsigned int D.17269;
  sizetype D.17270;
  const char * D.17271;
  struct MonoString * D.17272;
  struct MonoString * * D.17273;
  short unsigned int D.17274;
  sizetype D.17275;
  const char * D.17276;
  struct MonoString * D.17277;
  struct MonoString * * D.17278;
  short unsigned int D.17279;
  sizetype D.17280;
  const char * D.17281;
  struct MonoString * D.17282;
  struct MonoString * * D.17283;
  short unsigned int D.17284;
  sizetype D.17285;
  const char * D.17286;
  struct MonoString * D.17287;
  MonoBoolean D.17288;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.17241 = ri->geo_id;
  D.17242 = (int) D.17241;
  this->geo_id = D.17242;
  D.17243 = &this->iso2name;
  D.17244 = ri->iso2name;
  D.17245 = (sizetype) D.17244;
  D.17246 = &locale_strings + D.17245;
  D.17247 = mono_string_new (domain, D.17246);
  mono_gc_wbarrier_set_field (this, D.17243, D.17247);
  D.17248 = &this->iso3name;
  D.17249 = ri->iso3name;
  D.17250 = (sizetype) D.17249;
  D.17251 = &locale_strings + D.17250;
  D.17252 = mono_string_new (domain, D.17251);
  mono_gc_wbarrier_set_field (this, D.17248, D.17252);
  D.17253 = &this->win3name;
  D.17254 = ri->win3name;
  D.17255 = (sizetype) D.17254;
  D.17256 = &locale_strings + D.17255;
  D.17257 = mono_string_new (domain, D.17256);
  mono_gc_wbarrier_set_field (this, D.17253, D.17257);
  D.17258 = &this->english_name;
  D.17259 = ri->english_name;
  D.17260 = (sizetype) D.17259;
  D.17261 = &locale_strings + D.17260;
  D.17262 = mono_string_new (domain, D.17261);
  mono_gc_wbarrier_set_field (this, D.17258, D.17262);
  D.17263 = &this->native_name;
  D.17264 = ri->native_name;
  D.17265 = (sizetype) D.17264;
  D.17266 = &locale_strings + D.17265;
  D.17267 = mono_string_new (domain, D.17266);
  mono_gc_wbarrier_set_field (this, D.17263, D.17267);
  D.17268 = &this->currency_symbol;
  D.17269 = ri->currency_symbol;
  D.17270 = (sizetype) D.17269;
  D.17271 = &locale_strings + D.17270;
  D.17272 = mono_string_new (domain, D.17271);
  mono_gc_wbarrier_set_field (this, D.17268, D.17272);
  D.17273 = &this->iso_currency_symbol;
  D.17274 = ri->iso_currency_symbol;
  D.17275 = (sizetype) D.17274;
  D.17276 = &locale_strings + D.17275;
  D.17277 = mono_string_new (domain, D.17276);
  mono_gc_wbarrier_set_field (this, D.17273, D.17277);
  D.17278 = &this->currency_english_name;
  D.17279 = ri->currency_english_name;
  D.17280 = (sizetype) D.17279;
  D.17281 = &locale_strings + D.17280;
  D.17282 = mono_string_new (domain, D.17281);
  mono_gc_wbarrier_set_field (this, D.17278, D.17282);
  D.17283 = &this->currency_native_name;
  D.17284 = ri->currency_native_name;
  D.17285 = (sizetype) D.17284;
  D.17286 = &locale_strings + D.17285;
  D.17287 = mono_string_new (domain, D.17286);
  mono_gc_wbarrier_set_field (this, D.17283, D.17287);
  D.17288 = 1;
  return D.17288;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Globalization_RegionInfo_construct_internal_region_from_name (struct MonoRegionInfo * this, struct MonoString * name)
{
  MonoBoolean D.17292;
  short int D.17293;
  int D.17294;
  const struct RegionInfoEntry * D.17295;
  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.17290>; else goto <D.17291>;
  <D.17290>:
  monoeg_g_free (n);
  D.17292 = 0;
  return D.17292;
  <D.17291>:
  monoeg_g_free (n);
  D.17293 = ne->region_entry_index;
  D.17294 = (int) D.17293;
  D.17295 = &region_entries[D.17294];
  D.17292 = construct_region (this, D.17295);
  return D.17292;
}


region_name_locator (const void * a, const void * b)
{
  short unsigned int D.17297;
  sizetype D.17298;
  const char * D.17299;
  int D.17300;
  const char * aa;
  const struct RegionInfoNameEntry * bb;
  int ret;

  aa = a;
  bb = b;
  D.17297 = bb->name;
  D.17298 = (sizetype) D.17297;
  D.17299 = &locale_strings + D.17298;
  ret = strcmp (aa, D.17299);
  D.17300 = ret;
  return D.17300;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Globalization_CultureInfo_internal_get_cultures (MonoBoolean neutral, MonoBoolean specific, MonoBoolean installed)
{
  short unsigned int D.17302;
  _Bool D.17303;
  struct MonoImage * D.17309;
  long unsigned int D.17312;
  struct MonoArray * D.17315;
  int len.8;
  long unsigned int D.17319;
  int len.9;
  long unsigned int D.17326;
  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.16687>;
  <D.16686>:
  ci = &culture_entries[i];
  D.17302 = ci->territory;
  D.17303 = D.17302 == 0;
  is_neutral = (gboolean) D.17303;
  if (neutral != 0) goto <D.17307>; else goto <D.17304>;
  <D.17307>:
  if (is_neutral != 0) goto <D.17305>; else goto <D.17304>;
  <D.17304>:
  if (specific != 0) goto <D.17308>; else goto <D.17306>;
  <D.17308>:
  if (is_neutral == 0) goto <D.17305>; else goto <D.17306>;
  <D.17305>:
  len = len + 1;
  <D.17306>:
  i = i + 1;
  <D.16687>:
  if (i <= 282) goto <D.16686>; else goto <D.16688>;
  <D.16688>:
  D.17309 = mono_get_corlib ();
  class = mono_class_from_name (D.17309, "System.Globalization", "CultureInfo");
  if (neutral != 0) goto <D.17310>; else goto <D.17311>;
  <D.17310>:
  len = len + 1;
  <D.17311>:
  D.17312 = (long unsigned int) len;
  ret = mono_array_new (domain, class, D.17312);
  if (len == 0) goto <D.17313>; else goto <D.17314>;
  <D.17313>:
  D.17315 = ret;
  return D.17315;
  <D.17314>:
  len = 0;
  if (neutral != 0) goto <D.17316>; else goto <D.17317>;
  <D.17316>:
  {
    void * * __p;

    len.8 = len;
    len = len.8 + 1;
    D.17319 = (long unsigned int) len.8;
    __p = mono_array_addr_with_size (ret, 8, D.17319);
    mono_gc_wbarrier_set_arrayref (ret, __p, 0B);
  }
  <D.17317>:
  i = 0;
  goto <D.16692>;
  <D.16691>:
  ci = &culture_entries[i];
  D.17302 = ci->territory;
  D.17303 = D.17302 == 0;
  is_neutral = (gboolean) D.17303;
  if (neutral != 0) goto <D.17323>; else goto <D.17320>;
  <D.17323>:
  if (is_neutral != 0) goto <D.17321>; else goto <D.17320>;
  <D.17320>:
  if (specific != 0) goto <D.17324>; else goto <D.17322>;
  <D.17324>:
  if (is_neutral == 0) goto <D.17321>; else goto <D.17322>;
  <D.17321>:
  culture = mono_object_new (domain, class);
  mono_runtime_object_init (culture);
  construct_culture (culture, ci);
  culture->use_user_override = 1;
  {
    void * * __p;

    len.9 = len;
    len = len.9 + 1;
    D.17326 = (long unsigned int) len.9;
    __p = mono_array_addr_with_size (ret, 8, D.17326);
    mono_gc_wbarrier_set_arrayref (ret, __p, culture);
  }
  <D.17322>:
  i = i + 1;
  <D.16692>:
  if (i <= 282) goto <D.16691>; else goto <D.16693>;
  <D.16693>:
  D.17315 = ret;
  return D.17315;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Globalization_CompareInfo_construct_compareinfo (struct MonoCompareInfo * comp, struct MonoString * locale)
{

}


__attribute__((visibility ("hidden")))
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.17328;

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


string_invariant_compare (struct MonoString * str1, gint32 off1, gint32 len1, struct MonoString * str2, gint32 off2, gint32 len2, gint32 options)
{
  mono_unichar2 * D.17333;
  long unsigned int D.17334;
  long unsigned int D.17335;
  mono_unichar2 * D.17336;
  long unsigned int D.17337;
  long unsigned int D.17338;
  long unsigned int D.17341;
  long unsigned int D.17342;
  gunichar2 * D.17343;
  short unsigned int D.17344;
  gunichar2 * D.17345;
  short unsigned int D.17346;
  gint32 D.17349;
  sizetype D.17352;
  gunichar2 * D.17353;
  short unsigned int D.17354;
  gunichar2 * D.17355;
  short unsigned int D.17356;
  gint32 length;
  gint32 charcmp;
  gunichar2 * ustr1;
  gunichar2 * ustr2;
  gint32 pos;

  if (len1 >= len2) goto <D.17330>; else goto <D.17331>;
  <D.17330>:
  length = len1;
  goto <D.17332>;
  <D.17331>:
  length = len2;
  <D.17332>:
  D.17333 = mono_string_chars (str1);
  D.17334 = (long unsigned int) off1;
  D.17335 = D.17334 * 2;
  ustr1 = D.17333 + D.17335;
  D.17336 = mono_string_chars (str2);
  D.17337 = (long unsigned int) off2;
  D.17338 = D.17337 * 2;
  ustr2 = D.17336 + D.17338;
  pos = 0;
  pos = 0;
  goto <D.16775>;
  <D.16774>:
  if (pos >= len1) goto <D.16773>; else goto <D.17339>;
  <D.17339>:
  if (pos >= len2) goto <D.16773>; else goto <D.17340>;
  <D.17340>:
  D.17341 = (long unsigned int) pos;
  D.17342 = D.17341 * 2;
  D.17343 = ustr1 + D.17342;
  D.17344 = *D.17343;
  D.17341 = (long unsigned int) pos;
  D.17342 = D.17341 * 2;
  D.17345 = ustr2 + D.17342;
  D.17346 = *D.17345;
  charcmp = string_invariant_compare_char (D.17344, D.17346, options);
  if (charcmp != 0) goto <D.17347>; else goto <D.17348>;
  <D.17347>:
  D.17349 = charcmp;
  return D.17349;
  <D.17348>:
  pos = pos + 1;
  <D.16775>:
  if (pos != length) goto <D.16774>; else goto <D.16773>;
  <D.16773>:
  if (pos == length) goto <D.17350>; else goto <D.17351>;
  <D.17350>:
  D.17341 = (long unsigned int) pos;
  D.17342 = D.17341 * 2;
  D.17352 = D.17342 + 18446744073709551614;
  D.17353 = ustr1 + D.17352;
  D.17354 = *D.17353;
  D.17341 = (long unsigned int) pos;
  D.17342 = D.17341 * 2;
  D.17352 = D.17342 + 18446744073709551614;
  D.17355 = ustr2 + D.17352;
  D.17356 = *D.17355;
  D.17349 = string_invariant_compare_char (D.17354, D.17356, options);
  return D.17349;
  <D.17351>:
  if (pos >= len1) goto <D.17357>; else goto <D.17358>;
  <D.17357>:
  if (pos >= len2) goto <D.17359>; else goto <D.17360>;
  <D.17359>:
  D.17349 = 0;
  return D.17349;
  <D.17360>:
  D.17349 = -1;
  return D.17349;
  <D.17358>:
  if (pos >= len2) goto <D.17361>; else goto <D.17362>;
  <D.17361>:
  D.17349 = 1;
  return D.17349;
  <D.17362>:
  D.17341 = (long unsigned int) pos;
  D.17342 = D.17341 * 2;
  D.17343 = ustr1 + D.17342;
  D.17344 = *D.17343;
  D.17341 = (long unsigned int) pos;
  D.17342 = D.17341 * 2;
  D.17345 = ustr2 + D.17342;
  D.17346 = *D.17345;
  D.17349 = string_invariant_compare_char (D.17344, D.17346, options);
  return D.17349;
}


string_invariant_compare_char (gunichar2 c1, gunichar2 c2, gint32 options)
{
  int D.17364;
  gint32 D.17367;
  int D.17368;
  int D.17369;
  int D.17370;
  unsigned int D.17373;
  unsigned int D.17374;
  gunichar iftmp.10;
  gunichar iftmp.11;
  unsigned int D.17383;
  gint32 iftmp.12;
  _Bool D.17388;
  gint32 result;

  D.17364 = options & 1073741824;
  if (D.17364 != 0) goto <D.17365>; else goto <D.17366>;
  <D.17365>:
  D.17368 = (int) c1;
  D.17369 = (int) c2;
  D.17367 = D.17368 - D.17369;
  return D.17367;
  <D.17366>:
  D.17370 = options & 1;
  if (D.17370 != 0) goto <D.17371>; else goto <D.17372>;
  <D.17371>:
  {
    GUnicodeType c1type;
    GUnicodeType c2type;

    D.17373 = (unsigned int) c1;
    c1type = monoeg_g_unichar_type (D.17373);
    D.17374 = (unsigned int) c2;
    c2type = monoeg_g_unichar_type (D.17374);
    if (c1type != 5) goto <D.17376>; else goto <D.17377>;
    <D.17376>:
    D.17373 = (unsigned int) c1;
    iftmp.10 = monoeg_g_unichar_tolower (D.17373);
    goto <D.17378>;
    <D.17377>:
    iftmp.10 = (gunichar) c1;
    <D.17378>:
    if (c2type != 5) goto <D.17380>; else goto <D.17381>;
    <D.17380>:
    D.17374 = (unsigned int) c2;
    iftmp.11 = monoeg_g_unichar_tolower (D.17374);
    goto <D.17382>;
    <D.17381>:
    iftmp.11 = (gunichar) c2;
    <D.17382>:
    D.17383 = iftmp.10 - iftmp.11;
    result = (gint32) D.17383;
  }
  goto <D.17384>;
  <D.17372>:
  D.17368 = (int) c1;
  D.17369 = (int) c2;
  result = D.17368 - D.17369;
  <D.17384>:
  if (result >= 0) goto <D.17386>; else goto <D.17387>;
  <D.17386>:
  D.17388 = result > 0;
  iftmp.12 = (gint32) D.17388;
  goto <D.17389>;
  <D.17387>:
  iftmp.12 = -1;
  <D.17389>:
  D.17367 = iftmp.12;
  return D.17367;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Globalization_CompareInfo_free_internal_collator (struct MonoCompareInfo * this)
{

}


__attribute__((visibility ("hidden")))
ves_icall_System_Globalization_CompareInfo_assign_sortkey (struct MonoCompareInfo * this, struct MonoSortKey * key, struct MonoString * source, gint32 options)
{
  struct MonoDomain * D.17391;
  struct MonoClass * D.17392;
  long unsigned int D.17393;
  long unsigned int D.17394;
  mono_unichar2 * D.17395;
  long unsigned int D.17396;
  long unsigned int D.17397;
  mono_unichar2 * D.17398;
  short unsigned int D.17399;
  unsigned char D.17400;
  struct MonoArray * * D.17401;
  struct MonoArray * arr;
  gint32 keylen;
  gint32 i;

  keylen = mono_string_length (source);
  D.17391 = mono_domain_get ();
  D.17392 = mono_get_byte_class ();
  D.17393 = (long unsigned int) keylen;
  arr = mono_array_new (D.17391, D.17392, D.17393);
  i = 0;
  goto <D.16722>;
  <D.16721>:
  {
    guint8 * __p;

    D.17394 = (long unsigned int) i;
    __p = mono_array_addr_with_size (arr, 1, D.17394);
    D.17395 = mono_string_chars (source);
    D.17396 = (long unsigned int) i;
    D.17397 = D.17396 * 2;
    D.17398 = D.17395 + D.17397;
    D.17399 = *D.17398;
    D.17400 = (unsigned char) D.17399;
    *__p = D.17400;
  }
  i = i + 1;
  <D.16722>:
  if (i < keylen) goto <D.16721>; else goto <D.16723>;
  <D.16723>:
  D.17401 = &key->key;
  mono_gc_wbarrier_set_field (key, D.17401, arr);
}


__attribute__((visibility ("hidden")))
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.17402;

  D.17402 = string_invariant_indexof (source, sindex, count, value, first);
  return D.17402;
}


string_invariant_indexof (struct MonoString * source, gint32 sindex, gint32 count, struct MonoString * value, MonoBoolean first)
{
  gint32 D.17408;
  int D.17409;
  long unsigned int D.17410;
  long unsigned int D.17411;
  gunichar2 * D.17412;
  short unsigned int D.17413;
  long unsigned int D.17414;
  long unsigned int D.17415;
  gunichar2 * D.17416;
  short unsigned int D.17417;
  int D.17418;
  int D.17419;
  long unsigned int D.17420;
  long unsigned int D.17421;
  gunichar2 * D.17422;
  long unsigned int D.17423;
  long unsigned int D.17424;
  int D.17425;
  int D.17428;
  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.17404>; else goto <D.17405>;
  <D.17404>:
  count = count - lencmpstr;
  pos = sindex;
  goto <D.16815>;
  <D.16814>:
  i = 0;
  goto <D.16812>;
  <D.16811>:
  i = i + 1;
  if (i == lencmpstr) goto <D.17406>; else goto <D.17407>;
  <D.17406>:
  D.17408 = pos;
  return D.17408;
  <D.17407>:
  <D.16812>:
  D.17409 = pos + i;
  D.17410 = (long unsigned int) D.17409;
  D.17411 = D.17410 * 2;
  D.17412 = src + D.17411;
  D.17413 = *D.17412;
  D.17414 = (long unsigned int) i;
  D.17415 = D.17414 * 2;
  D.17416 = cmpstr + D.17415;
  D.17417 = *D.17416;
  if (D.17413 == D.17417) goto <D.16811>; else goto <D.16813>;
  <D.16813>:
  pos = pos + 1;
  <D.16815>:
  D.17418 = sindex + count;
  if (D.17418 >= pos) goto <D.16814>; else goto <D.16816>;
  <D.16816>:
  D.17408 = -1;
  return D.17408;
  <D.17405>:
  D.17419 = sindex - lencmpstr;
  pos = D.17419 + 1;
  goto <D.16818>;
  <D.16817>:
  D.17420 = (long unsigned int) pos;
  D.17421 = D.17420 * 2;
  D.17422 = src + D.17421;
  D.17423 = (long unsigned int) lencmpstr;
  D.17424 = D.17423 * 2;
  D.17425 = memcmp (D.17422, cmpstr, D.17424);
  if (D.17425 == 0) goto <D.17426>; else goto <D.17427>;
  <D.17426>:
  D.17408 = pos;
  return D.17408;
  <D.17427>:
  pos = pos + -1;
  <D.16818>:
  D.17428 = sindex - count;
  if (D.17428 < pos) goto <D.16817>; else goto <D.16819>;
  <D.16819>:
  D.17408 = -1;
  return D.17408;
}


__attribute__((visibility ("hidden")))
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.17430;

  D.17430 = string_invariant_indexof_char (source, sindex, count, value, first);
  return D.17430;
}


string_invariant_indexof_char (struct MonoString * source, gint32 sindex, gint32 count, gunichar2 value, MonoBoolean first)
{
  long unsigned int D.17434;
  long unsigned int D.17435;
  gunichar2 * D.17436;
  short unsigned int D.17437;
  gint32 D.17440;
  int D.17441;
  int D.17444;
  gint32 pos;
  gunichar2 * src;

  src = mono_string_chars (source);
  if (first != 0) goto <D.17432>; else goto <D.17433>;
  <D.17432>:
  pos = sindex;
  goto <D.16830>;
  <D.16829>:
  D.17434 = (long unsigned int) pos;
  D.17435 = D.17434 * 2;
  D.17436 = src + D.17435;
  D.17437 = *D.17436;
  if (D.17437 == value) goto <D.17438>; else goto <D.17439>;
  <D.17438>:
  D.17440 = pos;
  return D.17440;
  <D.17439>:
  pos = pos + 1;
  <D.16830>:
  D.17441 = count + sindex;
  if (D.17441 != pos) goto <D.16829>; else goto <D.16831>;
  <D.16831>:
  D.17440 = -1;
  return D.17440;
  <D.17433>:
  pos = sindex;
  goto <D.16833>;
  <D.16832>:
  D.17434 = (long unsigned int) pos;
  D.17435 = D.17434 * 2;
  D.17436 = src + D.17435;
  D.17437 = *D.17436;
  if (D.17437 == value) goto <D.17442>; else goto <D.17443>;
  <D.17442>:
  D.17440 = pos;
  return D.17440;
  <D.17443>:
  pos = pos + -1;
  <D.16833>:
  D.17444 = sindex - count;
  if (D.17444 < pos) goto <D.16832>; else goto <D.16834>;
  <D.16834>:
  D.17440 = -1;
  return D.17440;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Threading_Thread_current_lcid ()
{
  int D.17446;

  D.17446 = 127;
  return D.17446;
}


__attribute__((visibility ("hidden")))
ves_icall_System_String_InternalReplace_Str_Comp (struct MonoString * this, struct MonoString * old, struct MonoString * new, struct MonoCompareInfo * comp)
{
  struct MonoString * D.17448;

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


string_invariant_replace (struct MonoString * me, struct MonoString * oldValue, struct MonoString * newValue)
{
  long unsigned int D.17455;
  long unsigned int D.17456;
  gunichar2 * D.17457;
  long unsigned int D.17458;
  long unsigned int D.17459;
  int D.17460;
  int D.17464;
  struct MonoString * D.17467;
  int D.17468;
  int D.17469;
  int D.17471;
  struct MonoDomain * D.17476;
  long unsigned int D.17479;
  long unsigned int D.17480;
  gunichar2 * D.17481;
  long unsigned int D.17482;
  long unsigned int D.17483;
  short unsigned int D.17486;
  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.17450>; else goto <D.17451>;
  <D.17450>:
  newstr = mono_string_chars (newValue);
  newstrlen = mono_string_length (newValue);
  goto <D.17452>;
  <D.17451>:
  newstrlen = 0;
  <D.17452>:
  src = mono_string_chars (me);
  srclen = mono_string_length (me);
  if (oldstrlen != newstrlen) goto <D.17453>; else goto <D.17454>;
  <D.17453>:
  i = 0;
  goto <D.16794>;
  <D.16793>:
  D.17455 = (long unsigned int) i;
  D.17456 = D.17455 * 2;
  D.17457 = src + D.17456;
  D.17458 = (long unsigned int) oldstrlen;
  D.17459 = D.17458 * 2;
  D.17460 = memcmp (D.17457, oldstr, D.17459);
  if (D.17460 == 0) goto <D.17461>; else goto <D.17462>;
  <D.17461>:
  occurr = occurr + 1;
  i = i + oldstrlen;
  goto <D.17463>;
  <D.17462>:
  i = i + 1;
  <D.17463>:
  <D.16794>:
  D.17464 = srclen - oldstrlen;
  if (D.17464 >= i) goto <D.16793>; else goto <D.16795>;
  <D.16795>:
  if (occurr == 0) goto <D.17465>; else goto <D.17466>;
  <D.17465>:
  D.17467 = me;
  return D.17467;
  <D.17466>:
  D.17468 = newstrlen - oldstrlen;
  D.17469 = D.17468 * occurr;
  newsize = D.17469 + srclen;
  goto <D.17470>;
  <D.17454>:
  newsize = srclen;
  <D.17470>:
  ret = 0B;
  i = 0;
  goto <D.16796>;
  <D.16797>:
  D.17455 = (long unsigned int) i;
  D.17456 = D.17455 * 2;
  D.17457 = src + D.17456;
  D.17458 = (long unsigned int) oldstrlen;
  D.17459 = D.17458 * 2;
  D.17471 = memcmp (D.17457, oldstr, D.17459);
  if (D.17471 == 0) goto <D.17472>; else goto <D.17473>;
  <D.17472>:
  if (ret == 0B) goto <D.17474>; else goto <D.17475>;
  <D.17474>:
  D.17476 = mono_domain_get ();
  ret = mono_string_new_size (D.17476, newsize);
  dest = mono_string_chars (ret);
  D.17455 = (long unsigned int) i;
  D.17456 = D.17455 * 2;
  memcpy (dest, src, D.17456);
  <D.17475>:
  if (newstrlen > 0) goto <D.17477>; else goto <D.17478>;
  <D.17477>:
  D.17479 = (long unsigned int) destpos;
  D.17480 = D.17479 * 2;
  D.17481 = dest + D.17480;
  D.17482 = (long unsigned int) newstrlen;
  D.17483 = D.17482 * 2;
  memcpy (D.17481, newstr, D.17483);
  destpos = destpos + newstrlen;
  <D.17478>:
  i = i + oldstrlen;
  // predicted unlikely by continue predictor.
  goto <D.16796>;
  <D.17473>:
  if (ret != 0B) goto <D.17484>; else goto <D.17485>;
  <D.17484>:
  D.17479 = (long unsigned int) destpos;
  D.17480 = D.17479 * 2;
  D.17481 = dest + D.17480;
  D.17455 = (long unsigned int) i;
  D.17456 = D.17455 * 2;
  D.17457 = src + D.17456;
  D.17486 = *D.17457;
  *D.17481 = D.17486;
  <D.17485>:
  destpos = destpos + 1;
  i = i + 1;
  <D.16796>:
  if (i < srclen) goto <D.16797>; else goto <D.16798>;
  <D.16798>:
  if (ret == 0B) goto <D.17487>; else goto <D.17488>;
  <D.17487>:
  D.17467 = me;
  return D.17467;
  <D.17488>:
  D.17467 = ret;
  return D.17467;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.17490;
  long unsigned int D.17491;

  D.17491 = __builtin_object_size (__dest, 0);
  D.17490 = __builtin___memcpy_chk (__dest, __src, __len, D.17491);
  return D.17490;
}


__attribute__((visibility ("hidden")))
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;
}


