__attribute__((visibility ("hidden")))
mono_decimalIncr (struct decimal_repr * pA, struct decimal_repr * pB)
{
  unsigned int D.8839;
  long unsigned int D.8840;
  long unsigned int D.8841;
  unsigned int D.8842;
  long unsigned int D.8843;
  long unsigned int alo.0;
  unsigned int D.8845;
  long unsigned int ahi.1;
  unsigned int D.8847;
  long unsigned int D.8848;
  long unsigned int D.8849;
  unsigned int D.8850;
  long unsigned int D.8851;
  long unsigned int blo.2;
  unsigned int D.8853;
  long unsigned int bhi.3;
  <unnamed-unsigned:1> D.8855;
  <unnamed-unsigned:1> D.8856;
  int D.8857;
  unsigned char D.8858;
  int scaleA.4;
  unsigned char D.8860;
  int scaleA.5;
  long unsigned int alo.6;
  long unsigned int ahi.7;
  long unsigned int blo.8;
  long unsigned int bhi.9;
  signed long ahi.10;
  long unsigned int alo.11;
  long unsigned int alo.12;
  long unsigned int ahi.13;
  long unsigned int ahi.14;
  _Bool D.8879;
  int D.8884;
  int D.8885;
  int D.8888;
  int scaleA.15;
  int D.8892;
  gint32 D.8895;
  int D.8896;
  guint64 alo;
  guint64 ahi;
  guint64 blo;
  guint64 bhi;
  int log2A;
  int log2B;
  int log2Result;
  int log10Result;
  int rc;
  int subFlag;
  int sign;
  int scaleA;
  int scaleB;

  try
    {
      D.8839 = pA->mid32;
      D.8840 = (long unsigned int) D.8839;
      D.8841 = D.8840 << 32;
      D.8842 = pA->lo32;
      D.8843 = (long unsigned int) D.8842;
      alo.0 = D.8841 | D.8843;
      alo = alo.0;
      D.8845 = pA->hi32;
      ahi.1 = (long unsigned int) D.8845;
      ahi = ahi.1;
      D.8847 = pB->mid32;
      D.8848 = (long unsigned int) D.8847;
      D.8849 = D.8848 << 32;
      D.8850 = pB->lo32;
      D.8851 = (long unsigned int) D.8850;
      blo.2 = D.8849 | D.8851;
      blo = blo.2;
      D.8853 = pB->hi32;
      bhi.3 = (long unsigned int) D.8853;
      bhi = bhi.3;
      D.8855 = pA->u.signscale.sign;
      sign = (int) D.8855;
      D.8856 = pB->u.signscale.sign;
      D.8857 = (int) D.8856;
      subFlag = sign - D.8857;
      D.8858 = pA->u.signscale.scale;
      scaleA.4 = (int) D.8858;
      scaleA = scaleA.4;
      D.8860 = pB->u.signscale.scale;
      scaleB = (int) D.8860;
      scaleA.5 = scaleA;
      if (scaleA.5 == scaleB) goto <D.8862>; else goto <D.8863>;
      <D.8862>:
      if (subFlag != 0) goto <D.8864>; else goto <D.8865>;
      <D.8864>:
      alo.6 = alo;
      ahi.7 = ahi;
      blo.8 = blo;
      bhi.9 = bhi;
      sub128 (alo.6, ahi.7, blo.8, bhi.9, &alo, &ahi);
      ahi.7 = ahi;
      ahi.10 = (signed long) ahi.7;
      if (ahi.10 < 0) goto <D.8871>; else goto <D.8872>;
      <D.8871>:
      alo.6 = alo;
      alo.11 = alo.6 + 18446744073709551615;
      alo = alo.11;
      alo.6 = alo;
      alo.12 = ~alo.6;
      alo = alo.12;
      alo.6 = alo;
      if (alo.6 == 0) goto <D.8875>; else goto <D.8876>;
      <D.8875>:
      ahi.7 = ahi;
      ahi.13 = ahi.7 + 18446744073709551615;
      ahi = ahi.13;
      <D.8876>:
      ahi.7 = ahi;
      ahi.14 = ~ahi.7;
      ahi = ahi.14;
      D.8879 = sign == 0;
      sign = (int) D.8879;
      <D.8872>:
      goto <D.8880>;
      <D.8865>:
      alo.6 = alo;
      ahi.7 = ahi;
      blo.8 = blo;
      bhi.9 = bhi;
      add128 (alo.6, ahi.7, blo.8, bhi.9, &alo, &ahi);
      <D.8880>:
      rc = normalize128 (&alo, &ahi, &scaleA, 1, 0);
      goto <D.8881>;
      <D.8863>:
      alo.6 = alo;
      ahi.7 = ahi;
      scaleA.5 = scaleA;
      log2A = log2withScale_128 (alo.6, ahi.7, scaleA.5);
      blo.8 = blo;
      bhi.9 = bhi;
      log2B = log2withScale_128 (blo.8, bhi.9, scaleB);
      log2Result = MAX_EXPR <log2B, log2A>;
      if (subFlag == 0) goto <D.8882>; else goto <D.8883>;
      <D.8882>:
      log2Result = log2Result + 1;
      <D.8883>:
      D.8884 = log2Result * 1000;
      D.8885 = D.8884 / 3322;
      log10Result = D.8885 + 1;
      scaleA.5 = scaleA;
      if (scaleB > scaleA.5) goto <D.8886>; else goto <D.8887>;
      <D.8886>:
      scaleA = scaleB;
      <D.8887>:
      scaleA.5 = scaleA;
      D.8888 = scaleA.5 + log10Result;
      if (D.8888 > 35) goto <D.8889>; else goto <D.8890>;
      <D.8889>:
      scaleA.15 = 35 - log10Result;
      scaleA = scaleA.15;
      <D.8890>:
      scaleA.5 = scaleA;
      D.8858 = pA->u.signscale.scale;
      scaleA.4 = (int) D.8858;
      D.8892 = scaleA.5 - scaleA.4;
      rc = adjustScale128 (&alo, &ahi, D.8892);
      if (rc != 0) goto <D.8893>; else goto <D.8894>;
      <D.8893>:
      D.8895 = rc;
      return D.8895;
      <D.8894>:
      scaleA.5 = scaleA;
      D.8896 = scaleA.5 - scaleB;
      rc = adjustScale128 (&blo, &bhi, D.8896);
      if (rc != 0) goto <D.8897>; else goto <D.8898>;
      <D.8897>:
      D.8895 = rc;
      return D.8895;
      <D.8898>:
      if (subFlag != 0) goto <D.8899>; else goto <D.8900>;
      <D.8899>:
      alo.6 = alo;
      ahi.7 = ahi;
      blo.8 = blo;
      bhi.9 = bhi;
      sub128 (alo.6, ahi.7, blo.8, bhi.9, &alo, &ahi);
      ahi.7 = ahi;
      ahi.10 = (signed long) ahi.7;
      if (ahi.10 < 0) goto <D.8901>; else goto <D.8902>;
      <D.8901>:
      alo.6 = alo;
      alo.11 = alo.6 + 18446744073709551615;
      alo = alo.11;
      alo.6 = alo;
      alo.12 = ~alo.6;
      alo = alo.12;
      alo.6 = alo;
      if (alo.6 == 0) goto <D.8903>; else goto <D.8904>;
      <D.8903>:
      ahi.7 = ahi;
      ahi.13 = ahi.7 + 18446744073709551615;
      ahi = ahi.13;
      <D.8904>:
      ahi.7 = ahi;
      ahi.14 = ~ahi.7;
      ahi = ahi.14;
      D.8879 = sign == 0;
      sign = (int) D.8879;
      <D.8902>:
      goto <D.8905>;
      <D.8900>:
      alo.6 = alo;
      ahi.7 = ahi;
      blo.8 = blo;
      bhi.9 = bhi;
      add128 (alo.6, ahi.7, blo.8, bhi.9, &alo, &ahi);
      <D.8905>:
      rc = rescale128 (&alo, &ahi, &scaleA, 0, 0, 28, 1);
      <D.8881>:
      if (rc != 0) goto <D.8906>; else goto <D.8907>;
      <D.8906>:
      D.8895 = rc;
      return D.8895;
      <D.8907>:
      alo.6 = alo;
      ahi.7 = ahi;
      scaleA.5 = scaleA;
      D.8895 = pack128toDecimal (pA, alo.6, ahi.7, scaleA.5, sign);
      return D.8895;
    }
  finally
    {
      alo = {CLOBBER};
      ahi = {CLOBBER};
      blo = {CLOBBER};
      bhi = {CLOBBER};
      scaleA = {CLOBBER};
    }
}


normalize128 (guint64 * pclo, guint64 * pchi, int * pScale, int roundFlag, int roundBit)
{
  long unsigned int D.8910;
  long unsigned int D.8911;
  unsigned int D.8912;
  int D.8916;
  long unsigned int D.8921;
  int D.8924;
  guint32 overhang;
  int scale;
  int deltaScale;

  D.8910 = *pchi;
  D.8911 = D.8910 >> 32;
  overhang = (guint32) D.8911;
  scale = *pScale;
  goto <D.8469>;
  <D.8468>:
  deltaScale = 1;
  goto <D.8467>;
  <D.8466>:
  D.8912 = constantsDecadeInt32Factors[deltaScale];
  if (D.8912 > overhang) goto <D.8465>; else goto <D.8913>;
  <D.8913>:
  deltaScale = deltaScale + 1;
  <D.8467>:
  if (deltaScale <= 8) goto <D.8466>; else goto <D.8465>;
  <D.8465>:
  scale = scale - deltaScale;
  if (scale < 0) goto <D.8914>; else goto <D.8915>;
  <D.8914>:
  D.8916 = 2;
  return D.8916;
  <D.8915>:
  D.8912 = constantsDecadeInt32Factors[deltaScale];
  roundBit = div128by32 (pclo, pchi, D.8912, 0B);
  D.8910 = *pchi;
  D.8911 = D.8910 >> 32;
  overhang = (guint32) D.8911;
  if (roundFlag != 0) goto <D.8917>; else goto <D.8918>;
  <D.8917>:
  if (roundBit != 0) goto <D.8919>; else goto <D.8920>;
  <D.8919>:
  D.8921 = *pclo;
  if (D.8921 == 18446744073709551615) goto <D.8922>; else goto <D.8923>;
  <D.8922>:
  D.8910 = *pchi;
  D.8924 = (int) D.8910;
  if (D.8924 == -1) goto <D.8925>; else goto <D.8926>;
  <D.8925>:
  overhang = 1;
  <D.8926>:
  <D.8923>:
  <D.8920>:
  <D.8918>:
  <D.8469>:
  if (overhang != 0) goto <D.8468>; else goto <D.8470>;
  <D.8470>:
  *pScale = scale;
  if (roundFlag != 0) goto <D.8927>; else goto <D.8928>;
  <D.8927>:
  if (roundBit != 0) goto <D.8929>; else goto <D.8930>;
  <D.8929>:
  roundUp128 (pclo, pchi);
  <D.8930>:
  <D.8928>:
  D.8916 = 0;
  return D.8916;
}


div128by32 (guint64 * plo, guint64 * phi, guint32 factor, guint32 * pRest)
{
  long unsigned int D.8932;
  unsigned int D.8933;
  long unsigned int D.8934;
  long unsigned int D.8935;
  unsigned int D.8936;
  long unsigned int D.8937;
  long unsigned int D.8938;
  long unsigned int D.8939;
  unsigned int D.8940;
  long unsigned int D.8941;
  long unsigned int D.8942;
  long unsigned int D.8943;
  unsigned int D.8946;
  int D.8947;
  int iftmp.16;
  long unsigned int D.8954;
  guint64 a;
  guint64 b;
  guint64 c;
  guint64 h;

  h = *phi;
  D.8932 = h >> 32;
  D.8933 = (unsigned int) D.8932;
  a = (guint64) D.8933;
  D.8934 = (long unsigned int) factor;
  b = a / D.8934;
  D.8934 = (long unsigned int) factor;
  D.8935 = D.8934 * b;
  a = a - D.8935;
  a = a << 32;
  D.8936 = (unsigned int) h;
  D.8937 = (long unsigned int) D.8936;
  a = D.8937 | a;
  D.8934 = (long unsigned int) factor;
  c = a / D.8934;
  D.8934 = (long unsigned int) factor;
  D.8938 = D.8934 * c;
  a = a - D.8938;
  a = a << 32;
  D.8939 = b << 32;
  D.8940 = (unsigned int) c;
  D.8941 = (long unsigned int) D.8940;
  D.8942 = D.8939 | D.8941;
  *phi = D.8942;
  h = *plo;
  D.8932 = h >> 32;
  D.8933 = (unsigned int) D.8932;
  D.8943 = (long unsigned int) D.8933;
  a = D.8943 | a;
  D.8934 = (long unsigned int) factor;
  b = a / D.8934;
  D.8934 = (long unsigned int) factor;
  D.8935 = D.8934 * b;
  a = a - D.8935;
  a = a << 32;
  D.8936 = (unsigned int) h;
  D.8937 = (long unsigned int) D.8936;
  a = D.8937 | a;
  D.8934 = (long unsigned int) factor;
  c = a / D.8934;
  D.8934 = (long unsigned int) factor;
  D.8938 = D.8934 * c;
  a = a - D.8938;
  D.8939 = b << 32;
  D.8940 = (unsigned int) c;
  D.8941 = (long unsigned int) D.8940;
  D.8942 = D.8939 | D.8941;
  *plo = D.8942;
  if (pRest != 0B) goto <D.8944>; else goto <D.8945>;
  <D.8944>:
  D.8946 = (unsigned int) a;
  *pRest = D.8946;
  <D.8945>:
  a = a << 1;
  D.8934 = (long unsigned int) factor;
  if (D.8934 <= a) goto <D.8949>; else goto <D.8952>;
  <D.8952>:
  D.8934 = (long unsigned int) factor;
  if (D.8934 == a) goto <D.8953>; else goto <D.8950>;
  <D.8953>:
  D.8954 = c & 1;
  if (D.8954 != 0) goto <D.8949>; else goto <D.8950>;
  <D.8949>:
  iftmp.16 = 1;
  goto <D.8951>;
  <D.8950>:
  iftmp.16 = 0;
  <D.8951>:
  D.8947 = iftmp.16;
  return D.8947;
}


roundUp128 (guint64 * pclo, guint64 * pchi)
{
  long unsigned int D.8956;
  long unsigned int D.8957;
  long unsigned int D.8960;
  long unsigned int D.8961;

  D.8956 = *pclo;
  D.8957 = D.8956 + 1;
  *pclo = D.8957;
  D.8956 = *pclo;
  if (D.8956 == 0) goto <D.8958>; else goto <D.8959>;
  <D.8958>:
  D.8960 = *pchi;
  D.8961 = D.8960 + 1;
  *pchi = D.8961;
  <D.8959>:
}


log2withScale_128 (guint64 alo, guint64 ahi, int scale)
{
  int D.8964;
  int D.8965;
  int D.8966;
  int tlog2;

  tlog2 = log2_128 (alo, ahi);
  if (tlog2 < 0) goto <D.8962>; else goto <D.8963>;
  <D.8962>:
  tlog2 = 0;
  <D.8963>:
  D.8965 = scale * -33219;
  D.8966 = D.8965 / 10000;
  D.8964 = D.8966 + tlog2;
  return D.8964;
}


log2_128 (guint64 alo, guint64 ahi)
{
  int D.8970;
  int D.8971;

  if (ahi == 0) goto <D.8968>; else goto <D.8969>;
  <D.8968>:
  D.8970 = log2_64 (alo);
  return D.8970;
  <D.8969>:
  D.8971 = log2_64 (ahi);
  D.8970 = D.8971 + 64;
  return D.8970;
}


log2_64 (guint64 a)
{
  int D.8975;
  int D.8976;

  if (a == 0) goto <D.8973>; else goto <D.8974>;
  <D.8973>:
  D.8975 = -1000;
  return D.8975;
  <D.8974>:
  D.8976 = my_g_bit_nth_msf (a);
  D.8975 = D.8976 + 1;
  return D.8975;
}


my_g_bit_nth_msf (gsize mask)
{
  long unsigned int D.8978;
  long unsigned int D.8979;
  gint D.8982;
  int i;

  i = 64;
  goto <D.8503>;
  <D.8502>:
  i = i + -1;
  D.8978 = mask >> i;
  D.8979 = D.8978 & 1;
  if (D.8979 != 0) goto <D.8980>; else goto <D.8981>;
  <D.8980>:
  D.8982 = i;
  return D.8982;
  <D.8981>:
  <D.8503>:
  if (i > 0) goto <D.8502>; else goto <D.8504>;
  <D.8504>:
  D.8982 = -1;
  return D.8982;
}


adjustScale128 (guint64 * palo, guint64 * pahi, int deltaScale)
{
  int D.8988;
  unsigned int D.8989;
  int idx;
  int rc;

  if (deltaScale < 0) goto <D.8984>; else goto <D.8985>;
  <D.8984>:
  deltaScale = -deltaScale;
  if (deltaScale > 28) goto <D.8986>; else goto <D.8987>;
  <D.8986>:
  D.8988 = 3;
  return D.8988;
  <D.8987>:
  goto <D.8536>;
  <D.8535>:
  idx = MIN_EXPR <deltaScale, 9>;
  deltaScale = deltaScale - idx;
  D.8989 = constantsDecadeInt32Factors[idx];
  div128by32 (palo, pahi, D.8989, 0B);
  <D.8536>:
  if (deltaScale > 0) goto <D.8535>; else goto <D.8537>;
  <D.8537>:
  goto <D.8990>;
  <D.8985>:
  if (deltaScale > 0) goto <D.8991>; else goto <D.8992>;
  <D.8991>:
  if (deltaScale > 28) goto <D.8993>; else goto <D.8994>;
  <D.8993>:
  D.8988 = 3;
  return D.8988;
  <D.8994>:
  goto <D.8539>;
  <D.8538>:
  idx = MIN_EXPR <deltaScale, 9>;
  deltaScale = deltaScale - idx;
  D.8989 = constantsDecadeInt32Factors[idx];
  rc = mult128by32 (palo, pahi, D.8989, 0);
  if (rc != 0) goto <D.8995>; else goto <D.8996>;
  <D.8995>:
  D.8988 = rc;
  return D.8988;
  <D.8996>:
  <D.8539>:
  if (deltaScale > 0) goto <D.8538>; else goto <D.8540>;
  <D.8540>:
  <D.8992>:
  <D.8990>:
  D.8988 = 0;
  return D.8988;
}


mult128by32 (guint64 * pclo, guint64 * pchi, guint32 factor, int roundBit)
{
  long unsigned int D.8998;
  unsigned int D.8999;
  long unsigned int D.9000;
  long unsigned int D.9001;
  unsigned int D.9004;
  long unsigned int D.9005;
  long unsigned int D.9006;
  long unsigned int D.9007;
  long unsigned int D.9008;
  long unsigned int D.9009;
  long unsigned int D.9010;
  long unsigned int D.9011;
  long unsigned int D.9012;
  long unsigned int D.9013;
  unsigned int D.9014;
  long unsigned int D.9015;
  long unsigned int D.9016;
  long unsigned int D.9017;
  long unsigned int D.9018;
  int D.9019;
  int iftmp.17;
  long unsigned int D.9021;
  guint64 a;
  guint32 h0;
  guint32 h1;

  D.8998 = *pclo;
  D.8999 = (unsigned int) D.8998;
  D.9000 = (long unsigned int) D.8999;
  D.9001 = (long unsigned int) factor;
  a = D.9000 * D.9001;
  if (roundBit != 0) goto <D.9002>; else goto <D.9003>;
  <D.9002>:
  D.9004 = factor / 2;
  D.9005 = (long unsigned int) D.9004;
  a = D.9005 + a;
  <D.9003>:
  h0 = (guint32) a;
  a = a >> 32;
  D.8998 = *pclo;
  D.9006 = D.8998 >> 32;
  D.9007 = (long unsigned int) factor;
  D.9008 = D.9006 * D.9007;
  a = D.9008 + a;
  h1 = (guint32) a;
  D.9009 = (long unsigned int) h1;
  D.9010 = D.9009 << 32;
  D.9011 = (long unsigned int) h0;
  D.9012 = D.9010 | D.9011;
  *pclo = D.9012;
  a = a >> 32;
  D.9013 = *pchi;
  D.9014 = (unsigned int) D.9013;
  D.9015 = (long unsigned int) D.9014;
  D.9001 = (long unsigned int) factor;
  D.9016 = D.9015 * D.9001;
  a = D.9016 + a;
  h0 = (guint32) a;
  a = a >> 32;
  D.9013 = *pchi;
  D.9017 = D.9013 >> 32;
  D.9007 = (long unsigned int) factor;
  D.9018 = D.9017 * D.9007;
  a = D.9018 + a;
  h1 = (guint32) a;
  D.9009 = (long unsigned int) h1;
  D.9010 = D.9009 << 32;
  D.9011 = (long unsigned int) h0;
  D.9012 = D.9010 | D.9011;
  *pchi = D.9012;
  D.9021 = a >> 32;
  if (D.9021 == 0) goto <D.9022>; else goto <D.9023>;
  <D.9022>:
  iftmp.17 = 0;
  goto <D.9024>;
  <D.9023>:
  iftmp.17 = 2;
  <D.9024>:
  D.9019 = iftmp.17;
  return D.9019;
}


sub128 (guint64 alo, guint64 ahi, guint64 blo, guint64 bhi, guint64 * pclo, guint64 * pchi)
{
  guint64 clo;
  guint64 chi;

  clo = alo - blo;
  chi = ahi - bhi;
  if (alo < blo) goto <D.9026>; else goto <D.9027>;
  <D.9026>:
  chi = chi + 18446744073709551615;
  <D.9027>:
  *pclo = clo;
  *pchi = chi;
}


add128 (guint64 alo, guint64 ahi, guint64 blo, guint64 bhi, guint64 * pclo, guint64 * pchi)
{
  alo = alo + blo;
  if (alo < blo) goto <D.9028>; else goto <D.9029>;
  <D.9028>:
  ahi = ahi + 1;
  <D.9029>:
  ahi = ahi + bhi;
  *pclo = alo;
  *pchi = ahi;
}


rescale128 (guint64 * pclo, guint64 * pchi, int * pScale, int texp, int minScale, int maxScale, int roundFlag)
{
  long unsigned int D.9032;
  long unsigned int D.9033;
  long unsigned int D.9036;
  long unsigned int D.9041;
  long unsigned int D.9042;
  int D.9043;
  int D.9044;
  long unsigned int D.9045;
  long unsigned int D.9046;
  int D.9047;
  long unsigned int D.9048;
  long unsigned int D.9049;
  long unsigned int D.9050;
  _Bool D.9051;
  long int D.9052;
  long int D.9053;
  _Bool D.9056;
  long int D.9057;
  long int D.9058;
  int D.9063;
  long unsigned int D.9066;
  int D.9070;
  unsigned int D.9074;
  int D.9086;
  guint32 factor;
  guint32 overhang;
  int scale;
  int i;
  int rc;
  int roundBit;

  roundBit = 0;
  scale = *pScale;
  if (texp > 0) goto <D.9030>; else goto <D.9031>;
  <D.9030>:
  goto <D.8563>;
  <D.8562>:
  D.9032 = *pchi;
  D.9033 = D.9032 >> 32;
  overhang = (guint32) D.9033;
  if (overhang != 0) goto <D.9034>; else goto <D.9035>;
  <D.9034>:
  {
    int msf;
    int shift;

    D.9036 = (long unsigned int) overhang;
    msf = my_g_bit_nth_msf (D.9036);
    shift = msf + -11;
    if (shift >= texp) goto <D.9037>; else goto <D.9038>;
    <D.9037>:
    shift = texp + -1;
    <D.9038>:
    if (shift > 0) goto <D.9039>; else goto <D.9040>;
    <D.9039>:
    texp = texp - shift;
    D.9041 = *pclo;
    D.9042 = D.9041 >> shift;
    D.9032 = *pchi;
    D.9043 = 1 << shift;
    D.9044 = D.9043 + -1;
    D.9045 = (long unsigned int) D.9044;
    D.9046 = D.9032 & D.9045;
    D.9047 = 64 - shift;
    D.9048 = D.9046 << D.9047;
    D.9049 = D.9042 | D.9048;
    *pclo = D.9049;
    D.9032 = *pchi;
    D.9050 = D.9032 >> shift;
    *pchi = D.9050;
    overhang = overhang >> shift;
    D.9051 = texp <= 0;
    D.9052 = (long int) D.9051;
    D.9053 = __builtin_expect (D.9052, 0);
    if (D.9053 != 0) goto <D.9054>; else goto <D.9055>;
    <D.9054>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decimal.c", 730, "texp > 0");
    <D.9055>:
    D.9056 = overhang <= 1024;
    D.9057 = (long int) D.9056;
    D.9058 = __builtin_expect (D.9057, 0);
    if (D.9058 != 0) goto <D.9059>; else goto <D.9060>;
    <D.9059>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "decimal.c", 731, "overhang > (2 << DECIMAL_MAX_INTFACTORS)");
    <D.9060>:
    <D.9040>:
  }
  <D.9035>:
  goto <D.8559>;
  <D.8558>:
  texp = texp + -1;
  if (texp == 0) goto <D.9061>; else goto <D.9062>;
  <D.9061>:
  D.9041 = *pclo;
  D.9063 = (int) D.9041;
  roundBit = D.9063 & 1;
  <D.9062>:
  rshift128 (pclo, pchi);
  overhang = overhang >> 1;
  <D.8559>:
  if (texp > 0) goto <D.9064>; else goto <D.8560>;
  <D.9064>:
  if (overhang > 1024) goto <D.8558>; else goto <D.9065>;
  <D.9065>:
  D.9041 = *pclo;
  D.9066 = D.9041 & 1;
  if (D.9066 == 0) goto <D.8558>; else goto <D.8560>;
  <D.8560>:
  if (texp > 9) goto <D.9067>; else goto <D.9068>;
  <D.9067>:
  i = 9;
  goto <D.9069>;
  <D.9068>:
  i = texp;
  <D.9069>:
  D.9070 = scale + i;
  if (D.9070 > maxScale) goto <D.9071>; else goto <D.9072>;
  <D.9071>:
  i = maxScale - scale;
  <D.9072>:
  if (i == 0) goto <D.8561>; else goto <D.9073>;
  <D.9073>:
  texp = texp - i;
  scale = scale + i;
  D.9074 = constantsDecadeInt32Factors[i];
  factor = D.9074 >> i;
  mult128by32 (pclo, pchi, factor, 0);
  <D.8563>:
  if (texp > 0) goto <D.9075>; else goto <D.8561>;
  <D.9075>:
  if (scale <= maxScale) goto <D.8562>; else goto <D.8561>;
  <D.8561>:
  goto <D.8565>;
  <D.8564>:
  texp = texp + -1;
  if (texp == 0) goto <D.9076>; else goto <D.9077>;
  <D.9076>:
  D.9041 = *pclo;
  D.9063 = (int) D.9041;
  roundBit = D.9063 & 1;
  <D.9077>:
  rshift128 (pclo, pchi);
  <D.8565>:
  if (texp > 0) goto <D.8564>; else goto <D.8566>;
  <D.8566>:
  <D.9031>:
  goto <D.8568>;
  <D.8567>:
  i = scale - maxScale;
  if (i > 9) goto <D.9078>; else goto <D.9079>;
  <D.9078>:
  i = 9;
  <D.9079>:
  scale = scale - i;
  D.9074 = constantsDecadeInt32Factors[i];
  roundBit = div128by32 (pclo, pchi, D.9074, 0B);
  <D.8568>:
  if (scale > maxScale) goto <D.8567>; else goto <D.8569>;
  <D.8569>:
  goto <D.8571>;
  <D.8570>:
  if (roundFlag == 0) goto <D.9080>; else goto <D.9081>;
  <D.9080>:
  roundBit = 0;
  <D.9081>:
  i = minScale - scale;
  if (i > 9) goto <D.9082>; else goto <D.9083>;
  <D.9082>:
  i = 9;
  <D.9083>:
  scale = scale + i;
  D.9074 = constantsDecadeInt32Factors[i];
  rc = mult128by32 (pclo, pchi, D.9074, roundBit);
  if (rc != 0) goto <D.9084>; else goto <D.9085>;
  <D.9084>:
  D.9086 = rc;
  return D.9086;
  <D.9085>:
  roundBit = 0;
  <D.8571>:
  if (scale < minScale) goto <D.8570>; else goto <D.8572>;
  <D.8572>:
  *pScale = scale;
  D.9086 = normalize128 (pclo, pchi, pScale, roundFlag, roundBit);
  return D.9086;
}


rshift128 (guint64 * pclo, guint64 * pchi)
{
  long unsigned int D.9088;
  long unsigned int D.9089;
  long unsigned int D.9090;
  long unsigned int D.9091;
  long unsigned int D.9092;
  long unsigned int D.9093;

  D.9088 = *pclo;
  D.9089 = D.9088 >> 1;
  *pclo = D.9089;
  D.9088 = *pclo;
  D.9090 = *pchi;
  D.9091 = D.9090 << 63;
  D.9092 = D.9088 | D.9091;
  *pclo = D.9092;
  D.9090 = *pchi;
  D.9093 = D.9090 >> 1;
  *pchi = D.9093;
}


pack128toDecimal (struct decimal_repr * pA, guint64 alo, guint64 ahi, int scale, int sign)
{
  unsigned int scale.18;
  long unsigned int D.9098;
  int D.9099;
  unsigned int D.9100;
  long unsigned int D.9101;
  unsigned int D.9102;
  unsigned int D.9103;
  unsigned char D.9104;
  <unnamed-unsigned:1> D.9105;
  unsigned char D.9106;

  scale.18 = (unsigned int) scale;
  if (scale.18 > 28) goto <D.9094>; else goto <D.9097>;
  <D.9097>:
  D.9098 = ahi >> 32;
  if (D.9098 != 0) goto <D.9094>; else goto <D.9095>;
  <D.9094>:
  D.9099 = 2;
  return D.9099;
  <D.9095>:
  D.9100 = (unsigned int) alo;
  pA->lo32 = D.9100;
  D.9101 = alo >> 32;
  D.9102 = (unsigned int) D.9101;
  pA->mid32 = D.9102;
  D.9103 = (unsigned int) ahi;
  pA->hi32 = D.9103;
  D.9104 = (unsigned char) sign;
  D.9105 = (<unnamed-unsigned:1>) D.9104;
  pA->u.signscale.sign = D.9105;
  D.9106 = (unsigned char) scale;
  pA->u.signscale.scale = D.9106;
  D.9099 = 0;
  return D.9099;
}


__attribute__((visibility ("hidden")))
mono_double2decimal (struct decimal_repr * pA, double val, gint32 digits)
{
  long unsigned int D.9108;
  signed long D.9109;
  _Bool D.9110;
  long unsigned int D.9111;
  short unsigned int D.9112;
  long long unsigned int D.9113;
  long long unsigned int alo.19;
  int D.9115;
  int D.9116;
  gint32 D.9120;
  int D.9126;
  long unsigned int alo.20;
  long unsigned int ahi.21;
  int D.9133;
  int scale.22;
  int scale.23;
  long unsigned int D.9136;
  long unsigned int D.9139;
  int scale.24;
  int D.9145;
  guint64 alo;
  guint64 ahi;
  guint64 * p;
  int sigDigits;
  int sign;
  int texp;
  int rc;
  int scale;
  guint16 k;

  try
    {
      p = &val;
      D.9108 = *p;
      D.9109 = (signed long) D.9108;
      D.9110 = D.9109 < 0;
      sign = (int) D.9110;
      D.9108 = *p;
      D.9111 = D.9108 >> 52;
      D.9112 = (short unsigned int) D.9111;
      k = D.9112 & 2047;
      D.9108 = *p;
      D.9113 = D.9108 & 4503599627370495;
      alo.19 = D.9113 | 4503599627370496;
      alo = alo.19;
      ahi = 0;
      D.9115 = (int) k;
      D.9116 = D.9115 & 2047;
      texp = D.9116 + -1023;
      if (k == 2047) goto <D.9117>; else goto <D.9119>;
      <D.9119>:
      if (texp > 95) goto <D.9117>; else goto <D.9118>;
      <D.9117>:
      D.9120 = 2;
      return D.9120;
      <D.9118>:
      if (k == 0) goto <D.9121>; else goto <D.9123>;
      <D.9123>:
      if (texp < -93) goto <D.9121>; else goto <D.9122>;
      <D.9121>:
      memset (pA, 0, 16);
      D.9120 = 0;
      return D.9120;
      <D.9122>:
      texp = texp + -52;
      if (texp > 0) goto <D.9124>; else goto <D.9125>;
      <D.9124>:
      goto <D.8646>;
      <D.8645>:
      lshift128 (&alo, &ahi);
      texp = texp + -1;
      <D.8646>:
      if (texp > 0) goto <D.8645>; else goto <D.8647>;
      <D.8647>:
      <D.9125>:
      scale = 0;
      D.9126 = -texp;
      rc = rescale128 (&alo, &ahi, &scale, D.9126, 0, 28, 1);
      if (rc != 0) goto <D.9127>; else goto <D.9128>;
      <D.9127>:
      D.9120 = rc;
      return D.9120;
      <D.9128>:
      alo.20 = alo;
      ahi.21 = ahi;
      sigDigits = calcDigits (alo.20, ahi.21);
      if (sigDigits > digits) goto <D.9131>; else goto <D.9132>;
      <D.9131>:
      D.9133 = sigDigits - digits;
      div128DecadeFactor (&alo, &ahi, D.9133);
      scale.22 = scale;
      D.9133 = sigDigits - digits;
      scale.23 = scale.22 - D.9133;
      scale = scale.23;
      D.9136 = dec128decadeFactors[digits].hi;
      ahi.21 = ahi;
      if (D.9136 == ahi.21) goto <D.9137>; else goto <D.9138>;
      <D.9137>:
      D.9139 = dec128decadeFactors[digits].lo;
      alo.20 = alo;
      if (D.9139 == alo.20) goto <D.9140>; else goto <D.9141>;
      <D.9140>:
      div128by32 (&alo, &ahi, 10, 0B);
      scale.22 = scale;
      scale.24 = scale.22 + -1;
      scale = scale.24;
      <D.9141>:
      <D.9138>:
      scale.22 = scale;
      if (scale.22 < 0) goto <D.9143>; else goto <D.9144>;
      <D.9143>:
      scale.22 = scale;
      D.9145 = -scale.22;
      rc = mult128DecadeFactor (&alo, &ahi, D.9145);
      if (rc != 0) goto <D.9146>; else goto <D.9147>;
      <D.9146>:
      D.9120 = rc;
      return D.9120;
      <D.9147>:
      scale = 0;
      <D.9144>:
      <D.9132>:
      trimExcessScale (&alo, &ahi, &scale);
      alo.20 = alo;
      ahi.21 = ahi;
      scale.22 = scale;
      D.9120 = pack128toDecimal (pA, alo.20, ahi.21, scale.22, sign);
      return D.9120;
    }
  finally
    {
      alo = {CLOBBER};
      ahi = {CLOBBER};
      scale = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.9150;
  long unsigned int D.9151;

  D.9151 = __builtin_object_size (__dest, 0);
  D.9150 = __builtin___memset_chk (__dest, __ch, __len, D.9151);
  return D.9150;
}


lshift128 (guint64 * pclo, guint64 * pchi)
{
  long unsigned int D.9153;
  long unsigned int D.9154;
  long unsigned int D.9155;
  long long unsigned int D.9156;
  long long unsigned int D.9157;
  long unsigned int D.9158;

  D.9153 = *pchi;
  D.9154 = D.9153 << 1;
  *pchi = D.9154;
  D.9153 = *pchi;
  D.9155 = *pclo;
  D.9156 = D.9155 >> 63;
  D.9157 = D.9153 | D.9156;
  *pchi = D.9157;
  D.9155 = *pclo;
  D.9158 = D.9155 << 1;
  *pclo = D.9158;
}


calcDigits (guint64 alo, guint64 ahi)
{
  int D.9163;
  int D.9165;
  int D.9166;
  long unsigned int D.9169;
  long unsigned int D.9172;
  int tlog2;
  int tlog10;

  tlog2 = 0;
  if (ahi == 0) goto <D.9159>; else goto <D.9160>;
  <D.9159>:
  if (alo == 0) goto <D.9161>; else goto <D.9162>;
  <D.9161>:
  D.9163 = 0;
  return D.9163;
  <D.9162>:
  tlog2 = log2_64 (alo);
  goto <D.9164>;
  <D.9160>:
  D.9165 = log2_64 (ahi);
  tlog2 = D.9165 + 64;
  <D.9164>:
  D.9166 = tlog2 * 1000;
  tlog10 = D.9166 / 3322;
  D.9169 = dec128decadeFactors[tlog10].hi;
  if (D.9169 > ahi) goto <D.9167>; else goto <D.9170>;
  <D.9170>:
  D.9169 = dec128decadeFactors[tlog10].hi;
  if (D.9169 == ahi) goto <D.9171>; else goto <D.9168>;
  <D.9171>:
  D.9172 = dec128decadeFactors[tlog10].lo;
  if (D.9172 > alo) goto <D.9167>; else goto <D.9168>;
  <D.9167>:
  tlog10 = tlog10 + -1;
  <D.9168>:
  D.9163 = tlog10 + 1;
  return D.9163;
}


div128DecadeFactor (guint64 * palo, guint64 * pahi, int powerOfTen)
{
  unsigned int D.9174;
  int idx;
  int roundBit;

  roundBit = 0;
  goto <D.8623>;
  <D.8622>:
  idx = MIN_EXPR <powerOfTen, 9>;
  powerOfTen = powerOfTen - idx;
  D.9174 = constantsDecadeInt32Factors[idx];
  roundBit = div128by32 (palo, pahi, D.9174, 0B);
  <D.8623>:
  if (powerOfTen > 0) goto <D.8622>; else goto <D.8624>;
  <D.8624>:
  if (roundBit != 0) goto <D.9175>; else goto <D.9176>;
  <D.9175>:
  roundUp128 (palo, pahi);
  <D.9176>:
}


mult128DecadeFactor (guint64 * pclo, guint64 * pchi, int powerOfTen)
{
  unsigned int D.9177;
  int D.9180;
  int idx;
  int rc;

  goto <D.8397>;
  <D.8396>:
  idx = MIN_EXPR <powerOfTen, 9>;
  powerOfTen = powerOfTen - idx;
  D.9177 = constantsDecadeInt32Factors[idx];
  rc = mult128by32 (pclo, pchi, D.9177, 0);
  if (rc != 0) goto <D.9178>; else goto <D.9179>;
  <D.9178>:
  D.9180 = rc;
  return D.9180;
  <D.9179>:
  <D.8397>:
  if (powerOfTen > 0) goto <D.8396>; else goto <D.8398>;
  <D.8398>:
  D.9180 = 0;
  return D.9180;
}


trimExcessScale (guint64 * pclo, guint64 * pchi, int * pScale)
{
  long unsigned int ilo.25;
  long unsigned int ihi.26;
  unsigned int rest.27;
  int D.9189;
  guint64 ilo;
  guint64 lastlo;
  guint64 ihi;
  guint64 lasthi;
  int scale;
  int i;
  int roundBit;

  try
    {
      ilo.25 = *pclo;
      ilo = ilo.25;
      ihi.26 = *pchi;
      ihi = ihi.26;
      scale = *pScale;
      i = 0;
      goto <D.8587>;
      <D.8586>:
      scale = scale + -1;
      i = i + 1;
      lastlo = ilo;
      lasthi = ihi;
      roundBit = div128by32 (&ilo, &ihi, 10, &rest);
      rest.27 = rest;
      if (rest.27 != 0) goto <D.9185>; else goto <D.9186>;
      <D.9185>:
      i = i + -1;
      if (i == 0) goto <D.9187>; else goto <D.9188>;
      <D.9187>:
      return;
      <D.9188>:
      *pclo = lastlo;
      *pchi = lasthi;
      D.9189 = scale + 1;
      *pScale = D.9189;
      return;
      <D.9186>:
      <D.8587>:
      if (scale > 0) goto <D.8586>; else goto <D.8588>;
      <D.8588>:
    }
  finally
    {
      ilo = {CLOBBER};
      ihi = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_string2decimal (struct decimal_repr * pA, struct MonoString * str, gint32 decrDecimal, gint32 sign)
{
  long unsigned int ahi.28;
  short unsigned int D.9194;
  int D.9195;
  unsigned int n.29;
  gint32 D.9199;
  int iftmp.30;
  int D.9205;
  int D.9209;
  int D.9213;
  int D.9214;
  int scale.31;
  long unsigned int D.9224;
  long unsigned int D.9225;
  gushort * D.9226;
  short unsigned int D.9227;
  int D.9228;
  sizetype D.9236;
  gushort * D.9237;
  short unsigned int D.9238;
  int D.9239;
  int D.9244;
  long unsigned int alo.32;
  int scale.33;
  gushort * buf;
  gushort * p;
  guint64 alo;
  guint64 ahi;
  int n;
  int rc;
  int i;
  int len;
  int sigLen;
  int firstNonZero;
  int scale;
  int roundBit;

  try
    {
      buf = mono_string_chars (str);
      sigLen = -1;
      roundBit = 0;
      ahi = 0;
      ahi.28 = ahi;
      alo = ahi.28;
      memset (pA, 0, 16);
      p = buf;
      len = 0;
      goto <D.8667>;
      <D.8666>:
      len = len + 1;
      p = p + 2;
      <D.8667>:
      D.9194 = *p;
      if (D.9194 != 0) goto <D.8666>; else goto <D.8668>;
      <D.8668>:
      p = buf;
      i = 0;
      goto <D.8671>;
      <D.8670>:
      D.9194 = *p;
      D.9195 = (int) D.9194;
      n = D.9195 + -48;
      n.29 = (unsigned int) n;
      if (n.29 > 9) goto <D.9197>; else goto <D.9198>;
      <D.9197>:
      D.9199 = 2;
      return D.9199;
      <D.9198>:
      if (n != 0) goto <D.9200>; else goto <D.9201>;
      <D.9200>:
      if (sigLen < 0) goto <D.9202>; else goto <D.9203>;
      <D.9202>:
      firstNonZero = i;
      D.9205 = len - firstNonZero;
      if (D.9205 > 29) goto <D.9206>; else goto <D.9207>;
      <D.9206>:
      iftmp.30 = firstNonZero + 29;
      goto <D.9208>;
      <D.9207>:
      iftmp.30 = len;
      <D.9208>:
      sigLen = iftmp.30;
      D.9209 = sigLen + 1;
      if (D.9209 < decrDecimal) goto <D.9210>; else goto <D.9211>;
      <D.9210>:
      D.9199 = 2;
      return D.9199;
      <D.9211>:
      <D.9203>:
      if (i >= sigLen) goto <D.8669>; else goto <D.9212>;
      <D.9212>:
      D.9213 = sigLen + -1;
      D.9214 = D.9213 - i;
      rc = incMultConstant128 (&alo, &ahi, D.9214, n);
      if (rc != 0) goto <D.9215>; else goto <D.9216>;
      <D.9215>:
      D.9199 = rc;
      return D.9199;
      <D.9216>:
      <D.9201>:
      i = i + 1;
      p = p + 2;
      <D.8671>:
      D.9194 = *p;
      if (D.9194 != 0) goto <D.8670>; else goto <D.8669>;
      <D.8669>:
      if (sigLen < 0) goto <D.9217>; else goto <D.9218>;
      <D.9217>:
      if (len > decrDecimal) goto <D.9219>; else goto <D.9220>;
      <D.9219>:
      sigLen = len;
      <D.9220>:
      <D.9218>:
      scale.31 = sigLen - decrDecimal;
      scale = scale.31;
      if (i < len) goto <D.9222>; else goto <D.9223>;
      <D.9222>:
      D.9224 = (long unsigned int) i;
      D.9225 = D.9224 * 2;
      D.9226 = buf + D.9225;
      D.9227 = *D.9226;
      D.9228 = (int) D.9227;
      n = D.9228 + -48;
      n.29 = (unsigned int) n;
      if (n.29 > 9) goto <D.9229>; else goto <D.9230>;
      <D.9229>:
      D.9199 = 2;
      return D.9199;
      <D.9230>:
      if (n > 5) goto <D.9231>; else goto <D.9232>;
      <D.9231>:
      roundBit = 1;
      goto <D.9233>;
      <D.9232>:
      if (n == 5) goto <D.9234>; else goto <D.9235>;
      <D.9234>:
      D.9224 = (long unsigned int) i;
      D.9225 = D.9224 * 2;
      D.9236 = D.9225 + 18446744073709551614;
      D.9237 = buf + D.9236;
      D.9238 = *D.9237;
      D.9239 = (int) D.9238;
      n = D.9239 + -48;
      i = i + 1;
      goto <D.8674>;
      <D.8673>:
      D.9224 = (long unsigned int) i;
      D.9225 = D.9224 * 2;
      D.9226 = buf + D.9225;
      D.9227 = *D.9226;
      if (D.9227 != 48) goto <D.8672>; else goto <D.9240>;
      <D.9240>:
      i = i + 1;
      <D.8674>:
      if (i < len) goto <D.8673>; else goto <D.8672>;
      <D.8672>:
      if (i < len) goto <D.9241>; else goto <D.9243>;
      <D.9243>:
      D.9244 = n % 2;
      if (D.9244 == 1) goto <D.9241>; else goto <D.9242>;
      <D.9241>:
      roundBit = 1;
      <D.9242>:
      <D.9235>:
      <D.9233>:
      <D.9223>:
      ahi.28 = ahi;
      if (ahi.28 != 0) goto <D.9245>; else goto <D.9246>;
      <D.9245>:
      rc = normalize128 (&alo, &ahi, &scale, 1, roundBit);
      if (rc != 0) goto <D.9247>; else goto <D.9248>;
      <D.9247>:
      D.9199 = rc;
      return D.9199;
      <D.9248>:
      <D.9246>:
      alo.32 = alo;
      if (alo.32 == 0) goto <D.9251>; else goto <D.9249>;
      <D.9251>:
      ahi.28 = ahi;
      if (ahi.28 == 0) goto <D.9252>; else goto <D.9249>;
      <D.9252>:
      scale.33 = scale;
      if (scale.33 <= 0) goto <D.9254>; else goto <D.9249>;
      <D.9254>:
      D.9199 = 0;
      return D.9199;
      <D.9249>:
      alo.32 = alo;
      ahi.28 = ahi;
      scale.31 = sigLen - decrDecimal;
      D.9199 = pack128toDecimal (pA, alo.32, ahi.28, scale.31, sign);
      return D.9199;
    }
  finally
    {
      alo = {CLOBBER};
      ahi = {CLOBBER};
      scale = {CLOBBER};
    }
}


incMultConstant128 (guint64 * palo, guint64 * pahi, int idx, int factor)
{
  long unsigned int blo.34;
  long unsigned int bhi.35;
  unsigned int factor.36;
  long unsigned int bhi.37;
  int D.9265;
  long unsigned int D.9266;
  long unsigned int D.9267;
  long unsigned int blo.38;
  guint64 blo;
  guint64 bhi;
  guint64 h;

  try
    {
      blo.34 = dec128decadeFactors[idx].lo;
      blo = blo.34;
      bhi.35 = dec128decadeFactors[idx].hi;
      bhi = bhi.35;
      h = bhi;
      if (factor != 1) goto <D.9259>; else goto <D.9260>;
      <D.9259>:
      factor.36 = (unsigned int) factor;
      mult128by32 (&blo, &bhi, factor.36, 0);
      bhi.37 = bhi;
      if (h > bhi.37) goto <D.9263>; else goto <D.9264>;
      <D.9263>:
      D.9265 = 2;
      return D.9265;
      <D.9264>:
      <D.9260>:
      h = *pahi;
      D.9266 = *palo;
      D.9267 = *pahi;
      blo.38 = blo;
      bhi.37 = bhi;
      add128 (D.9266, D.9267, blo.38, bhi.37, palo, pahi);
      D.9267 = *pahi;
      if (D.9267 < h) goto <D.9269>; else goto <D.9270>;
      <D.9269>:
      D.9265 = 2;
      return D.9265;
      <D.9270>:
      D.9265 = 0;
      return D.9265;
    }
  finally
    {
      blo = {CLOBBER};
      bhi = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_decimal2UInt64 (struct decimal_repr * pA, guint64 * pResult)
{
  unsigned int D.9273;
  long unsigned int D.9274;
  long unsigned int D.9275;
  unsigned int D.9276;
  long unsigned int D.9277;
  long unsigned int alo.39;
  unsigned int D.9279;
  long unsigned int ahi.40;
  unsigned char D.9281;
  long unsigned int ahi.41;
  long unsigned int alo.42;
  unsigned int D.9290;
  unsigned int D.9291;
  gint32 D.9292;
  guint64 alo;
  guint64 ahi;
  int scale;

  try
    {
      D.9273 = pA->mid32;
      D.9274 = (long unsigned int) D.9273;
      D.9275 = D.9274 << 32;
      D.9276 = pA->lo32;
      D.9277 = (long unsigned int) D.9276;
      alo.39 = D.9275 | D.9277;
      alo = alo.39;
      D.9279 = pA->hi32;
      ahi.40 = (long unsigned int) D.9279;
      ahi = ahi.40;
      D.9281 = pA->u.signscale.scale;
      scale = (int) D.9281;
      if (scale > 0) goto <D.9282>; else goto <D.9283>;
      <D.9282>:
      div128DecadeFactor (&alo, &ahi, scale);
      <D.9283>:
      ahi.41 = ahi;
      if (ahi.41 != 0) goto <D.9284>; else goto <D.9287>;
      <D.9287>:
      alo.42 = alo;
      if (alo.42 != 0) goto <D.9289>; else goto <D.9285>;
      <D.9289>:
      D.9290 = BIT_FIELD_REF <MEM[(void *)pA], 32, 0>;
      D.9291 = D.9290 & 2147483648;
      if (D.9291 != 0) goto <D.9284>; else goto <D.9285>;
      <D.9284>:
      D.9292 = 2;
      return D.9292;
      <D.9285>:
      alo.42 = alo;
      *pResult = alo.42;
      D.9292 = 0;
      return D.9292;
    }
  finally
    {
      alo = {CLOBBER};
      ahi = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_decimal2Int64 (struct decimal_repr * pA, gint64 * pResult)
{
  unsigned int D.9295;
  long unsigned int D.9296;
  long unsigned int D.9297;
  unsigned int D.9298;
  long unsigned int D.9299;
  long unsigned int alo.43;
  unsigned int D.9301;
  long unsigned int ahi.44;
  unsigned char D.9303;
  long unsigned int ahi.45;
  gint32 D.9309;
  <unnamed-unsigned:1> D.9310;
  long unsigned int alo.46;
  long unsigned int D.9318;
  long int D.9319;
  signed long alo.47;
  long int alo.48;
  guint64 alo;
  guint64 ahi;
  int sign;
  int scale;

  try
    {
      D.9295 = pA->mid32;
      D.9296 = (long unsigned int) D.9295;
      D.9297 = D.9296 << 32;
      D.9298 = pA->lo32;
      D.9299 = (long unsigned int) D.9298;
      alo.43 = D.9297 | D.9299;
      alo = alo.43;
      D.9301 = pA->hi32;
      ahi.44 = (long unsigned int) D.9301;
      ahi = ahi.44;
      D.9303 = pA->u.signscale.scale;
      scale = (int) D.9303;
      if (scale > 0) goto <D.9304>; else goto <D.9305>;
      <D.9304>:
      div128DecadeFactor (&alo, &ahi, scale);
      <D.9305>:
      ahi.45 = ahi;
      if (ahi.45 != 0) goto <D.9307>; else goto <D.9308>;
      <D.9307>:
      D.9309 = 2;
      return D.9309;
      <D.9308>:
      D.9310 = pA->u.signscale.sign;
      sign = (int) D.9310;
      if (sign != 0) goto <D.9313>; else goto <D.9311>;
      <D.9313>:
      alo.46 = alo;
      if (alo.46 != 0) goto <D.9315>; else goto <D.9311>;
      <D.9315>:
      alo.46 = alo;
      if (alo.46 > 9223372036854775808) goto <D.9316>; else goto <D.9317>;
      <D.9316>:
      D.9309 = 2;
      return D.9309;
      <D.9317>:
      alo.46 = alo;
      D.9318 = -alo.46;
      D.9319 = (long int) D.9318;
      *pResult = D.9319;
      goto <D.9312>;
      <D.9311>:
      alo.46 = alo;
      alo.47 = (signed long) alo.46;
      if (alo.47 < 0) goto <D.9321>; else goto <D.9322>;
      <D.9321>:
      D.9309 = 2;
      return D.9309;
      <D.9322>:
      alo.46 = alo;
      alo.48 = (long int) alo.46;
      *pResult = alo.48;
      <D.9312>:
      D.9309 = 0;
      return D.9309;
    }
  finally
    {
      alo = {CLOBBER};
      ahi = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_decimalFloorAndTrunc (struct decimal_repr * pA, gint32 floorFlag)
{
  unsigned char D.9326;
  unsigned int D.9329;
  long unsigned int D.9330;
  long unsigned int D.9331;
  unsigned int D.9332;
  long unsigned int D.9333;
  long unsigned int alo.49;
  unsigned int D.9335;
  long unsigned int ahi.50;
  <unnamed-unsigned:1> D.9337;
  int iftmp.51;
  unsigned int rest.52;
  long unsigned int alo.53;
  long unsigned int ahi.54;
  guint64 alo;
  guint64 ahi;
  guint32 factor;
  guint32 rest;
  int scale;
  int sign;
  int idx;
  int hasRest;

  try
    {
      hasRest = 0;
      D.9326 = pA->u.signscale.scale;
      scale = (int) D.9326;
      if (scale == 0) goto <D.9327>; else goto <D.9328>;
      <D.9327>:
      return;
      <D.9328>:
      D.9329 = pA->mid32;
      D.9330 = (long unsigned int) D.9329;
      D.9331 = D.9330 << 32;
      D.9332 = pA->lo32;
      D.9333 = (long unsigned int) D.9332;
      alo.49 = D.9331 | D.9333;
      alo = alo.49;
      D.9335 = pA->hi32;
      ahi.50 = (long unsigned int) D.9335;
      ahi = ahi.50;
      D.9337 = pA->u.signscale.sign;
      sign = (int) D.9337;
      goto <D.8703>;
      <D.8702>:
      idx = MIN_EXPR <scale, 9>;
      factor = constantsDecadeInt32Factors[idx];
      scale = scale - idx;
      div128by32 (&alo, &ahi, factor, &rest);
      if (hasRest != 0) goto <D.9339>; else goto <D.9342>;
      <D.9342>:
      rest.52 = rest;
      if (rest.52 != 0) goto <D.9339>; else goto <D.9340>;
      <D.9339>:
      iftmp.51 = 1;
      goto <D.9341>;
      <D.9340>:
      iftmp.51 = 0;
      <D.9341>:
      hasRest = iftmp.51;
      <D.8703>:
      if (scale > 0) goto <D.8702>; else goto <D.8704>;
      <D.8704>:
      if (floorFlag != 0) goto <D.9344>; else goto <D.9345>;
      <D.9344>:
      if (hasRest != 0) goto <D.9346>; else goto <D.9347>;
      <D.9346>:
      if (sign != 0) goto <D.9348>; else goto <D.9349>;
      <D.9348>:
      roundUp128 (&alo, &ahi);
      <D.9349>:
      <D.9347>:
      <D.9345>:
      alo.53 = alo;
      ahi.54 = ahi;
      pack128toDecimal (pA, alo.53, ahi.54, 0, sign);
    }
  finally
    {
      alo = {CLOBBER};
      ahi = {CLOBBER};
      rest = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_decimalRound (struct decimal_repr * pA, gint32 decimals)
{
  unsigned int D.9355;
  long unsigned int D.9356;
  long unsigned int D.9357;
  unsigned int D.9358;
  long unsigned int D.9359;
  long unsigned int alo.55;
  unsigned int D.9361;
  long unsigned int ahi.56;
  unsigned char D.9363;
  <unnamed-unsigned:1> D.9364;
  int D.9367;
  long unsigned int alo.57;
  long unsigned int ahi.58;
  guint64 alo;
  guint64 ahi;
  int scale;
  int sign;

  try
    {
      D.9355 = pA->mid32;
      D.9356 = (long unsigned int) D.9355;
      D.9357 = D.9356 << 32;
      D.9358 = pA->lo32;
      D.9359 = (long unsigned int) D.9358;
      alo.55 = D.9357 | D.9359;
      alo = alo.55;
      D.9361 = pA->hi32;
      ahi.56 = (long unsigned int) D.9361;
      ahi = ahi.56;
      D.9363 = pA->u.signscale.scale;
      scale = (int) D.9363;
      D.9364 = pA->u.signscale.sign;
      sign = (int) D.9364;
      if (scale > decimals) goto <D.9365>; else goto <D.9366>;
      <D.9365>:
      D.9367 = scale - decimals;
      div128DecadeFactor (&alo, &ahi, D.9367);
      scale = decimals;
      <D.9366>:
      alo.57 = alo;
      ahi.58 = ahi;
      pack128toDecimal (pA, alo.57, ahi.58, scale, sign);
    }
  finally
    {
      alo = {CLOBBER};
      ahi = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_decimalMult (struct decimal_repr * pA, struct decimal_repr * pB)
{
  unsigned int D.9370;
  unsigned int D.9371;
  unsigned int D.9372;
  unsigned int D.9373;
  unsigned int D.9374;
  unsigned int D.9375;
  unsigned char D.9376;
  int D.9377;
  unsigned char D.9378;
  int D.9379;
  int scale.59;
  <unnamed-unsigned:1> D.9381;
  <unnamed-unsigned:1> D.9382;
  <unnamed-unsigned:1> D.9383;
  long unsigned int high.60;
  int scale.61;
  int scale.62;
  int scale.63;
  long unsigned int mid.64;
  long unsigned int D.9393;
  long unsigned int D.9394;
  gint32 D.9397;
  long unsigned int low.65;
  guint64 low;
  guint64 mid;
  guint64 high;
  guint32 factor;
  int scale;
  int sign;
  int rc;

  try
    {
      D.9370 = pA->lo32;
      D.9371 = pA->mid32;
      D.9372 = pA->hi32;
      D.9373 = pB->lo32;
      D.9374 = pB->mid32;
      D.9375 = pB->hi32;
      mult96by96to192 (D.9370, D.9371, D.9372, D.9373, D.9374, D.9375, &low, &mid, &high);
      D.9376 = pA->u.signscale.scale;
      D.9377 = (int) D.9376;
      D.9378 = pB->u.signscale.scale;
      D.9379 = (int) D.9378;
      scale.59 = D.9377 + D.9379;
      scale = scale.59;
      D.9381 = pA->u.signscale.sign;
      D.9382 = pB->u.signscale.sign;
      D.9383 = D.9381 ^ D.9382;
      sign = (int) D.9383;
      factor = 1000000000;
      goto <D.8725>;
      <D.8724>:
      high.60 = high;
      if (high.60 <= 99) goto <D.9385>; else goto <D.9386>;
      <D.9385>:
      factor = factor / 1000;
      scale.61 = scale;
      scale.62 = scale.61 + -6;
      scale = scale.62;
      goto <D.9389>;
      <D.9386>:
      scale.61 = scale;
      scale.63 = scale.61 + -9;
      scale = scale.63;
      <D.9389>:
      div192by32 (&low, &mid, &high, factor);
      <D.8725>:
      high.60 = high;
      if (high.60 != 0) goto <D.8724>; else goto <D.9391>;
      <D.9391>:
      mid.64 = mid;
      D.9393 = mid.64 >> 32;
      D.9394 = (long unsigned int) factor;
      if (D.9393 >= D.9394) goto <D.8724>; else goto <D.8726>;
      <D.8726>:
      rc = rescale128 (&low, &mid, &scale, 0, 0, 28, 1);
      if (rc != 0) goto <D.9395>; else goto <D.9396>;
      <D.9395>:
      D.9397 = rc;
      return D.9397;
      <D.9396>:
      low.65 = low;
      mid.64 = mid;
      scale.61 = scale;
      D.9397 = pack128toDecimal (pA, low.65, mid.64, scale.61, sign);
      return D.9397;
    }
  finally
    {
      low = {CLOBBER};
      mid = {CLOBBER};
      high = {CLOBBER};
      scale = {CLOBBER};
    }
}


mult96by96to192 (guint32 alo, guint32 ami, guint32 ahi, guint32 blo, guint32 bmi, guint32 bhi, guint64 * pclo, guint64 * pcmi, guint64 * pchi)
{
  long unsigned int D.9401;
  long unsigned int D.9402;
  long unsigned int D.9403;
  long unsigned int D.9404;
  long unsigned int D.9409;
  long unsigned int D.9410;
  long unsigned int D.9417;
  long unsigned int D.9422;
  long unsigned int D.9423;
  long unsigned int D.9424;
  long unsigned int D.9425;
  long unsigned int D.9426;
  long unsigned int D.9427;
  long unsigned int D.9428;
  long unsigned int D.9429;
  long unsigned int D.9430;
  long unsigned int D.9431;
  long unsigned int D.9432;
  long unsigned int D.9433;
  long unsigned int D.9434;
  guint64 a;
  guint64 b;
  guint64 c;
  guint64 d;
  guint32 h0;
  guint32 h1;
  guint32 h2;
  guint32 h3;
  guint32 h4;
  guint32 h5;
  int carry0;
  int carry1;

  D.9401 = (long unsigned int) alo;
  D.9402 = (long unsigned int) blo;
  a = D.9401 * D.9402;
  h0 = (guint32) a;
  a = a >> 32;
  carry0 = 0;
  D.9401 = (long unsigned int) alo;
  D.9403 = (long unsigned int) bmi;
  b = D.9401 * D.9403;
  D.9404 = (long unsigned int) ami;
  D.9402 = (long unsigned int) blo;
  c = D.9404 * D.9402;
  a = a + b;
  if (a < b) goto <D.9405>; else goto <D.9406>;
  <D.9405>:
  carry0 = carry0 + 1;
  <D.9406>:
  a = a + c;
  if (a < c) goto <D.9407>; else goto <D.9408>;
  <D.9407>:
  carry0 = carry0 + 1;
  <D.9408>:
  h1 = (guint32) a;
  a = a >> 32;
  carry1 = 0;
  D.9401 = (long unsigned int) alo;
  D.9409 = (long unsigned int) bhi;
  b = D.9401 * D.9409;
  D.9404 = (long unsigned int) ami;
  D.9403 = (long unsigned int) bmi;
  c = D.9404 * D.9403;
  D.9410 = (long unsigned int) ahi;
  D.9402 = (long unsigned int) blo;
  d = D.9410 * D.9402;
  a = a + b;
  if (a < b) goto <D.9411>; else goto <D.9412>;
  <D.9411>:
  carry1 = carry1 + 1;
  <D.9412>:
  a = a + c;
  if (a < c) goto <D.9413>; else goto <D.9414>;
  <D.9413>:
  carry1 = carry1 + 1;
  <D.9414>:
  a = a + d;
  if (a < d) goto <D.9415>; else goto <D.9416>;
  <D.9415>:
  carry1 = carry1 + 1;
  <D.9416>:
  h2 = (guint32) a;
  a = a >> 32;
  D.9417 = (long unsigned int) carry0;
  a = D.9417 + a;
  carry0 = 0;
  D.9404 = (long unsigned int) ami;
  D.9409 = (long unsigned int) bhi;
  b = D.9404 * D.9409;
  D.9410 = (long unsigned int) ahi;
  D.9403 = (long unsigned int) bmi;
  c = D.9410 * D.9403;
  a = a + b;
  if (a < b) goto <D.9418>; else goto <D.9419>;
  <D.9418>:
  carry0 = carry0 + 1;
  <D.9419>:
  a = a + c;
  if (a < c) goto <D.9420>; else goto <D.9421>;
  <D.9420>:
  carry0 = carry0 + 1;
  <D.9421>:
  h3 = (guint32) a;
  a = a >> 32;
  D.9422 = (long unsigned int) carry1;
  a = D.9422 + a;
  D.9410 = (long unsigned int) ahi;
  D.9409 = (long unsigned int) bhi;
  b = D.9410 * D.9409;
  a = a + b;
  h4 = (guint32) a;
  a = a >> 32;
  D.9417 = (long unsigned int) carry0;
  a = D.9417 + a;
  h5 = (guint32) a;
  D.9423 = (long unsigned int) h1;
  D.9424 = D.9423 << 32;
  D.9425 = (long unsigned int) h0;
  D.9426 = D.9424 | D.9425;
  *pclo = D.9426;
  D.9427 = (long unsigned int) h3;
  D.9428 = D.9427 << 32;
  D.9429 = (long unsigned int) h2;
  D.9430 = D.9428 | D.9429;
  *pcmi = D.9430;
  D.9431 = (long unsigned int) h5;
  D.9432 = D.9431 << 32;
  D.9433 = (long unsigned int) h4;
  D.9434 = D.9432 | D.9433;
  *pchi = D.9434;
}


div192by32 (guint64 * plo, guint64 * pmi, guint64 * phi, guint32 factor)
{
  long unsigned int D.9435;
  unsigned int D.9436;
  long unsigned int D.9437;
  long unsigned int D.9438;
  unsigned int D.9439;
  long unsigned int D.9440;
  long unsigned int D.9441;
  long unsigned int D.9442;
  unsigned int D.9443;
  long unsigned int D.9444;
  long unsigned int D.9445;
  long unsigned int D.9446;
  guint64 a;
  guint64 b;
  guint64 c;
  guint64 h;

  h = *phi;
  D.9435 = h >> 32;
  D.9436 = (unsigned int) D.9435;
  a = (guint64) D.9436;
  D.9437 = (long unsigned int) factor;
  b = a / D.9437;
  D.9437 = (long unsigned int) factor;
  D.9438 = D.9437 * b;
  a = a - D.9438;
  a = a << 32;
  D.9439 = (unsigned int) h;
  D.9440 = (long unsigned int) D.9439;
  a = D.9440 | a;
  D.9437 = (long unsigned int) factor;
  c = a / D.9437;
  D.9437 = (long unsigned int) factor;
  D.9441 = D.9437 * c;
  a = a - D.9441;
  a = a << 32;
  D.9442 = b << 32;
  D.9443 = (unsigned int) c;
  D.9444 = (long unsigned int) D.9443;
  D.9445 = D.9442 | D.9444;
  *phi = D.9445;
  h = *pmi;
  D.9435 = h >> 32;
  D.9436 = (unsigned int) D.9435;
  D.9446 = (long unsigned int) D.9436;
  a = D.9446 | a;
  D.9437 = (long unsigned int) factor;
  b = a / D.9437;
  D.9437 = (long unsigned int) factor;
  D.9438 = D.9437 * b;
  a = a - D.9438;
  a = a << 32;
  D.9439 = (unsigned int) h;
  D.9440 = (long unsigned int) D.9439;
  a = D.9440 | a;
  D.9437 = (long unsigned int) factor;
  c = a / D.9437;
  D.9437 = (long unsigned int) factor;
  D.9441 = D.9437 * c;
  a = a - D.9441;
  a = a << 32;
  D.9442 = b << 32;
  D.9443 = (unsigned int) c;
  D.9444 = (long unsigned int) D.9443;
  D.9445 = D.9442 | D.9444;
  *pmi = D.9445;
  h = *plo;
  D.9435 = h >> 32;
  D.9436 = (unsigned int) D.9435;
  D.9446 = (long unsigned int) D.9436;
  a = D.9446 | a;
  D.9437 = (long unsigned int) factor;
  b = a / D.9437;
  D.9437 = (long unsigned int) factor;
  D.9438 = D.9437 * b;
  a = a - D.9438;
  a = a << 32;
  D.9439 = (unsigned int) h;
  D.9440 = (long unsigned int) D.9439;
  a = D.9440 | a;
  D.9437 = (long unsigned int) factor;
  c = a / D.9437;
  D.9437 = (long unsigned int) factor;
  D.9441 = D.9437 * c;
  a = a - D.9441;
  a = a << 32;
  D.9442 = b << 32;
  D.9443 = (unsigned int) c;
  D.9444 = (long unsigned int) D.9443;
  D.9445 = D.9442 | D.9444;
  *plo = D.9445;
}


__attribute__((visibility ("hidden")))
mono_decimalDiv (struct decimal_repr * pC, struct decimal_repr * pA, struct decimal_repr * pB)
{
  int D.9447;
  gint32 D.9450;
  unsigned int D.9451;
  signed int D.9452;
  _Bool D.9453;
  int D.9454;
  unsigned char D.9461;
  int D.9462;
  unsigned char D.9463;
  int D.9464;
  int scale.66;
  int texp.67;
  long unsigned int clo.68;
  long unsigned int chi.69;
  int scale.70;
  <unnamed-unsigned:1> D.9472;
  <unnamed-unsigned:1> D.9473;
  <unnamed-unsigned:1> D.9474;
  int D.9475;
  guint64 clo;
  guint64 chi;
  int scale;
  int texp;
  int rc;

  try
    {
      D.9447 = mono_decimalCompare (pA, pB);
      if (D.9447 == 0) goto <D.9448>; else goto <D.9449>;
      <D.9448>:
      D.9450 = pack128toDecimal (pC, 1, 0, 0, 0);
      return D.9450;
      <D.9449>:
      D.9451 = BIT_FIELD_REF <MEM[(void *)pA], 32, 0>;
      D.9452 = (signed int) D.9451;
      D.9453 = D.9452 >= 0;
      pA->u.signscale.sign = D.9453;
      D.9454 = mono_decimalCompare (pA, pB);
      if (D.9454 == 0) goto <D.9455>; else goto <D.9456>;
      <D.9455>:
      D.9450 = pack128toDecimal (pC, 1, 0, 0, 1);
      return D.9450;
      <D.9456>:
      D.9451 = BIT_FIELD_REF <MEM[(void *)pA], 32, 0>;
      D.9452 = (signed int) D.9451;
      D.9453 = D.9452 >= 0;
      pA->u.signscale.sign = D.9453;
      rc = decimalDivSub (pA, pB, &clo, &chi, &texp);
      if (rc != 0) goto <D.9457>; else goto <D.9458>;
      <D.9457>:
      if (rc == 1) goto <D.9459>; else goto <D.9460>;
      <D.9459>:
      rc = 0;
      <D.9460>:
      D.9450 = rc;
      return D.9450;
      <D.9458>:
      D.9461 = pA->u.signscale.scale;
      D.9462 = (int) D.9461;
      D.9463 = pB->u.signscale.scale;
      D.9464 = (int) D.9463;
      scale.66 = D.9462 - D.9464;
      scale = scale.66;
      texp.67 = texp;
      rc = rescale128 (&clo, &chi, &scale, texp.67, 0, 28, 1);
      if (rc != 0) goto <D.9467>; else goto <D.9468>;
      <D.9467>:
      D.9450 = rc;
      return D.9450;
      <D.9468>:
      clo.68 = clo;
      chi.69 = chi;
      scale.70 = scale;
      D.9472 = pA->u.signscale.sign;
      D.9473 = pB->u.signscale.sign;
      D.9474 = D.9472 ^ D.9473;
      D.9475 = (int) D.9474;
      D.9450 = pack128toDecimal (pC, clo.68, chi.69, scale.70, D.9475);
      return D.9450;
    }
  finally
    {
      clo = {CLOBBER};
      chi = {CLOBBER};
      scale = {CLOBBER};
      texp = {CLOBBER};
    }
}


decimalDivSub (struct decimal_repr * pA, struct decimal_repr * pB, guint64 * pclo, guint64 * pchi, int * pExp)
{
  unsigned int D.9478;
  long unsigned int D.9479;
  long unsigned int D.9480;
  unsigned int D.9481;
  long unsigned int D.9482;
  long unsigned int ahi.71;
  unsigned int D.9484;
  long unsigned int D.9485;
  long unsigned int ami.72;
  int D.9493;
  long unsigned int ami.73;
  long unsigned int ahi.74;
  long unsigned int D.9500;
  long unsigned int ahi.75;
  signed long ahi.76;
  long unsigned int D.9510;
  int D.9511;
  int D.9512;
  unsigned int D.9513;
  unsigned int D.9515;
  signed int bhi.77;
  unsigned int D.9518;
  long unsigned int D.9519;
  long unsigned int D.9520;
  long unsigned int D.9521;
  long unsigned int D.9522;
  long unsigned int alo.78;
  int D.9529;
  long long unsigned int D.9532;
  long unsigned int D.9534;
  long unsigned int D.9535;
  guint64 alo;
  guint64 ami;
  guint64 ahi;
  guint64 tlo;
  guint64 tmi;
  guint64 thi;
  guint32 blo;
  guint32 bmi;
  guint32 bhi;
  int ashift;
  int bshift;
  int extraBit;
  int texp;

  try
    {
      D.9478 = pA->hi32;
      D.9479 = (long unsigned int) D.9478;
      D.9480 = D.9479 << 32;
      D.9481 = pA->mid32;
      D.9482 = (long unsigned int) D.9481;
      ahi.71 = D.9480 | D.9482;
      ahi = ahi.71;
      D.9484 = pA->lo32;
      D.9485 = (long unsigned int) D.9484;
      ami.72 = D.9485 << 32;
      ami = ami.72;
      alo = 0;
      blo = pB->lo32;
      bmi = pB->mid32;
      bhi = pB->hi32;
      if (blo == 0) goto <D.9487>; else goto <D.9488>;
      <D.9487>:
      if (bmi == 0) goto <D.9489>; else goto <D.9490>;
      <D.9489>:
      if (bhi == 0) goto <D.9491>; else goto <D.9492>;
      <D.9491>:
      D.9493 = 5;
      return D.9493;
      <D.9492>:
      <D.9490>:
      <D.9488>:
      ami.73 = ami;
      if (ami.73 == 0) goto <D.9495>; else goto <D.9496>;
      <D.9495>:
      ahi.74 = ahi;
      if (ahi.74 == 0) goto <D.9498>; else goto <D.9499>;
      <D.9498>:
      *pchi = 0;
      D.9500 = *pchi;
      *pclo = D.9500;
      D.9493 = 1;
      return D.9493;
      <D.9499>:
      <D.9496>:
      ahi.74 = ahi;
      if (ahi.74 == 0) goto <D.9501>; else goto <D.9502>;
      <D.9501>:
      ami.73 = ami;
      ahi = ami.73;
      ami = 0;
      ashift = 64;
      goto <D.8748>;
      <D.8747>:
      ahi.74 = ahi;
      ahi.75 = ahi.74 << 1;
      ahi = ahi.75;
      ashift = ashift + 1;
      <D.8748>:
      ahi.74 = ahi;
      ahi.76 = (signed long) ahi.74;
      if (ahi.76 >= 0) goto <D.8747>; else goto <D.8749>;
      <D.8749>:
      goto <D.9505>;
      <D.9502>:
      ashift = 0;
      goto <D.8751>;
      <D.8750>:
      lshift128 (&ami, &ahi);
      ashift = ashift + 1;
      <D.8751>:
      ahi.74 = ahi;
      ahi.76 = (signed long) ahi.74;
      if (ahi.76 >= 0) goto <D.8750>; else goto <D.8752>;
      <D.8752>:
      <D.9505>:
      if (bhi == 0) goto <D.9506>; else goto <D.9507>;
      <D.9506>:
      if (bmi == 0) goto <D.9508>; else goto <D.9509>;
      <D.9508>:
      {
        guint32 hi_shift;

        bhi = blo;
        bmi = 0;
        blo = 0;
        D.9510 = (long unsigned int) bhi;
        D.9511 = my_g_bit_nth_msf (D.9510);
        D.9512 = 31 - D.9511;
        hi_shift = (guint32) D.9512;
        bhi = bhi << hi_shift;
        D.9513 = hi_shift + 64;
        bshift = (int) D.9513;
      }
      goto <D.9514>;
      <D.9509>:
      bhi = bmi;
      bmi = blo;
      blo = 0;
      bshift = 32;
      goto <D.8755>;
      <D.8754>:
      bhi = bhi << 1;
      D.9515 = bmi >> 31;
      bhi = D.9515 | bhi;
      bmi = bmi << 1;
      bshift = bshift + 1;
      <D.8755>:
      bhi.77 = (signed int) bhi;
      if (bhi.77 >= 0) goto <D.8754>; else goto <D.8756>;
      <D.8756>:
      <D.9514>:
      goto <D.9517>;
      <D.9507>:
      bshift = 0;
      goto <D.8758>;
      <D.8757>:
      bhi = bhi << 1;
      D.9515 = bmi >> 31;
      bhi = D.9515 | bhi;
      bmi = bmi << 1;
      D.9518 = blo >> 31;
      bmi = D.9518 | bmi;
      blo = blo << 1;
      bshift = bshift + 1;
      <D.8758>:
      bhi.77 = (signed int) bhi;
      if (bhi.77 >= 0) goto <D.8757>; else goto <D.8759>;
      <D.8759>:
      <D.9517>:
      D.9519 = (long unsigned int) bhi;
      D.9520 = D.9519 << 32;
      D.9521 = (long unsigned int) bmi;
      thi = D.9520 | D.9521;
      D.9522 = (long unsigned int) blo;
      tmi = D.9522 << 32;
      tlo = 0;
      ahi.74 = ahi;
      if (ahi.74 > thi) goto <D.9523>; else goto <D.9526>;
      <D.9526>:
      ahi.74 = ahi;
      if (ahi.74 == thi) goto <D.9527>; else goto <D.9524>;
      <D.9527>:
      ami.73 = ami;
      if (ami.73 >= tmi) goto <D.9523>; else goto <D.9524>;
      <D.9523>:
      alo.78 = alo;
      ami.73 = ami;
      ahi.74 = ahi;
      sub192 (alo.78, ami.73, ahi.74, tlo, tmi, thi, &alo, &ami, &ahi);
      extraBit = 1;
      goto <D.9525>;
      <D.9524>:
      extraBit = 0;
      <D.9525>:
      alo.78 = alo;
      ami.73 = ami;
      ahi.74 = ahi;
      div192by96to128 (alo.78, ami.73, ahi.74, blo, bmi, bhi, pclo, pchi);
      D.9529 = ashift + 128;
      texp = D.9529 - bshift;
      if (extraBit != 0) goto <D.9530>; else goto <D.9531>;
      <D.9530>:
      rshift128 (pclo, pchi);
      D.9500 = *pchi;
      D.9532 = D.9500 + 9223372036854775808;
      *pchi = D.9532;
      texp = texp + -1;
      <D.9531>:
      goto <D.8761>;
      <D.8760>:
      rshift128 (pclo, pchi);
      texp = texp + -1;
      <D.8761>:
      if (texp > 0) goto <D.9533>; else goto <D.8762>;
      <D.9533>:
      D.9534 = *pclo;
      D.9535 = D.9534 & 1;
      if (D.9535 == 0) goto <D.8760>; else goto <D.8762>;
      <D.8762>:
      *pExp = texp;
      D.9493 = 0;
      return D.9493;
    }
  finally
    {
      alo = {CLOBBER};
      ami = {CLOBBER};
      ahi = {CLOBBER};
    }
}


sub192 (guint64 alo, guint64 ami, guint64 ahi, guint64 blo, guint64 bmi, guint64 bhi, guint64 * pclo, guint64 * pcmi, guint64 * pchi)
{
  guint64 clo;
  guint64 cmi;
  guint64 chi;

  clo = alo - blo;
  cmi = ami - bmi;
  chi = ahi - bhi;
  if (alo < blo) goto <D.9538>; else goto <D.9539>;
  <D.9538>:
  if (cmi == 0) goto <D.9540>; else goto <D.9541>;
  <D.9540>:
  chi = chi + 18446744073709551615;
  <D.9541>:
  cmi = cmi + 18446744073709551615;
  <D.9539>:
  if (ami < bmi) goto <D.9542>; else goto <D.9543>;
  <D.9542>:
  chi = chi + 18446744073709551615;
  <D.9543>:
  *pclo = clo;
  *pcmi = cmi;
  *pchi = chi;
}


div192by96to128 (guint64 alo, guint64 ami, guint64 ahi, guint32 blo, guint32 bmi, guint32 bhi, guint64 * pclo, guint64 * pchi)
{
  long unsigned int rhi.79;
  long unsigned int rhi.85;
  long unsigned int rmi.80;
  long unsigned int D.9547;
  long unsigned int rhi.81;
  long unsigned int D.9549;
  long unsigned int rlo.82;
  long unsigned int D.9551;
  long unsigned int rmi.83;
  long unsigned int rlo.84;
  long unsigned int D.9554;
  long unsigned int D.9555;
  unsigned int D.9556;
  long unsigned int D.9557;
  long unsigned int D.9558;
  long unsigned int D.9559;
  long unsigned int D.9563;
  long unsigned int D.9564;
  long unsigned int D.9565;
  guint64 rlo;
  guint64 rmi;
  guint64 rhi;
  guint32 h;
  guint32 c;

  try
    {
      rlo = alo;
      rmi = ami;
      rhi = ahi;
      h = div192by96to32withRest (&rlo, &rmi, &rhi, blo, bmi, bhi);
      rhi.79 = rhi;
      rhi.85 = rhi.79 << 32;
      rmi.80 = rmi;
      D.9547 = rmi.80 >> 32;
      rhi.81 = rhi.85 | D.9547;
      rhi = rhi.81;
      rmi.80 = rmi;
      D.9549 = rmi.80 << 32;
      rlo.82 = rlo;
      D.9551 = rlo.82 >> 32;
      rmi.83 = D.9549 | D.9551;
      rmi = rmi.83;
      rlo.82 = rlo;
      rlo.84 = rlo.82 << 32;
      rlo = rlo.84;
      D.9554 = (long unsigned int) h;
      D.9555 = D.9554 << 32;
      D.9556 = div192by96to32withRest (&rlo, &rmi, &rhi, blo, bmi, bhi);
      D.9557 = (long unsigned int) D.9556;
      D.9558 = D.9555 | D.9557;
      *pchi = D.9558;
      rhi.79 = rhi;
      rhi.85 = rhi.79 << 32;
      rmi.80 = rmi;
      D.9547 = rmi.80 >> 32;
      rhi.81 = rhi.85 | D.9547;
      rhi = rhi.81;
      rmi.80 = rmi;
      D.9549 = rmi.80 << 32;
      rlo.82 = rlo;
      D.9551 = rlo.82 >> 32;
      rmi.83 = D.9549 | D.9551;
      rmi = rmi.83;
      rlo.82 = rlo;
      rlo.84 = rlo.82 << 32;
      rlo = rlo.84;
      h = div192by96to32withRest (&rlo, &rmi, &rhi, blo, bmi, bhi);
      D.9559 = (long unsigned int) bhi;
      rhi.79 = rhi;
      if (D.9559 <= rhi.79) goto <D.9560>; else goto <D.9561>;
      <D.9560>:
      c = 4294967295;
      goto <D.9562>;
      <D.9561>:
      rhi.79 = rhi;
      rhi.85 = rhi.79 << 32;
      rhi = rhi.85;
      rhi.79 = rhi;
      D.9559 = (long unsigned int) bhi;
      D.9563 = rhi.79 / D.9559;
      c = (guint32) D.9563;
      <D.9562>:
      D.9554 = (long unsigned int) h;
      D.9555 = D.9554 << 32;
      D.9564 = (long unsigned int) c;
      D.9565 = D.9555 | D.9564;
      *pclo = D.9565;
    }
  finally
    {
      rlo = {CLOBBER};
      rmi = {CLOBBER};
      rhi = {CLOBBER};
    }
}


div192by96to32withRest (guint64 * palo, guint64 * pami, guint64 * pahi, guint32 blo, guint32 bmi, guint32 bhi)
{
  long unsigned int rlo.86;
  long unsigned int rmi.87;
  long unsigned int rhi.88;
  long unsigned int D.9569;
  long unsigned int D.9570;
  long unsigned int rhi.89;
  long unsigned int D.9575;
  long unsigned int D.9576;
  long unsigned int rlo.90;
  long unsigned int rmi.91;
  long unsigned int tlo.92;
  long unsigned int thi.93;
  long unsigned int D.9581;
  long unsigned int D.9582;
  long unsigned int D.9583;
  long unsigned int D.9584;
  long int rhi.94;
  guint32 D.9586;
  guint64 rlo;
  guint64 rmi;
  guint64 rhi;
  guint64 tlo;
  guint64 thi;
  guint32 c;

  try
    {
      rlo.86 = *palo;
      rlo = rlo.86;
      rmi.87 = *pami;
      rmi = rmi.87;
      rhi.88 = *pahi;
      rhi = rhi.88;
      D.9569 = (long unsigned int) bhi;
      D.9570 = D.9569 << 32;
      rhi.89 = rhi;
      if (D.9570 <= rhi.89) goto <D.9572>; else goto <D.9573>;
      <D.9572>:
      c = 4294967295;
      goto <D.9574>;
      <D.9573>:
      rhi.89 = rhi;
      D.9575 = (long unsigned int) bhi;
      D.9576 = rhi.89 / D.9575;
      c = (guint32) D.9576;
      <D.9574>:
      mult96by32to128 (blo, bmi, bhi, c, &tlo, &thi);
      rlo.90 = rlo;
      rmi.91 = rmi;
      rhi.89 = rhi;
      tlo.92 = tlo;
      thi.93 = thi;
      sub192 (rlo.90, rmi.91, rhi.89, 0, tlo.92, thi.93, &rlo, &rmi, &rhi);
      goto <D.8434>;
      <D.8433>:
      c = c + 4294967295;
      rlo.90 = rlo;
      rmi.91 = rmi;
      rhi.89 = rhi;
      D.9581 = (long unsigned int) bmi;
      D.9582 = D.9581 << 32;
      D.9583 = (long unsigned int) blo;
      D.9584 = D.9582 | D.9583;
      D.9575 = (long unsigned int) bhi;
      add192 (rlo.90, rmi.91, rhi.89, 0, D.9584, D.9575, &rlo, &rmi, &rhi);
      <D.8434>:
      rhi.89 = rhi;
      rhi.94 = (long int) rhi.89;
      if (rhi.94 < 0) goto <D.8433>; else goto <D.8435>;
      <D.8435>:
      rlo.90 = rlo;
      *palo = rlo.90;
      rmi.91 = rmi;
      *pami = rmi.91;
      rhi.89 = rhi;
      *pahi = rhi.89;
      D.9586 = c;
      return D.9586;
    }
  finally
    {
      rlo = {CLOBBER};
      rmi = {CLOBBER};
      rhi = {CLOBBER};
      tlo = {CLOBBER};
      thi = {CLOBBER};
    }
}


mult96by32to128 (guint32 alo, guint32 ami, guint32 ahi, guint32 factor, guint64 * pclo, guint64 * pchi)
{
  long unsigned int D.9589;
  long unsigned int D.9590;
  long unsigned int D.9591;
  long unsigned int D.9592;
  long unsigned int D.9593;
  long unsigned int D.9594;
  long unsigned int D.9595;
  long unsigned int D.9596;
  long unsigned int D.9597;
  long unsigned int D.9598;
  guint64 a;
  guint32 h0;
  guint32 h1;

  D.9589 = (long unsigned int) alo;
  D.9590 = (long unsigned int) factor;
  a = D.9589 * D.9590;
  h0 = (guint32) a;
  a = a >> 32;
  D.9591 = (long unsigned int) ami;
  D.9590 = (long unsigned int) factor;
  D.9592 = D.9591 * D.9590;
  a = D.9592 + a;
  h1 = (guint32) a;
  a = a >> 32;
  D.9593 = (long unsigned int) ahi;
  D.9590 = (long unsigned int) factor;
  D.9594 = D.9593 * D.9590;
  a = D.9594 + a;
  D.9595 = (long unsigned int) h1;
  D.9596 = D.9595 << 32;
  D.9597 = (long unsigned int) h0;
  D.9598 = D.9596 | D.9597;
  *pclo = D.9598;
  *pchi = a;
}


add192 (guint64 alo, guint64 ami, guint64 ahi, guint64 blo, guint64 bmi, guint64 bhi, guint64 * pclo, guint64 * pcmi, guint64 * pchi)
{
  alo = alo + blo;
  if (alo < blo) goto <D.9599>; else goto <D.9600>;
  <D.9599>:
  ami = ami + 1;
  if (ami == 0) goto <D.9601>; else goto <D.9602>;
  <D.9601>:
  ahi = ahi + 1;
  <D.9602>:
  <D.9600>:
  ami = ami + bmi;
  if (ami < bmi) goto <D.9603>; else goto <D.9604>;
  <D.9603>:
  ahi = ahi + 1;
  <D.9604>:
  ahi = ahi + bhi;
  *pclo = alo;
  *pcmi = ami;
  *pchi = ahi;
}


__attribute__((visibility ("hidden")))
mono_decimalIntDiv (struct decimal_repr * pC, struct decimal_repr * pA, struct decimal_repr * pB)
{
  gint32 D.9609;
  unsigned char D.9610;
  int D.9611;
  unsigned char D.9612;
  int D.9613;
  int scale.95;
  int texp.96;
  long unsigned int clo.97;
  long unsigned int chi.98;
  int scale.99;
  <unnamed-unsigned:1> D.9621;
  int D.9622;
  guint64 clo;
  guint64 chi;
  int scale;
  int texp;
  int rc;

  try
    {
      rc = decimalDivSub (pA, pB, &clo, &chi, &texp);
      if (rc != 0) goto <D.9605>; else goto <D.9606>;
      <D.9605>:
      if (rc == 1) goto <D.9607>; else goto <D.9608>;
      <D.9607>:
      rc = 0;
      <D.9608>:
      D.9609 = rc;
      return D.9609;
      <D.9606>:
      D.9610 = pA->u.signscale.scale;
      D.9611 = (int) D.9610;
      D.9612 = pB->u.signscale.scale;
      D.9613 = (int) D.9612;
      scale.95 = D.9611 - D.9613;
      scale = scale.95;
      texp.96 = texp;
      rc = rescale128 (&clo, &chi, &scale, texp.96, 0, 0, 0);
      if (rc != 0) goto <D.9616>; else goto <D.9617>;
      <D.9616>:
      D.9609 = rc;
      return D.9609;
      <D.9617>:
      clo.97 = clo;
      chi.98 = chi;
      scale.99 = scale;
      D.9621 = pA->u.signscale.sign;
      D.9622 = (int) D.9621;
      D.9609 = pack128toDecimal (pC, clo.97, chi.98, scale.99, D.9622);
      return D.9609;
    }
  finally
    {
      clo = {CLOBBER};
      chi = {CLOBBER};
      scale = {CLOBBER};
      texp = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_decimalCompare (struct decimal_repr * pA, struct decimal_repr * pB)
{
  int iftmp.100;
  unsigned int D.9626;
  unsigned int D.9627;
  unsigned int D.9631;
  unsigned int D.9632;
  signed int D.9633;
  gint32 D.9636;
  gint32 iftmp.101;
  int D.9641;
  int D.9643;
  <unnamed-unsigned:1> D.9648;
  unsigned char D.9649;
  unsigned char D.9650;
  <unnamed-unsigned:1> D.9651;
  int D.9652;
  gint32 iftmp.102;
  unsigned int D.9656;
  unsigned int D.9657;
  int log2a;
  int log2b;
  int delta;
  int sign;
  struct decimal_repr aa;

  try
    {
      D.9626 = BIT_FIELD_REF <MEM[(void *)pA], 32, 0>;
      D.9627 = D.9626 & 2147483648;
      if (D.9627 != 0) goto <D.9628>; else goto <D.9629>;
      <D.9628>:
      iftmp.100 = -1;
      goto <D.9630>;
      <D.9629>:
      iftmp.100 = 1;
      <D.9630>:
      sign = iftmp.100;
      D.9626 = BIT_FIELD_REF <MEM[(void *)pA], 32, 0>;
      D.9631 = BIT_FIELD_REF <MEM[(void *)pB], 32, 0>;
      D.9632 = D.9626 ^ D.9631;
      D.9633 = (signed int) D.9632;
      if (D.9633 < 0) goto <D.9634>; else goto <D.9635>;
      <D.9634>:
      D.9641 = decimalIsZero (pA);
      if (D.9641 == 0) goto <D.9638>; else goto <D.9642>;
      <D.9642>:
      D.9643 = decimalIsZero (pB);
      if (D.9643 == 0) goto <D.9638>; else goto <D.9639>;
      <D.9638>:
      iftmp.101 = sign;
      goto <D.9640>;
      <D.9639>:
      iftmp.101 = 0;
      <D.9640>:
      D.9636 = iftmp.101;
      return D.9636;
      <D.9635>:
      log2a = decimalLog2 (pA);
      log2b = decimalLog2 (pB);
      delta = log2a - log2b;
      if (delta < -1) goto <D.9644>; else goto <D.9645>;
      <D.9644>:
      D.9636 = -sign;
      return D.9636;
      <D.9645>:
      if (delta > 1) goto <D.9646>; else goto <D.9647>;
      <D.9646>:
      D.9636 = sign;
      return D.9636;
      <D.9647>:
      memcpy (&aa, pA, 16);
      D.9648 = aa.u.signscale.sign;
      D.9649 = (unsigned char) D.9648;
      D.9650 = 1 - D.9649;
      D.9651 = (<unnamed-unsigned:1>) D.9650;
      aa.u.signscale.sign = D.9651;
      mono_decimalIncr (&aa, pB);
      D.9652 = decimalIsZero (&aa);
      if (D.9652 != 0) goto <D.9653>; else goto <D.9654>;
      <D.9653>:
      D.9636 = 0;
      return D.9636;
      <D.9654>:
      D.9656 = BIT_FIELD_REF <MEM[(void *)&aa], 32, 0>;
      D.9657 = D.9656 & 2147483648;
      if (D.9657 != 0) goto <D.9658>; else goto <D.9659>;
      <D.9658>:
      iftmp.102 = 1;
      goto <D.9660>;
      <D.9659>:
      iftmp.102 = -1;
      <D.9660>:
      D.9636 = iftmp.102;
      return D.9636;
    }
  finally
    {
      aa = {CLOBBER};
    }
}


decimalLog2 (struct decimal_repr * pA)
{
  unsigned char D.9663;
  unsigned int D.9664;
  int D.9667;
  unsigned int D.9669;
  int D.9672;
  unsigned int D.9674;
  int D.9677;
  int D.9678;
  int D.9679;
  int tlog2;
  int scale;

  D.9663 = pA->u.signscale.scale;
  scale = (int) D.9663;
  D.9664 = pA->hi32;
  if (D.9664 != 0) goto <D.9665>; else goto <D.9666>;
  <D.9665>:
  D.9664 = pA->hi32;
  D.9667 = log2_32 (D.9664);
  tlog2 = D.9667 + 64;
  goto <D.9668>;
  <D.9666>:
  D.9669 = pA->mid32;
  if (D.9669 != 0) goto <D.9670>; else goto <D.9671>;
  <D.9670>:
  D.9669 = pA->mid32;
  D.9672 = log2_32 (D.9669);
  tlog2 = D.9672 + 32;
  goto <D.9673>;
  <D.9671>:
  D.9674 = pA->lo32;
  tlog2 = log2_32 (D.9674);
  <D.9673>:
  <D.9668>:
  if (tlog2 != -1000) goto <D.9675>; else goto <D.9676>;
  <D.9675>:
  D.9677 = scale * -33219;
  D.9678 = D.9677 / 10000;
  tlog2 = D.9678 + tlog2;
  <D.9676>:
  D.9679 = tlog2;
  return D.9679;
}


log2_32 (guint32 a)
{
  int D.9683;
  long unsigned int D.9684;
  int D.9685;

  if (a == 0) goto <D.9681>; else goto <D.9682>;
  <D.9681>:
  D.9683 = -1000;
  return D.9683;
  <D.9682>:
  D.9684 = (long unsigned int) a;
  D.9685 = my_g_bit_nth_msf (D.9684);
  D.9683 = D.9685 + 1;
  return D.9683;
}


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

  D.9688 = __builtin_object_size (__dest, 0);
  D.9687 = __builtin___memcpy_chk (__dest, __src, __len, D.9688);
  return D.9687;
}


decimalIsZero (struct decimal_repr * pA)
{
  int D.9690;
  int iftmp.103;
  unsigned int D.9694;
  unsigned int D.9696;
  unsigned int D.9698;

  D.9694 = pA->lo32;
  if (D.9694 == 0) goto <D.9695>; else goto <D.9692>;
  <D.9695>:
  D.9696 = pA->mid32;
  if (D.9696 == 0) goto <D.9697>; else goto <D.9692>;
  <D.9697>:
  D.9698 = pA->hi32;
  if (D.9698 == 0) goto <D.9699>; else goto <D.9692>;
  <D.9699>:
  iftmp.103 = 1;
  goto <D.9693>;
  <D.9692>:
  iftmp.103 = 0;
  <D.9693>:
  D.9690 = iftmp.103;
  return D.9690;
}


__attribute__((visibility ("hidden")))
mono_decimal2double (struct decimal_repr * pA)
{
  unsigned int D.9701;
  long unsigned int D.9702;
  long unsigned int D.9703;
  unsigned int D.9704;
  long unsigned int D.9705;
  long unsigned int ahi.104;
  unsigned int D.9707;
  long unsigned int D.9708;
  long unsigned int alo.105;
  long unsigned int ahi.106;
  long unsigned int alo.107;
  double D.9716;
  unsigned char D.9717;
  signed long ahi.108;
  long unsigned int D.9719;
  int D.9722;
  int D.9723;
  unsigned int D.9726;
  unsigned int D.9727;
  unsigned int log5.109;
  unsigned int D.9729;
  unsigned int D.9733;
  unsigned int D.9734;
  long unsigned int ahi.110;
  long unsigned int ahi.111;
  unsigned int D.9740;
  long unsigned int ahi.112;
  long long unsigned int D.9744;
  <unnamed-unsigned:1> D.9745;
  int D.9746;
  int D.9747;
  double d;
  guint64 alo;
  guint64 ahi;
  guint64 mantisse;
  guint32 overhang;
  guint32 factor;
  guint32 roundBits;
  int scale;
  int texp;
  int log5;
  int i;

  try
    {
      D.9701 = pA->hi32;
      D.9702 = (long unsigned int) D.9701;
      D.9703 = D.9702 << 32;
      D.9704 = pA->mid32;
      D.9705 = (long unsigned int) D.9704;
      ahi.104 = D.9703 | D.9705;
      ahi = ahi.104;
      D.9707 = pA->lo32;
      D.9708 = (long unsigned int) D.9707;
      alo.105 = D.9708 << 32;
      alo = alo.105;
      ahi.106 = ahi;
      if (ahi.106 == 0) goto <D.9711>; else goto <D.9712>;
      <D.9711>:
      alo.107 = alo;
      if (alo.107 == 0) goto <D.9714>; else goto <D.9715>;
      <D.9714>:
      D.9716 = 0.0;
      return D.9716;
      <D.9715>:
      <D.9712>:
      texp = 0;
      D.9717 = pA->u.signscale.scale;
      scale = (int) D.9717;
      goto <D.8825>;
      <D.8824>:
      goto <D.8822>;
      <D.8821>:
      lshift128 (&alo, &ahi);
      texp = texp + 1;
      <D.8822>:
      ahi.106 = ahi;
      ahi.108 = (signed long) ahi.106;
      if (ahi.108 >= 0) goto <D.8821>; else goto <D.8823>;
      <D.8823>:
      ahi.106 = ahi;
      D.9719 = ahi.106 >> 32;
      overhang = (guint32) D.9719;
      if (overhang > 4) goto <D.9720>; else goto <D.9721>;
      <D.9720>:
      D.9722 = log2_32 (overhang);
      D.9723 = D.9722 * 1000;
      log5 = D.9723 / 2322;
      if (log5 <= 8) goto <D.9724>; else goto <D.9725>;
      <D.9724>:
      D.9726 = constantsDecadeInt32Factors[log5];
      factor = D.9726 >> log5;
      D.9727 = overhang / factor;
      log5.109 = (unsigned int) log5;
      D.9729 = D.9727 + log5.109;
      i = (int) D.9729;
      goto <D.9730>;
      <D.9725>:
      i = 9;
      <D.9730>:
      if (i > scale) goto <D.9731>; else goto <D.9732>;
      <D.9731>:
      i = scale;
      <D.9732>:
      D.9733 = constantsDecadeInt32Factors[i];
      factor = D.9733 >> i;
      div128by32 (&alo, &ahi, factor, 0B);
      scale = scale - i;
      texp = texp + i;
      <D.9721>:
      <D.8825>:
      if (scale > 0) goto <D.8824>; else goto <D.8826>;
      <D.8826>:
      goto <D.8828>;
      <D.8827>:
      lshift128 (&alo, &ahi);
      texp = texp + 1;
      <D.8828>:
      ahi.106 = ahi;
      ahi.108 = (signed long) ahi.106;
      if (ahi.108 >= 0) goto <D.8827>; else goto <D.8829>;
      <D.8829>:
      ahi.106 = ahi;
      D.9734 = (unsigned int) ahi.106;
      roundBits = D.9734 & 2047;
      ahi.106 = ahi;
      ahi.110 = ahi.106 + 1024;
      ahi = ahi.110;
      ahi.106 = ahi;
      ahi.108 = (signed long) ahi.106;
      if (ahi.108 >= 0) goto <D.9736>; else goto <D.9737>;
      <D.9736>:
      ahi.106 = ahi;
      ahi.111 = ahi.106 >> 1;
      ahi = ahi.111;
      texp = texp + -1;
      goto <D.9739>;
      <D.9737>:
      D.9740 = roundBits & 1024;
      if (D.9740 == 0) goto <D.9741>; else goto <D.9742>;
      <D.9741>:
      ahi.106 = ahi;
      ahi.112 = ahi.106 & 18446744073709551614;
      ahi = ahi.112;
      <D.9742>:
      <D.9739>:
      ahi.106 = ahi;
      D.9744 = ahi.106 >> 11;
      mantisse = D.9744 & 4503599627370495;
      D.9745 = pA->u.signscale.sign;
      D.9746 = (int) D.9745;
      D.9747 = 95 - texp;
      buildIEEE754Double (&d, D.9746, D.9747, mantisse);
      D.9716 = d;
      return D.9716;
    }
  finally
    {
      d = {CLOBBER};
      alo = {CLOBBER};
      ahi = {CLOBBER};
    }
}


buildIEEE754Double (double * pd, int sign, int texp, guint64 mantisse)
{
  long unsigned int D.9750;
  long unsigned int D.9751;
  int D.9752;
  long unsigned int D.9753;
  long unsigned int D.9754;
  long unsigned int D.9755;
  long unsigned int D.9756;
  long unsigned int D.9757;
  guint64 * p;

  p = pd;
  D.9750 = (long unsigned int) sign;
  D.9751 = D.9750 << 63;
  D.9752 = texp + 1023;
  D.9753 = (long unsigned int) D.9752;
  D.9754 = D.9753 << 52;
  D.9755 = D.9754 & 9218868437227405312;
  D.9756 = D.9751 | D.9755;
  D.9757 = D.9756 | mantisse;
  *p = D.9757;
}


__attribute__((visibility ("hidden")))
mono_decimalSetExponent (struct decimal_repr * pA, gint32 texp)
{
  unsigned char D.9758;
  int scale.113;
  int scale.114;
  int scale.115;
  unsigned int scale.116;
  unsigned int D.9765;
  long unsigned int D.9766;
  long unsigned int D.9767;
  unsigned int D.9768;
  long unsigned int D.9769;
  long unsigned int alo.117;
  unsigned int D.9771;
  long unsigned int ahi.118;
  gint32 D.9775;
  long unsigned int alo.119;
  long unsigned int ahi.120;
  <unnamed-unsigned:1> D.9778;
  int D.9779;
  unsigned char D.9780;
  guint64 alo;
  guint64 ahi;
  int rc;
  int scale;

  try
    {
      D.9758 = pA->u.signscale.scale;
      scale.113 = (int) D.9758;
      scale = scale.113;
      scale.114 = scale;
      scale.115 = scale.114 - texp;
      scale = scale.115;
      scale.114 = scale;
      scale.116 = (unsigned int) scale.114;
      if (scale.116 > 28) goto <D.9763>; else goto <D.9764>;
      <D.9763>:
      D.9765 = pA->mid32;
      D.9766 = (long unsigned int) D.9765;
      D.9767 = D.9766 << 32;
      D.9768 = pA->lo32;
      D.9769 = (long unsigned int) D.9768;
      alo.117 = D.9767 | D.9769;
      alo = alo.117;
      D.9771 = pA->hi32;
      ahi.118 = (long unsigned int) D.9771;
      ahi = ahi.118;
      rc = rescale128 (&alo, &ahi, &scale, 0, 0, 28, 1);
      if (rc != 0) goto <D.9773>; else goto <D.9774>;
      <D.9773>:
      D.9775 = rc;
      return D.9775;
      <D.9774>:
      alo.119 = alo;
      ahi.120 = ahi;
      scale.114 = scale;
      D.9778 = pA->u.signscale.sign;
      D.9779 = (int) D.9778;
      D.9775 = pack128toDecimal (pA, alo.119, ahi.120, scale.114, D.9779);
      return D.9775;
      <D.9764>:
      scale.114 = scale;
      D.9780 = (unsigned char) scale.114;
      pA->u.signscale.scale = D.9780;
      D.9775 = 0;
      return D.9775;
    }
  finally
    {
      alo = {CLOBBER};
      ahi = {CLOBBER};
      scale = {CLOBBER};
    }
}