Glib::Date::Date() (struct Date * const this)
{
  struct GDate * D.86807;

  D.86807 = &this->gobject_;
  g_date_clear (D.86807, 1);
}


Glib::Date::Date(Glib::Date::Day, Glib::Date::Month, Glib::Date::Year) (struct Date * const this, Day day, Month month, Year year)
{
  struct GDate * D.86808;
  int D.86809;
  int D.86810;

  D.86808 = &this->gobject_;
  g_date_clear (D.86808, 1);
  D.86809 = (int) year;
  D.86810 = (int) day;
  D.86808 = &this->gobject_;
  g_date_set_dmy (D.86808, D.86810, month, D.86809);
}


Glib::Date::Date(guint32) (struct Date * const this, guint32 julian_day)
{
  struct GDate * D.86811;

  D.86811 = &this->gobject_;
  g_date_clear (D.86811, 1);
  D.86811 = &this->gobject_;
  g_date_set_julian (D.86811, julian_day);
}


Glib::Date::Date(const GDate&) (struct Date * const this, const struct GDate & castitem)
{
  this->gobject_ = MEM[(const struct _GDate &)castitem];
}


Glib::Date::Date(const Glib::Date&) (struct Date * const this, const struct Date & other)
{
  struct GDate * D.86812;
  bool retval.0;
  const struct GDate * D.86814;
  int D.86815;
  unsigned int D.86818;

  D.86812 = &this->gobject_;
  g_date_clear (D.86812, 1);
  D.86814 = &other->gobject_;
  D.86815 = g_date_valid (D.86814);
  retval.0 = D.86815 != 0;
  if (retval.0 != 0) goto <D.86816>; else goto <D.86817>;
  <D.86816>:
  D.86818 = Glib::Date::get_julian (other);
  D.86812 = &this->gobject_;
  g_date_set_julian (D.86812, D.86818);
  goto <D.86819>;
  <D.86817>:
  <D.86819>:
}


Glib::Date& Glib::Date::operator=(const Glib::Date&) (struct Date * const this, const struct Date & other)
{
  bool retval.1;
  bool iftmp.2;
  const struct GDate * D.86827;
  int D.86828;
  unsigned int D.86832;
  struct GDate * D.86833;
  struct Date & D.86835;

  if (other != this) goto <D.86826>; else goto <D.86824>;
  <D.86826>:
  D.86827 = &other->gobject_;
  D.86828 = g_date_valid (D.86827);
  if (D.86828 != 0) goto <D.86829>; else goto <D.86824>;
  <D.86829>:
  iftmp.2 = 1;
  goto <D.86825>;
  <D.86824>:
  iftmp.2 = 0;
  <D.86825>:
  retval.1 = iftmp.2;
  if (retval.1 != 0) goto <D.86830>; else goto <D.86831>;
  <D.86830>:
  D.86832 = Glib::Date::get_julian (other);
  D.86833 = &this->gobject_;
  g_date_set_julian (D.86833, D.86832);
  goto <D.86834>;
  <D.86831>:
  <D.86834>:
  D.86835 = this;
  return D.86835;
}


void Glib::Date::clear() (struct Date * const this)
{
  struct GDate * D.86839;

  D.86839 = &this->gobject_;
  g_date_clear (D.86839, 1);
}


void Glib::Date::set_parse(const Glib::ustring&) (struct Date * const this, const struct ustring & str)
{
  const char * D.86840;
  struct GDate * D.86841;

  D.86840 = Glib::ustring::c_str (str);
  D.86841 = &this->gobject_;
  g_date_set_parse (D.86841, D.86840);
}


void Glib::Date::set_time(GTime) (struct Date * const this, GTime time)
{
  long int D.86843;
  struct GDate * D.86844;

  D.86843 = (long int) time;
  D.86844 = &this->gobject_;
  g_date_set_time_t (D.86844, D.86843);
}


void Glib::Date::set_time(time_t) (struct Date * const this, time_t timet)
{
  struct GDate * D.86845;

  D.86845 = &this->gobject_;
  g_date_set_time_t (D.86845, timet);
}


void Glib::Date::set_time_current() (struct Date * const this)
{
  long int D.86846;
  struct GDate * D.86847;

  D.86846 = time (0B);
  D.86847 = &this->gobject_;
  g_date_set_time_t (D.86847, D.86846);
}


void Glib::Date::set_time(const GTimeVal&) (struct Date * const this, const struct GTimeVal & timeval)
{
  struct GDate * D.86848;

  D.86848 = &this->gobject_;
  g_date_set_time_val (D.86848, timeval);
}


void Glib::Date::set_month(Glib::Date::Month) (struct Date * const this, Month month)
{
  struct GDate * D.86849;

  D.86849 = &this->gobject_;
  g_date_set_month (D.86849, month);
}


void Glib::Date::set_day(Glib::Date::Day) (struct Date * const this, Day day)
{
  int D.86850;
  struct GDate * D.86851;

  D.86850 = (int) day;
  D.86851 = &this->gobject_;
  g_date_set_day (D.86851, D.86850);
}


void Glib::Date::set_year(Glib::Date::Year) (struct Date * const this, Year year)
{
  int D.86852;
  struct GDate * D.86853;

  D.86852 = (int) year;
  D.86853 = &this->gobject_;
  g_date_set_year (D.86853, D.86852);
}


void Glib::Date::set_dmy(Glib::Date::Day, Glib::Date::Month, Glib::Date::Year) (struct Date * const this, Day day, Month month, Year year)
{
  int D.86854;
  int D.86855;
  struct GDate * D.86856;

  D.86854 = (int) year;
  D.86855 = (int) day;
  D.86856 = &this->gobject_;
  g_date_set_dmy (D.86856, D.86855, month, D.86854);
}


void Glib::Date::set_julian(guint32) (struct Date * const this, guint32 julian_day)
{
  struct GDate * D.86857;

  D.86857 = &this->gobject_;
  g_date_set_julian (D.86857, julian_day);
}


Glib::Date& Glib::Date::add_days(int) (struct Date * const this, int n_days)
{
  unsigned int n_days.3;
  struct GDate * D.86861;
  int D.86863;
  unsigned int D.86864;
  struct Date & D.86865;

  if (n_days >= 0) goto <D.86858>; else goto <D.86859>;
  <D.86858>:
  n_days.3 = (unsigned int) n_days;
  D.86861 = &this->gobject_;
  g_date_add_days (D.86861, n_days.3);
  goto <D.86862>;
  <D.86859>:
  D.86863 = -n_days;
  D.86864 = (unsigned int) D.86863;
  D.86861 = &this->gobject_;
  g_date_subtract_days (D.86861, D.86864);
  <D.86862>:
  D.86865 = this;
  return D.86865;
}


Glib::Date& Glib::Date::subtract_days(int) (struct Date * const this, int n_days)
{
  unsigned int n_days.4;
  struct GDate * D.86870;
  int D.86872;
  unsigned int D.86873;
  struct Date & D.86874;

  if (n_days >= 0) goto <D.86867>; else goto <D.86868>;
  <D.86867>:
  n_days.4 = (unsigned int) n_days;
  D.86870 = &this->gobject_;
  g_date_subtract_days (D.86870, n_days.4);
  goto <D.86871>;
  <D.86868>:
  D.86872 = -n_days;
  D.86873 = (unsigned int) D.86872;
  D.86870 = &this->gobject_;
  g_date_add_days (D.86870, D.86873);
  <D.86871>:
  D.86874 = this;
  return D.86874;
}


Glib::Date& Glib::Date::add_months(int) (struct Date * const this, int n_months)
{
  unsigned int n_months.5;
  struct GDate * D.86879;
  int D.86881;
  unsigned int D.86882;
  struct Date & D.86883;

  if (n_months >= 0) goto <D.86876>; else goto <D.86877>;
  <D.86876>:
  n_months.5 = (unsigned int) n_months;
  D.86879 = &this->gobject_;
  g_date_add_months (D.86879, n_months.5);
  goto <D.86880>;
  <D.86877>:
  D.86881 = -n_months;
  D.86882 = (unsigned int) D.86881;
  D.86879 = &this->gobject_;
  g_date_subtract_months (D.86879, D.86882);
  <D.86880>:
  D.86883 = this;
  return D.86883;
}


Glib::Date& Glib::Date::subtract_months(int) (struct Date * const this, int n_months)
{
  unsigned int n_months.6;
  struct GDate * D.86888;
  int D.86890;
  unsigned int D.86891;
  struct Date & D.86892;

  if (n_months >= 0) goto <D.86885>; else goto <D.86886>;
  <D.86885>:
  n_months.6 = (unsigned int) n_months;
  D.86888 = &this->gobject_;
  g_date_subtract_months (D.86888, n_months.6);
  goto <D.86889>;
  <D.86886>:
  D.86890 = -n_months;
  D.86891 = (unsigned int) D.86890;
  D.86888 = &this->gobject_;
  g_date_add_months (D.86888, D.86891);
  <D.86889>:
  D.86892 = this;
  return D.86892;
}


Glib::Date& Glib::Date::add_years(int) (struct Date * const this, int n_years)
{
  unsigned int n_years.7;
  struct GDate * D.86897;
  int D.86899;
  unsigned int D.86900;
  struct Date & D.86901;

  if (n_years >= 0) goto <D.86894>; else goto <D.86895>;
  <D.86894>:
  n_years.7 = (unsigned int) n_years;
  D.86897 = &this->gobject_;
  g_date_add_years (D.86897, n_years.7);
  goto <D.86898>;
  <D.86895>:
  D.86899 = -n_years;
  D.86900 = (unsigned int) D.86899;
  D.86897 = &this->gobject_;
  g_date_subtract_years (D.86897, D.86900);
  <D.86898>:
  D.86901 = this;
  return D.86901;
}


Glib::Date& Glib::Date::subtract_years(int) (struct Date * const this, int n_years)
{
  unsigned int n_years.8;
  struct GDate * D.86906;
  int D.86908;
  unsigned int D.86909;
  struct Date & D.86910;

  if (n_years >= 0) goto <D.86903>; else goto <D.86904>;
  <D.86903>:
  n_years.8 = (unsigned int) n_years;
  D.86906 = &this->gobject_;
  g_date_subtract_years (D.86906, n_years.8);
  goto <D.86907>;
  <D.86904>:
  D.86908 = -n_years;
  D.86909 = (unsigned int) D.86908;
  D.86906 = &this->gobject_;
  g_date_add_years (D.86906, D.86909);
  <D.86907>:
  D.86910 = this;
  return D.86910;
}


int Glib::Date::days_between(const Glib::Date&) const (const struct Date * const this, const struct Date & rhs)
{
  int D.86912;
  const struct GDate * D.86913;
  const struct GDate * D.86914;

  D.86913 = &rhs->gobject_;
  D.86914 = &this->gobject_;
  D.86912 = g_date_days_between (D.86914, D.86913);
  return D.86912;
}


int Glib::Date::compare(const Glib::Date&) const (const struct Date * const this, const struct Date & rhs)
{
  int D.86917;
  const struct GDate * D.86918;
  const struct GDate * D.86919;

  D.86918 = &rhs->gobject_;
  D.86919 = &this->gobject_;
  D.86917 = g_date_compare (D.86919, D.86918);
  return D.86917;
}


Glib::Date& Glib::Date::clamp(const Glib::Date&, const Glib::Date&) (struct Date * const this, const struct Date & min_date, const struct Date & max_date)
{
  const struct GDate * D.86922;
  const struct GDate * D.86923;
  struct GDate * D.86924;
  struct Date & D.86925;

  D.86922 = &max_date->gobject_;
  D.86923 = &min_date->gobject_;
  D.86924 = &this->gobject_;
  g_date_clamp (D.86924, D.86923, D.86922);
  D.86925 = this;
  return D.86925;
}


Glib::Date& Glib::Date::clamp_min(const Glib::Date&) (struct Date * const this, const struct Date & min_date)
{
  const struct GDate * D.86927;
  struct GDate * D.86928;
  struct Date & D.86929;

  D.86927 = &min_date->gobject_;
  D.86928 = &this->gobject_;
  g_date_clamp (D.86928, D.86927, 0B);
  D.86929 = this;
  return D.86929;
}


Glib::Date& Glib::Date::clamp_max(const Glib::Date&) (struct Date * const this, const struct Date & max_date)
{
  const struct GDate * D.86931;
  struct GDate * D.86932;
  struct Date & D.86933;

  D.86931 = &max_date->gobject_;
  D.86932 = &this->gobject_;
  g_date_clamp (D.86932, 0B, D.86931);
  D.86933 = this;
  return D.86933;
}


void Glib::Date::order(Glib::Date&) (struct Date * const this, struct Date & other)
{
  struct GDate * D.86935;
  struct GDate * D.86936;

  D.86935 = &other->gobject_;
  D.86936 = &this->gobject_;
  g_date_order (D.86936, D.86935);
}


Glib::Date::Weekday Glib::Date::get_weekday() const (const struct Date * const this)
{
  Weekday D.86937;
  const struct GDate * D.86938;

  D.86938 = &this->gobject_;
  D.86937 = g_date_get_weekday (D.86938);
  return D.86937;
}


Glib::Date::Month Glib::Date::get_month() const (const struct Date * const this)
{
  Month D.86941;
  const struct GDate * D.86942;

  D.86942 = &this->gobject_;
  D.86941 = g_date_get_month (D.86942);
  return D.86941;
}


Glib::Date::Year Glib::Date::get_year() const (const struct Date * const this)
{
  Year D.86945;
  const struct GDate * D.86946;

  D.86946 = &this->gobject_;
  D.86945 = g_date_get_year (D.86946);
  return D.86945;
}


Glib::Date::Day Glib::Date::get_day() const (const struct Date * const this)
{
  Day D.86949;
  const struct GDate * D.86950;

  D.86950 = &this->gobject_;
  D.86949 = g_date_get_day (D.86950);
  return D.86949;
}


guint32 Glib::Date::get_julian() const (const struct Date * const this)
{
  guint32 D.86953;
  const struct GDate * D.86954;

  D.86954 = &this->gobject_;
  D.86953 = g_date_get_julian (D.86954);
  return D.86953;
}


unsigned int Glib::Date::get_day_of_year() const (const struct Date * const this)
{
  unsigned int D.86957;
  const struct GDate * D.86958;

  D.86958 = &this->gobject_;
  D.86957 = g_date_get_day_of_year (D.86958);
  return D.86957;
}


unsigned int Glib::Date::get_monday_week_of_year() const (const struct Date * const this)
{
  unsigned int D.86961;
  const struct GDate * D.86962;

  D.86962 = &this->gobject_;
  D.86961 = g_date_get_monday_week_of_year (D.86962);
  return D.86961;
}


unsigned int Glib::Date::get_sunday_week_of_year() const (const struct Date * const this)
{
  unsigned int D.86965;
  const struct GDate * D.86966;

  D.86966 = &this->gobject_;
  D.86965 = g_date_get_sunday_week_of_year (D.86966);
  return D.86965;
}


unsigned int Glib::Date::get_iso8601_week_of_year() const (const struct Date * const this)
{
  unsigned int D.86969;
  const struct GDate * D.86970;

  D.86970 = &this->gobject_;
  D.86969 = g_date_get_iso8601_week_of_year (D.86970);
  return D.86969;
}


bool Glib::Date::is_first_of_month() const (const struct Date * const this)
{
  bool D.86973;
  const struct GDate * D.86974;
  int D.86975;

  D.86974 = &this->gobject_;
  D.86975 = g_date_is_first_of_month (D.86974);
  D.86973 = D.86975 != 0;
  return D.86973;
}


bool Glib::Date::is_last_of_month() const (const struct Date * const this)
{
  bool D.86978;
  const struct GDate * D.86979;
  int D.86980;

  D.86979 = &this->gobject_;
  D.86980 = g_date_is_last_of_month (D.86979);
  D.86978 = D.86980 != 0;
  return D.86978;
}


static guint8 Glib::Date::get_days_in_month(Glib::Date::Month, Glib::Date::Year) (Month month, Year year)
{
  guint8 D.86983;
  int D.86984;

  D.86984 = (int) year;
  D.86983 = g_date_get_days_in_month (month, D.86984);
  return D.86983;
}


static guint8 Glib::Date::get_monday_weeks_in_year(Glib::Date::Year) (Year year)
{
  guint8 D.86987;
  int D.86988;

  D.86988 = (int) year;
  D.86987 = g_date_get_monday_weeks_in_year (D.86988);
  return D.86987;
}


static guint8 Glib::Date::get_sunday_weeks_in_year(Glib::Date::Year) (Year year)
{
  guint8 D.86991;
  int D.86992;

  D.86992 = (int) year;
  D.86991 = g_date_get_sunday_weeks_in_year (D.86992);
  return D.86991;
}


static bool Glib::Date::is_leap_year(Glib::Date::Year) (Year year)
{
  bool D.86995;
  int D.86996;
  int D.86997;

  D.86996 = (int) year;
  D.86997 = g_date_is_leap_year (D.86996);
  D.86995 = D.86997 != 0;
  return D.86995;
}


Glib::ustring Glib::Date::format_string(const Glib::ustring&) const (const struct Date * const this, const struct ustring & format)
{
  const struct GDate * D.87001;
  const long unsigned int D.86115;
  const long unsigned int D.86114;
  long unsigned int D.87002;
  long unsigned int D.87003;
  const long unsigned int & D.87004;
  void * D.87005;
  char * D.87006;
  const char * D.87007;
  char * D.87008;
  bool retval.9;
  bool iftmp.10;
  char * D.87015;
  char D.87016;
  bool retval.11;
  int retval.12;
  long int D.87024;
  long int D.87025;
  struct string D.86122;
  struct allocator D.86121;
  char * D.87029;
  bool retval.13;
  struct tm tm_data;
  const struct string locale_format;
  gsize bufsize;
  static const char __PRETTY_FUNCTION__[68] = "Glib::ustring Glib::Date::format_string(const Glib::ustring&) const";

  try
    {
      D.87001 = &this->gobject_;
      g_date_to_struct_tm (D.87001, &tm_data);
      locale_format = Glib::locale_from_utf8 (format); [return slot optimization]
      try
        {
          D.86115 = 128;
          try
            {
              D.87002 = std::basic_string<char>::size (&locale_format);
              D.87003 = D.87002 * 2;
              D.86114 = D.87003;
              try
                {
                  D.87004 = std::max<long unsigned int> (&D.86114, &D.86115);
                  bufsize = *D.87004;
                }
              finally
                {
                  D.86114 = {CLOBBER};
                }
            }
          finally
            {
              D.86115 = {CLOBBER};
            }
          <D.86129>:
          {
            const struct ScopedPtr buf;
            const gsize len;

            try
              {
                D.87005 = g_malloc (bufsize);
                Glib::ScopedPtr<char>::ScopedPtr (&buf, D.87005);
                try
                  {
                    D.87006 = Glib::ScopedPtr<char>::get (&buf);
                    *D.87006 = 1;
                    D.87007 = std::basic_string<char>::c_str (&locale_format);
                    D.87008 = Glib::ScopedPtr<char>::get (&buf);
                    len = strftime (D.87008, bufsize, D.87007, &tm_data);
                    {
                      if (len != 0) goto <D.87011>; else goto <D.87014>;
                      <D.87014>:
                      D.87015 = Glib::ScopedPtr<char>::get (&buf);
                      D.87016 = *D.87015;
                      if (D.87016 == 0) goto <D.87011>; else goto <D.87012>;
                      <D.87011>:
                      iftmp.10 = 1;
                      goto <D.87013>;
                      <D.87012>:
                      iftmp.10 = 0;
                      <D.87013>:
                      retval.9 = iftmp.10;
                      if (retval.9 != 0) goto <D.87017>; else goto <D.87018>;
                      <D.87017>:
                      {
                        {
                          {
                            {
                              int _g_boolean_var_;

                              if (len < bufsize) goto <D.87021>; else goto <D.87022>;
                              <D.87021>:
                              _g_boolean_var_ = 1;
                              goto <D.87023>;
                              <D.87022>:
                              _g_boolean_var_ = 0;
                              <D.87023>:
                              retval.12 = _g_boolean_var_;
                            }
                            D.87024 = (long int) retval.12;
                            D.87025 = __builtin_expect (D.87024, 1);
                            retval.11 = D.87025 != 0;
                            if (retval.11 != 0) goto <D.87026>; else goto <D.87027>;
                            <D.87026>:
                            goto <D.87028>;
                            <D.87027>:
                            g_assertion_message_expr ("glibmm", "date.cc", 337, &__PRETTY_FUNCTION__, "len < bufsize");
                            <D.87028>:
                          }
                        }
                        std::allocator<char>::allocator (&D.86121);
                        try
                          {
                            D.87029 = Glib::ScopedPtr<char>::get (&buf);
                            std::basic_string<char>::basic_string (&D.86122, D.87029, len, &D.86121);
                            try
                              {
                                *<retval> = Glib::locale_to_utf8 (&D.86122); [return slot optimization]
                                return <retval>;
                              }
                            finally
                              {
                                std::basic_string<char>::~basic_string (&D.86122);
                                D.86122 = {CLOBBER};
                              }
                          }
                        finally
                          {
                            std::allocator<char>::~allocator (&D.86121);
                            D.86121 = {CLOBBER};
                          }
                      }
                      <D.87018>:
                    }
                  }
                finally
                  {
                    Glib::ScopedPtr<char>::~ScopedPtr (&buf);
                  }
              }
            finally
              {
                buf = {CLOBBER};
              }
          }
          bufsize = bufsize * 2;
          retval.13 = bufsize <= 65536;
          if (retval.13 != 0) goto <D.86129>; else goto <D.86125>;
          <D.86125>:
          g_log ("glibmm", 16, "Glib::Date::format_string(): maximum size of strftime buffer exceeded, giving up");
          Glib::ustring::ustring (<retval>);
          return <retval>;
        }
      finally
        {
          std::basic_string<char>::~basic_string (&locale_format);
        }
    }
  finally
    {
      tm_data = {CLOBBER};
      locale_format = {CLOBBER};
    }
}


std::basic_string<_CharT, _Traits, _Alloc>::size_type std::basic_string<_CharT, _Traits, _Alloc>::size() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::basic_string<_CharT, _Traits, _Alloc>::size_type = long unsigned int] (const struct basic_string * const this)
{
  size_type D.87051;
  struct _Rep * D.87052;

  D.87052 = std::basic_string<char>::_M_rep (this);
  D.87051 = D.87052->D.18966._M_length;
  return D.87051;
}


std::basic_string<_CharT, _Traits, _Alloc>::_Rep* std::basic_string<_CharT, _Traits, _Alloc>::_M_rep() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const struct basic_string * const this)
{
  struct _Rep * D.87055;
  char * D.87056;

  D.87056 = std::basic_string<char>::_M_data (this);
  D.87055 = D.87056 + 18446744073709551592;
  return D.87055;
}


_CharT* std::basic_string<_CharT, _Traits, _Alloc>::_M_data() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const struct basic_string * const this)
{
  char * D.87059;

  D.87059 = this->_M_dataplus._M_p;
  return D.87059;
}


const _Tp& std::max(const _Tp&, const _Tp&) [with _Tp = long unsigned int] (const long unsigned int & __a, const long unsigned int & __b)
{
  long unsigned int D.87061;
  long unsigned int D.87062;
  const long unsigned int & D.87065;

  D.87061 = *__a;
  D.87062 = *__b;
  if (D.87061 < D.87062) goto <D.87063>; else goto <D.87064>;
  <D.87063>:
  D.87065 = __b;
  return D.87065;
  <D.87064>:
  D.87065 = __a;
  return D.87065;
}


Glib::ScopedPtr<T>::ScopedPtr(T*) [with T = char] (struct ScopedPtr * const this, char * ptr)
{
  this->ptr_ = ptr;
}


const _CharT* std::basic_string<_CharT, _Traits, _Alloc>::c_str() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (const struct basic_string * const this)
{
  const char * D.87067;

  D.87067 = std::basic_string<char>::_M_data (this);
  return D.87067;
}


std::allocator< <template-parameter-1-1> >::allocator() [with _Tp = char] (struct allocator * const this)
{
  void * D.87070;

  try
    {
      {
        __gnu_cxx::new_allocator<char>::new_allocator (this);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<char>::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.87070 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.87070);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::new_allocator() [with _Tp = char] (struct new_allocator * const this)
{
  void * D.87071;

  try
    {
      {

      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.87071 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.87071);
          
        }
    }
}


T* Glib::ScopedPtr<T>::get() const [with T = char] (const struct ScopedPtr * const this)
{
  char * D.87072;

  D.87072 = this->ptr_;
  return D.87072;
}


std::allocator< <template-parameter-1-1> >::~allocator() [with _Tp = char] (struct allocator * const this)
{
  void * D.87074;

  try
    {
      {
        try
          {
            try
              {

              }
            finally
              {
                __gnu_cxx::new_allocator<char>::~new_allocator (this);
              }
          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.86436>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.87074 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.87074);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::~new_allocator() [with _Tp = char] (struct new_allocator * const this)
{
  void * D.87075;

  try
    {
      {
        try
          {

          }
        finally
          {
            *this = {CLOBBER};
          }
      }
      <D.86584>:
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.87075 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.87075);
          
        }
    }
}


Glib::ScopedPtr<T>::~ScopedPtr() [with T = char] (struct ScopedPtr * const this)
{
  char * D.87076;

  {
    try
      {
        D.87076 = this->ptr_;
        g_free (D.87076);
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.86492>:
}


std::basic_string<_CharT, _Traits, _Alloc>::~basic_string() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct basic_string * const this)
{
  struct allocator_type D.86212;
  struct _Rep * D.87078;
  struct _Alloc_hider * D.87079;

  {
    try
      {
        try
          {
            D.86212 = std::basic_string<char>::get_allocator (this); [return slot optimization]
            try
              {
                D.87078 = std::basic_string<char>::_M_rep (this);
                std::basic_string<char>::_Rep::_M_dispose (D.87078, &D.86212);
              }
            finally
              {
                std::allocator<char>::~allocator (&D.86212);
                D.86212 = {CLOBBER};
              }
          }
        finally
          {
            D.87079 = &this->_M_dataplus;
            std::basic_string<char>::_Alloc_hider::~_Alloc_hider (D.87079);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.86213>:
}


std::basic_string<_CharT, _Traits, _Alloc>::allocator_type std::basic_string<_CharT, _Traits, _Alloc>::get_allocator() const [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::basic_string<_CharT, _Traits, _Alloc>::allocator_type = std::allocator<char>] (const struct basic_string * const this)
{
  struct _Alloc_hider * D.87085;

  D.87085 = &this->_M_dataplus;
  std::allocator<char>::allocator (<retval>, D.87085);
  return <retval>;
}


std::allocator< <template-parameter-1-1> >::allocator(const std::allocator< <template-parameter-1-1> >&) [with _Tp = char] (struct allocator * const this, const struct allocator & __a)
{
  void * D.87087;

  try
    {
      {
        __gnu_cxx::new_allocator<char>::new_allocator (this, __a);
        try
          {

          }
        catch
          {
            __gnu_cxx::new_allocator<char>::~new_allocator (this);
          }
      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.87087 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.87087);
          
        }
    }
}


__gnu_cxx::new_allocator<_Tp>::new_allocator(const __gnu_cxx::new_allocator<_Tp>&) [with _Tp = char] (struct new_allocator * const this, const struct new_allocator & D.14983)
{
  void * D.87088;

  try
    {
      {

      }
    }
  catch
    {
      <<<eh_filter (NULL)>>>
        {
          
            D.87088 = __builtin_eh_pointer (0);
            __cxa_call_unexpected (D.87088);
          
        }
    }
}


void std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_M_dispose(const _Alloc&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] (struct _Rep * const this, const struct allocator & __a)
{
  bool retval.14;
  struct _Rep & D.87090;
  bool D.87091;
  long int D.87092;
  long int D.87093;
  bool retval.15;
  _Atomic_word * D.87097;
  int D.87098;

  D.87090 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.87091 = D.87090 != this;
  D.87092 = (long int) D.87091;
  D.87093 = __builtin_expect (D.87092, 0);
  retval.14 = D.87093 != 0;
  if (retval.14 != 0) goto <D.87094>; else goto <D.87095>;
  <D.87094>:
  D.87097 = &this->D.18966._M_refcount;
  D.87098 = __gnu_cxx::__exchange_and_add_dispatch (D.87097, -1);
  retval.15 = D.87098 <= 0;
  if (retval.15 != 0) goto <D.87099>; else goto <D.87100>;
  <D.87099>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.87101>;
  <D.87100>:
  <D.87101>:
  goto <D.87102>;
  <D.87095>:
  <D.87102>:
}


static std::basic_string<_CharT, _Traits, _Alloc>::_Rep& std::basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep() [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>] ()
{
  struct _Rep & D.87104;
  void * __p;

  __p = &_S_empty_rep_storage;
  D.87104 = __p;
  return D.87104;
}


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.16;
  int D.87107;
  _Atomic_word D.87110;

  D.87107 = __gthread_active_p ();
  retval.16 = D.87107 != 0;
  if (retval.16 != 0) goto <D.87108>; else goto <D.87109>;
  <D.87108>:
  D.87110 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.87110;
  <D.87109>:
  D.87110 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.87110;
}


int __gthread_active_p() ()
{
  int D.87112;
  bool D.87113;
  static void * const __gthread_active_ptr = (void *) __gthrw___pthread_key_create;

  D.87113 = __gthrw___pthread_key_create != 0B;
  D.87112 = (int) D.87113;
  return D.87112;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.87115;
  unsigned int __val.17;
  unsigned int D.87117;

  __val.17 = (unsigned int) __val;
  D.87117 = __atomic_fetch_add_4 (__mem, __val.17, 4);
  D.87115 = (_Atomic_word) D.87117;
  return D.87115;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.87119;
  int D.87120;
  _Atomic_word D.87121;
  _Atomic_word __result;

  __result = *__mem;
  D.87119 = *__mem;
  D.87120 = D.87119 + __val;
  *__mem = D.87120;
  D.87121 = __result;
  return D.87121;
}


std::basic_string<char>::_Alloc_hider::~_Alloc_hider() (struct _Alloc_hider * const this)
{
  {
    try
      {
        try
          {

          }
        finally
          {
            std::allocator<char>::~allocator (this);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.86206>:
}


void Glib::Date::to_struct_tm(tm&) const (const struct Date * const this, struct tm & dest)
{
  const struct GDate * D.87123;

  D.87123 = &this->gobject_;
  g_date_to_struct_tm (D.87123, dest);
}


bool Glib::Date::valid() const (const struct Date * const this)
{
  bool D.87124;
  const struct GDate * D.87125;
  int D.87126;

  D.87125 = &this->gobject_;
  D.87126 = g_date_valid (D.87125);
  D.87124 = D.87126 != 0;
  return D.87124;
}


static bool Glib::Date::valid_day(Glib::Date::Day) (Day day)
{
  bool D.87129;
  int D.87130;
  int D.87131;

  D.87130 = (int) day;
  D.87131 = g_date_valid_day (D.87130);
  D.87129 = D.87131 != 0;
  return D.87129;
}


static bool Glib::Date::valid_month(Glib::Date::Month) (Month month)
{
  bool D.87134;
  int D.87135;

  D.87135 = g_date_valid_month (month);
  D.87134 = D.87135 != 0;
  return D.87134;
}


static bool Glib::Date::valid_year(Glib::Date::Year) (Year year)
{
  bool D.87138;
  int D.87139;
  int D.87140;

  D.87139 = (int) year;
  D.87140 = g_date_valid_year (D.87139);
  D.87138 = D.87140 != 0;
  return D.87138;
}


static bool Glib::Date::valid_weekday(Glib::Date::Weekday) (Weekday weekday)
{
  bool D.87143;
  int D.87144;

  D.87144 = g_date_valid_weekday (weekday);
  D.87143 = D.87144 != 0;
  return D.87143;
}


static bool Glib::Date::valid_julian(guint32) (guint32 julian_day)
{
  bool D.87147;
  int D.87148;

  D.87148 = g_date_valid_julian (julian_day);
  D.87147 = D.87148 != 0;
  return D.87147;
}


static bool Glib::Date::valid_dmy(Glib::Date::Day, Glib::Date::Month, Glib::Date::Year) (Day day, Month month, Year year)
{
  bool D.87151;
  int D.87152;
  int D.87153;
  int D.87154;

  D.87152 = (int) year;
  D.87153 = (int) day;
  D.87154 = g_date_valid_dmy (D.87153, month, D.87152);
  D.87151 = D.87154 != 0;
  return D.87151;
}