#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
struct lconv {
  char *mon_grouping;
  char *mon_decimal_point;
  char *decimal_point;
  char *mon_thousands_sep;
  char *thousands_sep;
  int int_frac_digits;
  int frac_digits;
};

/* Variables and functions */
int CHAR_MAX;
int asprintf(char **, char *, int, int, double);
int /*<<< orphan*/ free(char *);
scalar_t__ get_groups(int, char *);
struct lconv *localeconv();
char *malloc(size_t);
int /*<<< orphan*/ memcpy(char *, char *, size_t);
int /*<<< orphan*/ memmove(char *, char *, size_t);
int /*<<< orphan*/ memset(char *, int, size_t);
char *__format_grouped_double(double value, int *flags, int left_prec,
                              int right_prec, int pad_char) {
  char *rslt;
  char *avalue;
  int avalue_size;
  size_t bufsize;
  char *bufend;
  int padded;
  struct lconv *lc = localeconv();
  char *grouping;
  char decimal_point;
  char thousands_sep;
  int groups = 0;
  grouping = lc->mon_grouping;
  decimal_point = *lc->mon_decimal_point;
  if (decimal_point == '\0')
    decimal_point = *lc->decimal_point;
  thousands_sep = *lc->mon_thousands_sep;
  if (thousands_sep == '\0')
    thousands_sep = *lc->thousands_sep;
  if (left_prec == -1)
    left_prec = 0;
  if (right_prec == -1) {
    if (*flags & 0x40)
      right_prec = lc->int_frac_digits;
    else
      right_prec = lc->frac_digits;
    if (right_prec == CHAR_MAX)
      right_prec = 2;
  }
  if (*flags & 0x01)
    left_prec += get_groups(left_prec, grouping);
  avalue_size =
      asprintf(&avalue, "%*.*f", left_prec + right_prec + 1, right_prec, value);
  if (avalue_size < 0)
    return (NULL);
  bufsize = avalue_size * 2 + 1;
  rslt = malloc(bufsize);
  if (rslt == NULL) {
    free(avalue);
    return (NULL);
  }
  memset(rslt, 0, bufsize);
  bufend = rslt + bufsize - 1;
  padded = 0;
  while (avalue[padded] == ' ') {
    padded++;
    avalue_size--;
  }
  if (right_prec > 0) {
    bufend -= right_prec;
    memcpy(bufend, avalue + avalue_size + padded - right_prec,
           (size_t)right_prec);
    *--bufend = decimal_point;
    avalue_size -= (right_prec + 1);
  }
  if ((*flags & 0x01) && thousands_sep != '\0' &&
      (unsigned char)*grouping != ((unsigned char)CHAR_MAX) && *grouping > 0) {
    while (avalue_size > (int)*grouping) {
      do {
        int i = *grouping;
        while (i-- > 0) {
          avalue_size--;
          *--bufend = *(avalue + avalue_size + padded);
        }
      } while (0);
      do {
        *--bufend = thousands_sep;
        groups++;
      } while (0);
      grouping++;
      if ((unsigned char)*grouping == ((unsigned char)CHAR_MAX))
        break;
      if (*grouping == 0) {
        grouping--;
        while (avalue_size > *grouping) {
          do {
            int i = *grouping;
            while (i-- > 0) {
              avalue_size--;
              *--bufend = *(avalue + avalue_size + padded);
            }
          } while (0);
          do {
            *--bufend = thousands_sep;
            groups++;
          } while (0);
        }
      }
    }
    if (avalue_size != 0)
      do {
        int i = avalue_size;
        while (i-- > 0) {
          avalue_size--;
          *--bufend = *(avalue + avalue_size + padded);
        }
      } while (0);
    padded -= groups;
  } else {
    bufend -= avalue_size;
    memcpy(bufend, avalue + padded, (size_t)avalue_size);
    if (right_prec == 0)
      padded--;
  }
  if (padded > 0) {
    bufend -= padded;
    memset(bufend, pad_char, (size_t)padded);
  }
  bufsize = bufsize - (bufend - rslt) + 1;
  memmove(rslt, bufend, bufsize);
  free(avalue);
  return (rslt);
}


x86 assembly (clang, -O0):
<__format_grouped_double>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movsd  %xmm0,-0x10(%rbp)
mov    %rdi,-0x18(%rbp)
mov    %esi,-0x1c(%rbp)
mov    %edx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    $0x0,%al
call   1040 <localeconv@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x60(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x68(%rbp)
mov    -0x60(%rbp),%rax
mov    0x8(%rax),%rax
mov    (%rax),%al
mov    %al,-0x69(%rbp)
movsbl -0x69(%rbp),%eax
cmp    $0x0,%eax
jne    11e1 <__format_grouped_double+0x61>
mov    -0x60(%rbp),%rax
mov    0x10(%rax),%rax
mov    (%rax),%al
mov    %al,-0x69(%rbp)
mov    -0x60(%rbp),%rax
mov    0x18(%rax),%rax
mov    (%rax),%al
mov    %al,-0x6a(%rbp)
movsbl -0x6a(%rbp),%eax
cmp    $0x0,%eax
jne    1208 <__format_grouped_double+0x88>
mov    -0x60(%rbp),%rax
mov    0x20(%rax),%rax
mov    (%rax),%al
mov    %al,-0x6a(%rbp)
cmpl   $0xffffffff,-0x1c(%rbp)
jne    1219 <__format_grouped_double+0x99>
movl   $0x0,-0x1c(%rbp)
cmpl   $0xffffffff,-0x20(%rbp)
jne    126c <__format_grouped_double+0xec>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
and    $0x40,%eax
cmp    $0x0,%eax
je     1244 <__format_grouped_double+0xc4>
mov    -0x60(%rbp),%rax
mov    0x28(%rax),%eax
mov    %eax,-0x20(%rbp)
jmp    124e <__format_grouped_double+0xce>
mov    -0x60(%rbp),%rax
mov    0x2c(%rax),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    0x2d90(%rip),%rcx
cmp    (%rcx),%eax
jne    1267 <__format_grouped_double+0xe7>
movl   $0x2,-0x20(%rbp)
jmp    126c <__format_grouped_double+0xec>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1297 <__format_grouped_double+0x117>
mov    -0x1c(%rbp),%edi
mov    -0x68(%rbp),%rsi
call   1050 <get_groups@plt>
mov    %rax,%rcx
movslq -0x1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%edx
add    -0x20(%rbp),%edx
add    $0x1,%edx
mov    -0x20(%rbp),%ecx
movsd  -0x10(%rbp),%xmm0
lea    -0x38(%rbp),%rdi
lea    0xd4d(%rip),%rsi
call   1090 <asprintf@plt>
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jge    12d2 <__format_grouped_double+0x152>
movq   $0x0,-0x8(%rbp)
jmp    16ba <__format_grouped_double+0x53a>
mov    -0x3c(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rdi
call   1080 <malloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    130f <__format_grouped_double+0x18f>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
movq   $0x0,-0x8(%rbp)
jmp    16ba <__format_grouped_double+0x53a>
mov    -0x30(%rbp),%rdi
mov    -0x48(%rbp),%rdx
xor    %esi,%esi
call   1060 <memset@plt>
mov    -0x30(%rbp),%rax
add    -0x48(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    1361 <__format_grouped_double+0x1e1>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1335 <__format_grouped_double+0x1b5>
cmpl   $0x0,-0x20(%rbp)
jle    13cf <__format_grouped_double+0x24f>
mov    -0x20(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x38(%rbp),%rsi
movslq -0x3c(%rbp),%rax
add    %rax,%rsi
movslq -0x54(%rbp),%rax
add    %rax,%rsi
movslq -0x20(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rsi
movslq -0x20(%rbp),%rdx
call   1070 <memcpy@plt>
mov    -0x69(%rbp),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,-0x1(%rax)
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
mov    -0x3c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1608 <__format_grouped_double+0x488>
movsbl -0x6a(%rbp),%eax
cmp    $0x0,%eax
je     1608 <__format_grouped_double+0x488>
mov    -0x68(%rbp),%rax
movzbl (%rax),%eax
mov    0x2bec(%rip),%rcx
mov    (%rcx),%ecx
movzbl %cl,%ecx
cmp    %ecx,%eax
je     1608 <__format_grouped_double+0x488>
mov    -0x68(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jle    1608 <__format_grouped_double+0x488>
jmp    141e <__format_grouped_double+0x29e>
mov    -0x3c(%rbp),%eax
mov    -0x68(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jle    1593 <__format_grouped_double+0x413>
jmp    1435 <__format_grouped_double+0x2b5>
mov    -0x68(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x74(%rbp)
cmp    $0x0,%eax
jle    1485 <__format_grouped_double+0x305>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
add    %rcx,%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,-0x1(%rax)
jmp    143f <__format_grouped_double+0x2bf>
jmp    148a <__format_grouped_double+0x30a>
jmp    148f <__format_grouped_double+0x30f>
mov    -0x6a(%rbp),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,-0x1(%rax)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
movzbl (%rax),%eax
mov    0x2b21(%rip),%rcx
mov    (%rcx),%ecx
movzbl %cl,%ecx
cmp    %ecx,%eax
jne    14d9 <__format_grouped_double+0x359>
jmp    1593 <__format_grouped_double+0x413>
mov    -0x68(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    158e <__format_grouped_double+0x40e>
mov    -0x68(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x68(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x68(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jle    1589 <__format_grouped_double+0x409>
jmp    150c <__format_grouped_double+0x38c>
mov    -0x68(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x78(%rbp)
cmp    $0x0,%eax
jle    155c <__format_grouped_double+0x3dc>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
add    %rcx,%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,-0x1(%rax)
jmp    1516 <__format_grouped_double+0x396>
jmp    1561 <__format_grouped_double+0x3e1>
jmp    1566 <__format_grouped_double+0x3e6>
mov    -0x6a(%rbp),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,-0x1(%rax)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    14f5 <__format_grouped_double+0x375>
jmp    158e <__format_grouped_double+0x40e>
jmp    141e <__format_grouped_double+0x29e>
cmpl   $0x0,-0x3c(%rbp)
je     15f8 <__format_grouped_double+0x478>
jmp    15a2 <__format_grouped_double+0x422>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x7c(%rbp)
cmp    $0x0,%eax
jle    15ee <__format_grouped_double+0x46e>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
add    %rcx,%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,-0x1(%rax)
jmp    15a8 <__format_grouped_double+0x428>
jmp    15f3 <__format_grouped_double+0x473>
jmp    15f8 <__format_grouped_double+0x478>
mov    -0x70(%rbp),%ecx
mov    -0x54(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x54(%rbp)
jmp    164e <__format_grouped_double+0x4ce>
mov    -0x3c(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x38(%rbp),%rsi
movslq -0x54(%rbp),%rax
add    %rax,%rsi
movslq -0x3c(%rbp),%rdx
call   1070 <memcpy@plt>
cmpl   $0x0,-0x20(%rbp)
jne    1649 <__format_grouped_double+0x4c9>
mov    -0x54(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x54(%rbp)
jmp    164e <__format_grouped_double+0x4ce>
cmpl   $0x0,-0x54(%rbp)
jle    167e <__format_grouped_double+0x4fe>
mov    -0x54(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x24(%rbp),%esi
movslq -0x54(%rbp),%rdx
call   1060 <memset@plt>
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x30(%rbp),%rdx
sub    %rdx,%rcx
sub    %rcx,%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x48(%rbp),%rdx
call   10a0 <memmove@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<__format_grouped_double>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %ecx,%r12d
mov    %edx,%r14d
mov    %esi,%ebp
mov    %rdi,%r13
movsd  %xmm0,0x10(%rsp)
xor    %eax,%eax
call   1040 <localeconv@plt>
mov    0x8(%rax),%rcx
mov    (%rcx),%dil
test   %dil,%dil
jne    11b9 <__format_grouped_double+0x39>
mov    0x10(%rax),%rcx
mov    (%rcx),%dil
mov    0x18(%rax),%rcx
mov    (%rcx),%r15b
test   %r15b,%r15b
jne    11cc <__format_grouped_double+0x4c>
mov    0x20(%rax),%rcx
mov    (%rcx),%r15b
xor    %ebx,%ebx
cmp    $0xffffffff,%ebp
cmovne %ebp,%ebx
mov    %r13,0x30(%rsp)
mov    0x0(%r13),%ecx
cmp    $0xffffffff,%r14d
jne    1202 <__format_grouped_double+0x82>
xor    %edx,%edx
test   $0x40,%cl
sete   %dl
mov    0x28(%rax,%rdx,4),%edx
mov    0x2df2(%rip),%rsi
cmp    (%rsi),%edx
mov    $0x2,%r14d
cmovne %edx,%r14d
mov    (%rax),%r13
test   $0x1,%cl
mov    %dil,0xf(%rsp)
je     121d <__format_grouped_double+0x9d>
mov    %ebx,%edi
mov    %r13,%rsi
call   1050 <get_groups@plt>
add    %ebx,%eax
mov    %eax,%ebx
movsd  0x10(%rsp),%xmm0
lea    (%r14,%rbx,1),%edx
add    $0x1,%edx
lea    0xdcf(%rip),%rsi
mov    %rsp,%rdi
mov    %r14d,%ecx
call   1090 <asprintf@plt>
test   %eax,%eax
js     14e7 <__format_grouped_double+0x367>
mov    %eax,%ebp
mov    %r13,0x28(%rsp)
mov    %r15d,%r13d
mov    %r12d,0x1c(%rsp)
lea    0x1(%rbp,%rbp,1),%eax
movslq %eax,%r15
mov    %r15,%rdi
call   1080 <malloc@plt>
xor    %r12d,%r12d
test   %rax,%rax
je     1543 <__format_grouped_double+0x3c3>
mov    %rax,%rbx
mov    %rax,%rdi
xor    %esi,%esi
mov    %r15,0x10(%rsp)
mov    %r15,%rdx
call   1060 <memset@plt>
mov    (%rsp),%rsi
cmpb   $0x20,(%rsi)
mov    %r13d,%r15d
mov    0x28(%rsp),%r13
jne    12b0 <__format_grouped_double+0x130>
xor    %r12d,%r12d
nopw   0x0(%rax,%rax,1)
cmpb   $0x20,0x1(%rsi,%r12,1)
lea    0x1(%r12),%r12
je     12a0 <__format_grouped_double+0x120>
sub    %r12d,%ebp
mov    %rbx,0x20(%rsp)
mov    0x10(%rsp),%rax
add    %rax,%rbx
add    $0xffffffffffffffff,%rbx
mov    %r12d,%r12d
test   %r14d,%r14d
jle    12f5 <__format_grouped_double+0x175>
mov    %r14d,%edx
sub    %rdx,%rbx
movslq %ebp,%rbp
add    %rbp,%rsi
add    %r12,%rsi
sub    %rdx,%rsi
mov    %rbx,%rdi
call   1070 <memcpy@plt>
mov    0xf(%rsp),%al
mov    %al,-0x1(%rbx)
add    $0xffffffffffffffff,%rbx
mov    %r14d,%eax
not    %eax
add    %eax,%ebp
mov    0x30(%rsp),%rax
testb  $0x1,(%rax)
je     14eb <__format_grouped_double+0x36b>
test   %r15b,%r15b
je     14eb <__format_grouped_double+0x36b>
mov    0x0(%r13),%al
test   %al,%al
jle    14eb <__format_grouped_double+0x36b>
mov    0x2cc9(%rip),%r8
cmp    (%r8),%al
je     14eb <__format_grouped_double+0x36b>
movzbl %al,%edx
xor    %r10d,%r10d
cmp    %edx,%ebp
jle    1560 <__format_grouped_double+0x3e0>
xor    %r10d,%r10d
jmp    1348 <__format_grouped_double+0x1c8>
nopl   0x0(%rax,%rax,1)
cmp    %edx,%ebp
jle    1560 <__format_grouped_double+0x3e0>
test   %edx,%edx
jle    13f2 <__format_grouped_double+0x272>
movslq %ebp,%rbp
lea    -0x1(%rdx),%r9d
mov    %edx,%edi
and    $0x3,%edi
je     1380 <__format_grouped_double+0x200>
xor    %ecx,%ecx
mov    (%rsp),%rsi
add    %r12,%rsi
movzbl -0x1(%rbp,%rsi,1),%eax
add    $0xffffffffffffffff,%rbp
mov    %al,-0x1(%rbx)
add    $0xffffffffffffffff,%rbx
add    $0x1,%ecx
cmp    %ecx,%edi
jne    1360 <__format_grouped_double+0x1e0>
sub    %ecx,%edx
cmp    $0x3,%r9d
jb     13f2 <__format_grouped_double+0x272>
lea    (%r12,%rbp,1),%rsi
movslq %edx,%rdi
add    $0xffffffffffffffff,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x1(%rdx,%rax,1),%eax
mov    %al,-0x1(%rbx,%rdx,1)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x2(%rdx,%rax,1),%eax
mov    %al,-0x2(%rbx,%rdx,1)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x3(%rdx,%rax,1),%eax
mov    %al,-0x3(%rbx,%rdx,1)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x4(%rdx,%rax,1),%eax
mov    %al,-0x4(%rbx,%rdx,1)
add    $0xfffffffffffffffc,%rdx
lea    (%rdx,%rdi,1),%eax
cmp    $0xfffffffe,%eax
jb     13a0 <__format_grouped_double+0x220>
add    %rdx,%rbp
add    %rdx,%rbx
mov    %r15b,-0x1(%rbx)
add    $0xffffffffffffffff,%rbx
add    $0x1,%r10d
movsbl 0x1(%r13),%edx
cmp    (%r8),%dl
je     1560 <__format_grouped_double+0x3e0>
test   %dl,%dl
je     142c <__format_grouped_double+0x2ac>
add    $0x1,%r13
jmp    1340 <__format_grouped_double+0x1c0>
nopl   0x0(%rax)
mov    %r15b,-0x1(%rbx)
add    $0xffffffffffffffff,%rbx
add    $0x1,%r10d
movsbl 0x0(%r13),%edx
cmp    %edx,%ebp
jle    1340 <__format_grouped_double+0x1c0>
test   %edx,%edx
jle    1420 <__format_grouped_double+0x2a0>
movslq %ebp,%rbp
lea    -0x1(%rdx),%esi
mov    %edx,%edi
and    $0x3,%edi
je     1470 <__format_grouped_double+0x2f0>
xor    %ecx,%ecx
nopl   0x0(%rax)
mov    (%rsp),%rax
add    %r12,%rax
movzbl -0x1(%rbp,%rax,1),%eax
add    $0xffffffffffffffff,%rbp
mov    %al,-0x1(%rbx)
add    $0xffffffffffffffff,%rbx
add    $0x1,%ecx
cmp    %ecx,%edi
jne    1450 <__format_grouped_double+0x2d0>
sub    %ecx,%edx
cmp    $0x3,%esi
jb     1420 <__format_grouped_double+0x2a0>
lea    (%r12,%rbp,1),%rsi
movslq %edx,%rdi
add    $0xffffffffffffffff,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x1(%rdx,%rax,1),%eax
mov    %al,-0x1(%rbx,%rdx,1)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x2(%rdx,%rax,1),%eax
mov    %al,-0x2(%rbx,%rdx,1)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x3(%rdx,%rax,1),%eax
mov    %al,-0x3(%rbx,%rdx,1)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x4(%rdx,%rax,1),%eax
mov    %al,-0x4(%rbx,%rdx,1)
add    $0xfffffffffffffffc,%rdx
lea    (%rdx,%rdi,1),%eax
cmp    $0xfffffffe,%eax
jb     1490 <__format_grouped_double+0x310>
add    %rdx,%rbp
add    %rdx,%rbx
jmp    1420 <__format_grouped_double+0x2a0>
xor    %ebx,%ebx
jmp    154e <__format_grouped_double+0x3ce>
movslq %ebp,%rdx
sub    %rdx,%rbx
mov    %r12,%rsi
add    (%rsp),%rsi
mov    %rbx,%rdi
call   1070 <memcpy@plt>
cmp    $0x1,%r14d
sbb    $0x0,%r12d
mov    0x10(%rsp),%r14
test   %r12d,%r12d
jle    1524 <__format_grouped_double+0x3a4>
mov    %r12d,%edx
sub    %rdx,%rbx
mov    %rbx,%rdi
mov    0x1c(%rsp),%esi
call   1060 <memset@plt>
mov    0x20(%rsp),%rdi
add    %rdi,%r14
sub    %rbx,%r14
add    $0x1,%r14
mov    %rbx,%rsi
mov    %rdi,%rbx
mov    %r14,%rdx
call   10a0 <memmove@plt>
jmp    1545 <__format_grouped_double+0x3c5>
xor    %ebx,%ebx
mov    (%rsp),%rdi
call   1030 <free@plt>
mov    %rbx,%rax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
test   %ebp,%ebp
jle    15a3 <__format_grouped_double+0x423>
mov    %ebp,%ecx
lea    -0x1(%rbp),%edx
and    $0x3,%ebp
je     15b0 <__format_grouped_double+0x430>
mov    0x10(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rsp),%rax
add    %r12,%rax
movzbl -0x1(%rcx,%rax,1),%eax
add    $0xffffffffffffffff,%rcx
mov    %al,-0x1(%rbx)
add    $0xffffffffffffffff,%rbx
add    $0xffffffff,%ebp
jne    1580 <__format_grouped_double+0x400>
cmp    $0x3,%edx
jae    15ba <__format_grouped_double+0x43a>
jmp    1612 <__format_grouped_double+0x492>
mov    0x10(%rsp),%r14
sub    %r10d,%r12d
jmp    150d <__format_grouped_double+0x38d>
mov    0x10(%rsp),%r14
cmp    $0x3,%edx
jb     1612 <__format_grouped_double+0x492>
lea    (%rcx,%r12,1),%rsi
xor    %edx,%edx
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x1(%rdx,%rax,1),%eax
mov    %al,-0x1(%rbx,%rdx,1)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x2(%rdx,%rax,1),%eax
mov    %al,-0x2(%rbx,%rdx,1)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x3(%rdx,%rax,1),%eax
mov    %al,-0x3(%rbx,%rdx,1)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x4(%rdx,%rax,1),%eax
mov    %al,-0x4(%rbx,%rdx,1)
add    $0xfffffffffffffffc,%rdx
lea    (%rcx,%rdx,1),%eax
add    $0x1,%eax
cmp    $0x1,%eax
jg     15c0 <__format_grouped_double+0x440>
add    %rdx,%rbx
sub    %r10d,%r12d
jmp    150d <__format_grouped_double+0x38d>

LLVM IR (-O0):
%struct.lconv = type { i8*, i8*, i8*, i8*, i8*, i32, i32 }
@CHAR_MAX = global i32 0
@.str = [6 x i8] c"%*.*f\00"
define i8* @__format_grouped_double(double %0, i32* %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca i8*
%7 = alloca double
%8 = alloca i32*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca i32
%15 = alloca i64
%16 = alloca i8*
%17 = alloca i32
%18 = alloca %struct.lconv*
%19 = alloca i8*
%20 = alloca i8
%21 = alloca i8
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
store double %0, double* %7
store i32* %1, i32** %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store i32 %4, i32* %11
%26 = call %struct.lconv* (...) @localeconv()
store %struct.lconv* %26, %struct.lconv** %18
store i32 0, i32* %22
%27 = load %struct.lconv*, %struct.lconv** %18
%28 = getelementptr inbounds %struct.lconv, %struct.lconv* %27, i32 0, i32 0
%29 = load i8*, i8** %28
store i8* %29, i8** %19
%30 = load %struct.lconv*, %struct.lconv** %18
%31 = getelementptr inbounds %struct.lconv, %struct.lconv* %30, i32 0, i32 1
%32 = load i8*, i8** %31
%33 = load i8, i8* %32
store i8 %33, i8* %20
%34 = load i8, i8* %20
%35 = sext i8 %34 to i32
%36 = icmp eq i32 %35, 0
br i1 %36, label %37, label %42
37: ; preds = %5
%38 = load %struct.lconv*, %struct.lconv** %18
%39 = getelementptr inbounds %struct.lconv, %struct.lconv* %38, i32 0, i32 2
%40 = load i8*, i8** %39
%41 = load i8, i8* %40
store i8 %41, i8* %20
br label %42
42: ; preds = %37, %5
%43 = load %struct.lconv*, %struct.lconv** %18
%44 = getelementptr inbounds %struct.lconv, %struct.lconv* %43, i32 0, i32 3
%45 = load i8*, i8** %44
%46 = load i8, i8* %45
store i8 %46, i8* %21
%47 = load i8, i8* %21
%48 = sext i8 %47 to i32
%49 = icmp eq i32 %48, 0
br i1 %49, label %50, label %55
50: ; preds = %42
%51 = load %struct.lconv*, %struct.lconv** %18
%52 = getelementptr inbounds %struct.lconv, %struct.lconv* %51, i32 0, i32 4
%53 = load i8*, i8** %52
%54 = load i8, i8* %53
store i8 %54, i8* %21
br label %55
55: ; preds = %50, %42
%56 = load i32, i32* %9
%57 = icmp eq i32 %56, -1
br i1 %57, label %58, label %59
58: ; preds = %55
store i32 0, i32* %9
br label %59
59: ; preds = %58, %55
%60 = load i32, i32* %10
%61 = icmp eq i32 %60, -1
br i1 %61, label %62, label %81
62: ; preds = %59
%63 = load i32*, i32** %8
%64 = load i32, i32* %63
%65 = and i32 %64, 64
%66 = icmp ne i32 %65, 0
br i1 %66, label %67, label %71
67: ; preds = %62
%68 = load %struct.lconv*, %struct.lconv** %18
%69 = getelementptr inbounds %struct.lconv, %struct.lconv* %68, i32 0, i32 5
%70 = load i32, i32* %69
store i32 %70, i32* %10
br label %75
71: ; preds = %62
%72 = load %struct.lconv*, %struct.lconv** %18
%73 = getelementptr inbounds %struct.lconv, %struct.lconv* %72, i32 0, i32 6
%74 = load i32, i32* %73
store i32 %74, i32* %10
br label %75
75: ; preds = %71, %67
%76 = load i32, i32* %10
%77 = load i32, i32* @CHAR_MAX
%78 = icmp eq i32 %76, %77
br i1 %78, label %79, label %80
79: ; preds = %75
store i32 2, i32* %10
br label %80
80: ; preds = %79, %75
br label %81
81: ; preds = %80, %59
%82 = load i32*, i32** %8
%83 = load i32, i32* %82
%84 = and i32 %83, 1
%85 = icmp ne i32 %84, 0
br i1 %85, label %86, label %94
86: ; preds = %81
%87 = load i32, i32* %9
%88 = load i8*, i8** %19
%89 = call i64 @get_groups(i32 %87, i8* %88)
%90 = load i32, i32* %9
%91 = sext i32 %90 to i64
%92 = add nsw i64 %91, %89
%93 = trunc i64 %92 to i32
store i32 %93, i32* %9
br label %94
94: ; preds = %86, %81
%95 = load i32, i32* %9
%96 = load i32, i32* %10
%97 = add nsw i32 %95, %96
%98 = add nsw i32 %97, 1
%99 = load i32, i32* %10
%100 = load double, double* %7
%101 = call i32 @asprintf(i8** %13, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i32 %98, i32 %99, double %100)
store i32 %101, i32* %14
%102 = load i32, i32* %14
%103 = icmp slt i32 %102, 0
br i1 %103, label %104, label %105
104: ; preds = %94
store i8* null, i8** %6
br label %365
105: ; preds = %94
%106 = load i32, i32* %14
%107 = mul nsw i32 %106, 2
%108 = add nsw i32 %107, 1
%109 = sext i32 %108 to i64
store i64 %109, i64* %15
%110 = load i64, i64* %15
%111 = call i8* @malloc(i64 %110)
store i8* %111, i8** %12
%112 = load i8*, i8** %12
%113 = icmp eq i8* %112, null
br i1 %113, label %114, label %117
114: ; preds = %105
%115 = load i8*, i8** %13
%116 = call i32 @free(i8* %115)
store i8* null, i8** %6
br label %365
117: ; preds = %105
%118 = load i8*, i8** %12
%119 = load i64, i64* %15
%120 = call i32 @memset(i8* %118, i32 0, i64 %119)
%121 = load i8*, i8** %12
%122 = load i64, i64* %15
%123 = getelementptr inbounds i8, i8* %121, i64 %122
%124 = getelementptr inbounds i8, i8* %123, i64 -1
store i8* %124, i8** %16
store i32 0, i32* %17
br label %125
125: ; preds = %133, %117
%126 = load i8*, i8** %13
%127 = load i32, i32* %17
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i8, i8* %126, i64 %128
%130 = load i8, i8* %129
%131 = sext i8 %130 to i32
%132 = icmp eq i32 %131, 32
br i1 %132, label %133, label %138
133: ; preds = %125
%134 = load i32, i32* %17
%135 = add nsw i32 %134, 1
store i32 %135, i32* %17
%136 = load i32, i32* %14
%137 = add nsw i32 %136, -1
store i32 %137, i32* %14
br label %125
138: ; preds = %125
%139 = load i32, i32* %10
%140 = icmp sgt i32 %139, 0
br i1 %140, label %141, label %169
141: ; preds = %138
%142 = load i32, i32* %10
%143 = load i8*, i8** %16
%144 = sext i32 %142 to i64
%145 = sub i64 0, %144
%146 = getelementptr inbounds i8, i8* %143, i64 %145
store i8* %146, i8** %16
%147 = load i8*, i8** %16
%148 = load i8*, i8** %13
%149 = load i32, i32* %14
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i8, i8* %148, i64 %150
%152 = load i32, i32* %17
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds i8, i8* %151, i64 %153
%155 = load i32, i32* %10
%156 = sext i32 %155 to i64
%157 = sub i64 0, %156
%158 = getelementptr inbounds i8, i8* %154, i64 %157
%159 = load i32, i32* %10
%160 = sext i32 %159 to i64
%161 = call i32 @memcpy(i8* %147, i8* %158, i64 %160)
%162 = load i8, i8* %20
%163 = load i8*, i8** %16
%164 = getelementptr inbounds i8, i8* %163, i32 -1
store i8* %164, i8** %16
store i8 %162, i8* %164
%165 = load i32, i32* %10
%166 = add nsw i32 %165, 1
%167 = load i32, i32* %14
%168 = sub nsw i32 %167, %166
store i32 %168, i32* %14
br label %169
169: ; preds = %141, %138
%170 = load i32*, i32** %8
%171 = load i32, i32* %170
%172 = and i32 %171, 1
%173 = icmp ne i32 %172, 0
br i1 %173, label %174, label %315
174: ; preds = %169
%175 = load i8, i8* %21
%176 = sext i8 %175 to i32
%177 = icmp ne i32 %176, 0
br i1 %177, label %178, label %315
178: ; preds = %174
%179 = load i8*, i8** %19
%180 = load i8, i8* %179
%181 = zext i8 %180 to i32
%182 = load i32, i32* @CHAR_MAX
%183 = trunc i32 %182 to i8
%184 = zext i8 %183 to i32
%185 = icmp ne i32 %181, %184
br i1 %185, label %186, label %315
186: ; preds = %178
%187 = load i8*, i8** %19
%188 = load i8, i8* %187
%189 = sext i8 %188 to i32
%190 = icmp sgt i32 %189, 0
br i1 %190, label %191, label %315
191: ; preds = %186
br label %192
192: ; preds = %285, %191
%193 = load i32, i32* %14
%194 = load i8*, i8** %19
%195 = load i8, i8* %194
%196 = sext i8 %195 to i32
%197 = icmp sgt i32 %193, %196
br i1 %197, label %198, label %286
198: ; preds = %192
br label %199
199: ; preds = %198
%200 = load i8*, i8** %19
%201 = load i8, i8* %200
%202 = sext i8 %201 to i32
store i32 %202, i32* %23
br label %203
203: ; preds = %207, %199
%204 = load i32, i32* %23
%205 = add nsw i32 %204, -1
store i32 %205, i32* %23
%206 = icmp sgt i32 %204, 0
br i1 %206, label %207, label %220
207: ; preds = %203
%208 = load i32, i32* %14
%209 = add nsw i32 %208, -1
store i32 %209, i32* %14
%210 = load i8*, i8** %13
%211 = load i32, i32* %14
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds i8, i8* %210, i64 %212
%214 = load i32, i32* %17
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds i8, i8* %213, i64 %215
%217 = load i8, i8* %216
%218 = load i8*, i8** %16
%219 = getelementptr inbounds i8, i8* %218, i32 -1
store i8* %219, i8** %16
store i8 %217, i8* %219
br label %203
220: ; preds = %203
br label %221
221: ; preds = %220
br label %222
222: ; preds = %221
%223 = load i8, i8* %21
%224 = load i8*, i8** %16
%225 = getelementptr inbounds i8, i8* %224, i32 -1
store i8* %225, i8** %16
store i8 %223, i8* %225
%226 = load i32, i32* %22
%227 = add nsw i32 %226, 1
store i32 %227, i32* %22
br label %228
228: ; preds = %222
%229 = load i8*, i8** %19
%230 = getelementptr inbounds i8, i8* %229, i32 1
store i8* %230, i8** %19
%231 = load i8*, i8** %19
%232 = load i8, i8* %231
%233 = zext i8 %232 to i32
%234 = load i32, i32* @CHAR_MAX
%235 = trunc i32 %234 to i8
%236 = zext i8 %235 to i32
%237 = icmp eq i32 %233, %236
br i1 %237, label %238, label %239
238: ; preds = %228
br label %286
239: ; preds = %228
%240 = load i8*, i8** %19
%241 = load i8, i8* %240
%242 = sext i8 %241 to i32
%243 = icmp eq i32 %242, 0
br i1 %243, label %244, label %285
244: ; preds = %239
%245 = load i8*, i8** %19
%246 = getelementptr inbounds i8, i8* %245, i32 -1
store i8* %246, i8** %19
br label %247
247: ; preds = %283, %244
%248 = load i32, i32* %14
%249 = load i8*, i8** %19
%250 = load i8, i8* %249
%251 = sext i8 %250 to i32
%252 = icmp sgt i32 %248, %251
br i1 %252, label %253, label %284
253: ; preds = %247
br label %254
254: ; preds = %253
%255 = load i8*, i8** %19
%256 = load i8, i8* %255
%257 = sext i8 %256 to i32
store i32 %257, i32* %24
br label %258
258: ; preds = %262, %254
%259 = load i32, i32* %24
%260 = add nsw i32 %259, -1
store i32 %260, i32* %24
%261 = icmp sgt i32 %259, 0
br i1 %261, label %262, label %275
262: ; preds = %258
%263 = load i32, i32* %14
%264 = add nsw i32 %263, -1
store i32 %264, i32* %14
%265 = load i8*, i8** %13
%266 = load i32, i32* %14
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds i8, i8* %265, i64 %267
%269 = load i32, i32* %17
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds i8, i8* %268, i64 %270
%272 = load i8, i8* %271
%273 = load i8*, i8** %16
%274 = getelementptr inbounds i8, i8* %273, i32 -1
store i8* %274, i8** %16
store i8 %272, i8* %274
br label %258
275: ; preds = %258
br label %276
276: ; preds = %275
br label %277
277: ; preds = %276
%278 = load i8, i8* %21
%279 = load i8*, i8** %16
%280 = getelementptr inbounds i8, i8* %279, i32 -1
store i8* %280, i8** %16
store i8 %278, i8* %280
%281 = load i32, i32* %22
%282 = add nsw i32 %281, 1
store i32 %282, i32* %22
br label %283
283: ; preds = %277
br label %247
284: ; preds = %247
br label %285
285: ; preds = %284, %239
br label %192
286: ; preds = %238, %192
%287 = load i32, i32* %14
%288 = icmp ne i32 %287, 0
br i1 %288, label %289, label %311
289: ; preds = %286
br label %290
290: ; preds = %289
%291 = load i32, i32* %14
store i32 %291, i32* %25
br label %292
292: ; preds = %296, %290
%293 = load i32, i32* %25
%294 = add nsw i32 %293, -1
store i32 %294, i32* %25
%295 = icmp sgt i32 %293, 0
br i1 %295, label %296, label %309
296: ; preds = %292
%297 = load i32, i32* %14
%298 = add nsw i32 %297, -1
store i32 %298, i32* %14
%299 = load i8*, i8** %13
%300 = load i32, i32* %14
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds i8, i8* %299, i64 %301
%303 = load i32, i32* %17
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds i8, i8* %302, i64 %304
%306 = load i8, i8* %305
%307 = load i8*, i8** %16
%308 = getelementptr inbounds i8, i8* %307, i32 -1
store i8* %308, i8** %16
store i8 %306, i8* %308
br label %292
309: ; preds = %292
br label %310
310: ; preds = %309
br label %311
311: ; preds = %310, %286
%312 = load i32, i32* %22
%313 = load i32, i32* %17
%314 = sub nsw i32 %313, %312
store i32 %314, i32* %17
br label %335
315: ; preds = %186, %178, %174, %169
%316 = load i32, i32* %14
%317 = load i8*, i8** %16
%318 = sext i32 %316 to i64
%319 = sub i64 0, %318
%320 = getelementptr inbounds i8, i8* %317, i64 %319
store i8* %320, i8** %16
%321 = load i8*, i8** %16
%322 = load i8*, i8** %13
%323 = load i32, i32* %17
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds i8, i8* %322, i64 %324
%326 = load i32, i32* %14
%327 = sext i32 %326 to i64
%328 = call i32 @memcpy(i8* %321, i8* %325, i64 %327)
%329 = load i32, i32* %10
%330 = icmp eq i32 %329, 0
br i1 %330, label %331, label %334
331: ; preds = %315
%332 = load i32, i32* %17
%333 = add nsw i32 %332, -1
store i32 %333, i32* %17
br label %334
334: ; preds = %331, %315
br label %335
335: ; preds = %334, %311
%336 = load i32, i32* %17
%337 = icmp sgt i32 %336, 0
br i1 %337, label %338, label %349
338: ; preds = %335
%339 = load i32, i32* %17
%340 = load i8*, i8** %16
%341 = sext i32 %339 to i64
%342 = sub i64 0, %341
%343 = getelementptr inbounds i8, i8* %340, i64 %342
store i8* %343, i8** %16
%344 = load i8*, i8** %16
%345 = load i32, i32* %11
%346 = load i32, i32* %17
%347 = sext i32 %346 to i64
%348 = call i32 @memset(i8* %344, i32 %345, i64 %347)
br label %349
349: ; preds = %338, %335
%350 = load i64, i64* %15
%351 = load i8*, i8** %16
%352 = load i8*, i8** %12
%353 = ptrtoint i8* %351 to i64
%354 = ptrtoint i8* %352 to i64
%355 = sub i64 %353, %354
%356 = sub i64 %350, %355
%357 = add i64 %356, 1
store i64 %357, i64* %15
%358 = load i8*, i8** %12
%359 = load i8*, i8** %16
%360 = load i64, i64* %15
%361 = call i32 @memmove(i8* %358, i8* %359, i64 %360)
%362 = load i8*, i8** %13
%363 = call i32 @free(i8* %362)
%364 = load i8*, i8** %12
store i8* %364, i8** %6
br label %365
365: ; preds = %349, %114, %104
%366 = load i8*, i8** %6
ret i8* %366
}

LLVM IR (-O2):
%struct.lconv = type { i8*, i8*, i8*, i8*, i8*, i32, i32 }
@CHAR_MAX = global i32 0
@.str = [6 x i8] c"%*.*f\00"
define i8* @__format_grouped_double(double %0, i32* nocapture %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca i8*
%7 = bitcast i8** %6 to i8*
%8 = tail call %struct.lconv* (...) @localeconv()
%9 = getelementptr inbounds %struct.lconv, %struct.lconv* %8, i64 0, i32 0
%10 = load i8*, i8** %9
%11 = getelementptr inbounds %struct.lconv, %struct.lconv* %8, i64 0, i32 1
%12 = load i8*, i8** %11
%13 = load i8, i8* %12
%14 = icmp eq i8 %13, 0
br i1 %14, label %15, label %19
15: ; preds = %5
%16 = getelementptr inbounds %struct.lconv, %struct.lconv* %8, i64 0, i32 2
%17 = load i8*, i8** %16
%18 = load i8, i8* %17
br label %19
19: ; preds = %15, %5
%20 = phi i8 [ %18, %15 ], [ %13, %5 ]
%21 = getelementptr inbounds %struct.lconv, %struct.lconv* %8, i64 0, i32 3
%22 = load i8*, i8** %21
%23 = load i8, i8* %22
%24 = icmp eq i8 %23, 0
br i1 %24, label %25, label %29
25: ; preds = %19
%26 = getelementptr inbounds %struct.lconv, %struct.lconv* %8, i64 0, i32 4
%27 = load i8*, i8** %26
%28 = load i8, i8* %27
br label %29
29: ; preds = %25, %19
%30 = phi i8 [ %28, %25 ], [ %23, %19 ]
%31 = icmp eq i32 %2, -1
%32 = select i1 %31, i32 0, i32 %2
%33 = icmp eq i32 %3, -1
%34 = load i32, i32* %1
br i1 %33, label %35, label %45
35: ; preds = %29
%36 = and i32 %34, 64
%37 = icmp eq i32 %36, 0
%38 = getelementptr inbounds %struct.lconv, %struct.lconv* %8, i64 0, i32 5
%39 = getelementptr inbounds %struct.lconv, %struct.lconv* %8, i64 0, i32 6
%40 = select i1 %37, i32* %39, i32* %38
%41 = load i32, i32* %40
%42 = load i32, i32* @CHAR_MAX
%43 = icmp eq i32 %41, %42
%44 = select i1 %43, i32 2, i32 %41
br label %45
45: ; preds = %29, %35
%46 = phi i32 [ %44, %35 ], [ %3, %29 ]
%47 = and i32 %34, 1
%48 = icmp eq i32 %47, 0
br i1 %48, label %53, label %49
49: ; preds = %45
%50 = tail call i64 @get_groups(i32 %32, i8* %10)
%51 = trunc i64 %50 to i32
%52 = add i32 %32, %51
br label %53
53: ; preds = %49, %45
%54 = phi i32 [ %52, %49 ], [ %32, %45 ]
%55 = add i32 %46, 1
%56 = add i32 %55, %54
%57 = call i32 @asprintf(i8** %6, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i32 %56, i32 %46, double %0)
%58 = icmp slt i32 %57, 0
br i1 %58, label %377, label %59
59: ; preds = %53
%60 = shl nuw nsw i32 %57, 1
%61 = or i32 %60, 1
%62 = sext i32 %61 to i64
%63 = call i8* @malloc(i64 %62)
%64 = icmp eq i8* %63, null
br i1 %64, label %373, label %65
65: ; preds = %59
%66 = call i32 @memset(i8* %63, i32 0, i64 %62)
%67 = getelementptr inbounds i8, i8* %63, i64 %62
%68 = getelementptr inbounds i8, i8* %67, i64 -1
%69 = load i8*, i8** %6
%70 = load i8, i8* %69
%71 = icmp eq i8 %70, 32
br i1 %71, label %72, label %82
72: ; preds = %65, %72
%73 = phi i64 [ %75, %72 ], [ 0, %65 ]
%74 = phi i32 [ %76, %72 ], [ %57, %65 ]
%75 = add nuw nsw i64 %73, 1
%76 = add nsw i32 %74, -1
%77 = getelementptr inbounds i8, i8* %69, i64 %75
%78 = load i8, i8* %77
%79 = icmp eq i8 %78, 32
br i1 %79, label %72, label %80
80: ; preds = %72
%81 = trunc i64 %75 to i32
br label %82
82: ; preds = %80, %65
%83 = phi i32 [ 0, %65 ], [ %81, %80 ]
%84 = phi i32 [ %57, %65 ], [ %76, %80 ]
%85 = zext i32 %83 to i64
%86 = icmp sgt i32 %46, 0
br i1 %86, label %87, label %99
87: ; preds = %82
%88 = zext i32 %46 to i64
%89 = sub nsw i64 0, %88
%90 = getelementptr inbounds i8, i8* %68, i64 %89
%91 = sext i32 %84 to i64
%92 = getelementptr inbounds i8, i8* %69, i64 %91
%93 = getelementptr inbounds i8, i8* %92, i64 %85
%94 = getelementptr inbounds i8, i8* %93, i64 %89
%95 = call i32 @memcpy(i8* %90, i8* %94, i64 %88)
%96 = getelementptr inbounds i8, i8* %90, i64 -1
store i8 %20, i8* %96
%97 = xor i32 %46, -1
%98 = add i32 %84, %97
br label %99
99: ; preds = %87, %82
%100 = phi i32 [ %98, %87 ], [ %84, %82 ]
%101 = phi i8* [ %96, %87 ], [ %68, %82 ]
%102 = load i32, i32* %1
%103 = and i32 %102, 1
%104 = icmp ne i32 %103, 0
%105 = icmp ne i8 %30, 0
%106 = select i1 %104, i1 %105, i1 false
br i1 %106, label %107, label %346
107: ; preds = %99
%108 = load i8, i8* %10
%109 = load i32, i32* @CHAR_MAX
%110 = trunc i32 %109 to i8
%111 = icmp ne i8 %108, %110
%112 = icmp sgt i8 %108, 0
%113 = and i1 %112, %111
br i1 %113, label %114, label %346
114: ; preds = %107
%115 = zext i8 %108 to i32
%116 = icmp sgt i32 %100, %115
br i1 %116, label %117, label %287
117: ; preds = %114, %280
%118 = phi i32 [ %281, %280 ], [ %115, %114 ]
%119 = phi i32 [ %285, %280 ], [ 0, %114 ]
%120 = phi i8* [ %284, %280 ], [ %10, %114 ]
%121 = phi i8* [ %283, %280 ], [ %101, %114 ]
%122 = phi i32 [ %282, %280 ], [ %100, %114 ]
%123 = icmp sgt i32 %118, 0
br i1 %123, label %124, label %185
124: ; preds = %117
%125 = sext i32 %122 to i64
%126 = add nsw i32 %118, -1
%127 = and i32 %118, 3
%128 = icmp eq i32 %127, 0
br i1 %128, label %143, label %129
129: ; preds = %124, %129
%130 = phi i64 [ %135, %129 ], [ %125, %124 ]
%131 = phi i32 [ %134, %129 ], [ %118, %124 ]
%132 = phi i8* [ %140, %129 ], [ %121, %124 ]
%133 = phi i32 [ %141, %129 ], [ 0, %124 ]
%134 = add nsw i32 %131, -1
%135 = add nsw i64 %130, -1
%136 = load i8*, i8** %6
%137 = getelementptr inbounds i8, i8* %136, i64 %85
%138 = getelementptr inbounds i8, i8* %137, i64 %135
%139 = load i8, i8* %138
%140 = getelementptr inbounds i8, i8* %132, i64 -1
store i8 %139, i8* %140
%141 = add i32 %133, 1
%142 = icmp eq i32 %141, %127
br i1 %142, label %143, label %129
143: ; preds = %129, %124
%144 = phi i64 [ %125, %124 ], [ %135, %129 ]
%145 = phi i32 [ %118, %124 ], [ %134, %129 ]
%146 = phi i8* [ %121, %124 ], [ %140, %129 ]
%147 = phi i64 [ undef, %124 ], [ %135, %129 ]
%148 = phi i8* [ undef, %124 ], [ %140, %129 ]
%149 = icmp ult i32 %126, 3
br i1 %149, label %181, label %150
150: ; preds = %143, %150
%151 = phi i64 [ %173, %150 ], [ %144, %143 ]
%152 = phi i32 [ %172, %150 ], [ %145, %143 ]
%153 = phi i8* [ %178, %150 ], [ %146, %143 ]
%154 = add nsw i64 %151, -1
%155 = load i8*, i8** %6
%156 = getelementptr inbounds i8, i8* %155, i64 %85
%157 = getelementptr inbounds i8, i8* %156, i64 %154
%158 = load i8, i8* %157
%159 = getelementptr inbounds i8, i8* %153, i64 -1
store i8 %158, i8* %159
%160 = add nsw i64 %151, -2
%161 = load i8*, i8** %6
%162 = getelementptr inbounds i8, i8* %161, i64 %85
%163 = getelementptr inbounds i8, i8* %162, i64 %160
%164 = load i8, i8* %163
%165 = getelementptr inbounds i8, i8* %153, i64 -2
store i8 %164, i8* %165
%166 = add nsw i64 %151, -3
%167 = load i8*, i8** %6
%168 = getelementptr inbounds i8, i8* %167, i64 %85
%169 = getelementptr inbounds i8, i8* %168, i64 %166
%170 = load i8, i8* %169
%171 = getelementptr inbounds i8, i8* %153, i64 -3
store i8 %170, i8* %171
%172 = add nsw i32 %152, -4
%173 = add nsw i64 %151, -4
%174 = load i8*, i8** %6
%175 = getelementptr inbounds i8, i8* %174, i64 %85
%176 = getelementptr inbounds i8, i8* %175, i64 %173
%177 = load i8, i8* %176
%178 = getelementptr inbounds i8, i8* %153, i64 -4
store i8 %177, i8* %178
%179 = add i32 %152, -5
%180 = icmp ult i32 %179, -2
br i1 %180, label %150, label %181
181: ; preds = %150, %143
%182 = phi i64 [ %147, %143 ], [ %173, %150 ]
%183 = phi i8* [ %148, %143 ], [ %178, %150 ]
%184 = trunc i64 %182 to i32
br label %185
185: ; preds = %181, %117
%186 = phi i32 [ %122, %117 ], [ %184, %181 ]
%187 = phi i8* [ %121, %117 ], [ %183, %181 ]
%188 = getelementptr inbounds i8, i8* %187, i64 -1
store i8 %30, i8* %188
%189 = add nsw i32 %119, 1
%190 = getelementptr inbounds i8, i8* %120, i64 1
%191 = load i8, i8* %190
%192 = load i32, i32* @CHAR_MAX
%193 = trunc i32 %192 to i8
%194 = icmp eq i8 %191, %193
br i1 %194, label %287, label %195
195: ; preds = %185
%196 = icmp eq i8 %191, 0
br i1 %196, label %199, label %197
197: ; preds = %195
%198 = sext i8 %191 to i32
br label %280
199: ; preds = %195
%200 = load i8, i8* %120
%201 = sext i8 %200 to i32
%202 = icmp sgt i32 %186, %201
br i1 %202, label %203, label %280
203: ; preds = %199, %270
%204 = phi i32 [ %276, %270 ], [ %201, %199 ]
%205 = phi i32 [ %274, %270 ], [ %189, %199 ]
%206 = phi i8* [ %273, %270 ], [ %188, %199 ]
%207 = phi i32 [ %271, %270 ], [ %186, %199 ]
%208 = icmp sgt i32 %204, 0
br i1 %208, label %209, label %270
209: ; preds = %203
%210 = sext i32 %207 to i64
%211 = add nsw i32 %204, -1
%212 = and i32 %204, 3
%213 = icmp eq i32 %212, 0
br i1 %213, label %228, label %214
214: ; preds = %209, %214
%215 = phi i64 [ %220, %214 ], [ %210, %209 ]
%216 = phi i32 [ %219, %214 ], [ %204, %209 ]
%217 = phi i8* [ %225, %214 ], [ %206, %209 ]
%218 = phi i32 [ %226, %214 ], [ 0, %209 ]
%219 = add nsw i32 %216, -1
%220 = add nsw i64 %215, -1
%221 = load i8*, i8** %6
%222 = getelementptr inbounds i8, i8* %221, i64 %85
%223 = getelementptr inbounds i8, i8* %222, i64 %220
%224 = load i8, i8* %223
%225 = getelementptr inbounds i8, i8* %217, i64 -1
store i8 %224, i8* %225
%226 = add i32 %218, 1
%227 = icmp eq i32 %226, %212
br i1 %227, label %228, label %214
228: ; preds = %214, %209
%229 = phi i64 [ %210, %209 ], [ %220, %214 ]
%230 = phi i32 [ %204, %209 ], [ %219, %214 ]
%231 = phi i8* [ %206, %209 ], [ %225, %214 ]
%232 = phi i64 [ undef, %209 ], [ %220, %214 ]
%233 = phi i8* [ undef, %209 ], [ %225, %214 ]
%234 = icmp ult i32 %211, 3
br i1 %234, label %266, label %235
235: ; preds = %228, %235
%236 = phi i64 [ %258, %235 ], [ %229, %228 ]
%237 = phi i32 [ %257, %235 ], [ %230, %228 ]
%238 = phi i8* [ %263, %235 ], [ %231, %228 ]
%239 = add nsw i64 %236, -1
%240 = load i8*, i8** %6
%241 = getelementptr inbounds i8, i8* %240, i64 %85
%242 = getelementptr inbounds i8, i8* %241, i64 %239
%243 = load i8, i8* %242
%244 = getelementptr inbounds i8, i8* %238, i64 -1
store i8 %243, i8* %244
%245 = add nsw i64 %236, -2
%246 = load i8*, i8** %6
%247 = getelementptr inbounds i8, i8* %246, i64 %85
%248 = getelementptr inbounds i8, i8* %247, i64 %245
%249 = load i8, i8* %248
%250 = getelementptr inbounds i8, i8* %238, i64 -2
store i8 %249, i8* %250
%251 = add nsw i64 %236, -3
%252 = load i8*, i8** %6
%253 = getelementptr inbounds i8, i8* %252, i64 %85
%254 = getelementptr inbounds i8, i8* %253, i64 %251
%255 = load i8, i8* %254
%256 = getelementptr inbounds i8, i8* %238, i64 -3
store i8 %255, i8* %256
%257 = add nsw i32 %237, -4
%258 = add nsw i64 %236, -4
%259 = load i8*, i8** %6
%260 = getelementptr inbounds i8, i8* %259, i64 %85
%261 = getelementptr inbounds i8, i8* %260, i64 %258
%262 = load i8, i8* %261
%263 = getelementptr inbounds i8, i8* %238, i64 -4
store i8 %262, i8* %263
%264 = add i32 %237, -5
%265 = icmp ult i32 %264, -2
br i1 %265, label %235, label %266
266: ; preds = %235, %228
%267 = phi i64 [ %232, %228 ], [ %258, %235 ]
%268 = phi i8* [ %233, %228 ], [ %263, %235 ]
%269 = trunc i64 %267 to i32
br label %270
270: ; preds = %266, %203
%271 = phi i32 [ %207, %203 ], [ %269, %266 ]
%272 = phi i8* [ %206, %203 ], [ %268, %266 ]
%273 = getelementptr inbounds i8, i8* %272, i64 -1
store i8 %30, i8* %273
%274 = add nsw i32 %205, 1
%275 = load i8, i8* %120
%276 = sext i8 %275 to i32
%277 = icmp sgt i32 %271, %276
br i1 %277, label %203, label %278
278: ; preds = %270
%279 = sext i8 %275 to i32
br label %280
280: ; preds = %278, %197, %199
%281 = phi i32 [ %198, %197 ], [ %201, %199 ], [ %279, %278 ]
%282 = phi i32 [ %186, %197 ], [ %186, %199 ], [ %271, %278 ]
%283 = phi i8* [ %188, %197 ], [ %188, %199 ], [ %273, %278 ]
%284 = phi i8* [ %190, %197 ], [ %120, %199 ], [ %120, %278 ]
%285 = phi i32 [ %189, %197 ], [ %189, %199 ], [ %274, %278 ]
%286 = icmp sgt i32 %282, %281
br i1 %286, label %117, label %287
287: ; preds = %280, %185, %114
%288 = phi i32 [ %100, %114 ], [ %186, %185 ], [ %282, %280 ]
%289 = phi i8* [ %101, %114 ], [ %188, %185 ], [ %283, %280 ]
%290 = phi i32 [ 0, %114 ], [ %189, %185 ], [ %285, %280 ]
%291 = icmp sgt i32 %288, 0
br i1 %291, label %292, label %343
292: ; preds = %287
%293 = zext i32 %288 to i64
%294 = add i32 %288, -1
%295 = and i32 %288, 3
%296 = icmp eq i32 %295, 0
br i1 %296, label %309, label %297
297: ; preds = %292, %297
%298 = phi i64 [ %301, %297 ], [ %293, %292 ]
%299 = phi i8* [ %306, %297 ], [ %289, %292 ]
%300 = phi i32 [ %307, %297 ], [ 0, %292 ]
%301 = add nsw i64 %298, -1
%302 = load i8*, i8** %6
%303 = getelementptr inbounds i8, i8* %302, i64 %85
%304 = getelementptr inbounds i8, i8* %303, i64 %301
%305 = load i8, i8* %304
%306 = getelementptr inbounds i8, i8* %299, i64 -1
store i8 %305, i8* %306
%307 = add i32 %300, 1
%308 = icmp eq i32 %307, %295
br i1 %308, label %309, label %297
309: ; preds = %297, %292
%310 = phi i64 [ %293, %292 ], [ %301, %297 ]
%311 = phi i8* [ %289, %292 ], [ %306, %297 ]
%312 = phi i8* [ undef, %292 ], [ %306, %297 ]
%313 = icmp ult i32 %294, 3
br i1 %313, label %343, label %314
314: ; preds = %309, %314
%315 = phi i64 [ %336, %314 ], [ %310, %309 ]
%316 = phi i8* [ %341, %314 ], [ %311, %309 ]
%317 = add nsw i64 %315, -1
%318 = load i8*, i8** %6
%319 = getelementptr inbounds i8, i8* %318, i64 %85
%320 = getelementptr inbounds i8, i8* %319, i64 %317
%321 = load i8, i8* %320
%322 = getelementptr inbounds i8, i8* %316, i64 -1
store i8 %321, i8* %322
%323 = add nsw i64 %315, -2
%324 = load i8*, i8** %6
%325 = getelementptr inbounds i8, i8* %324, i64 %85
%326 = getelementptr inbounds i8, i8* %325, i64 %323
%327 = load i8, i8* %326
%328 = getelementptr inbounds i8, i8* %316, i64 -2
store i8 %327, i8* %328
%329 = add nsw i64 %315, -3
%330 = load i8*, i8** %6
%331 = getelementptr inbounds i8, i8* %330, i64 %85
%332 = getelementptr inbounds i8, i8* %331, i64 %329
%333 = load i8, i8* %332
%334 = getelementptr inbounds i8, i8* %316, i64 -3
store i8 %333, i8* %334
%335 = trunc i64 %329 to i32
%336 = add nsw i64 %315, -4
%337 = load i8*, i8** %6
%338 = getelementptr inbounds i8, i8* %337, i64 %85
%339 = getelementptr inbounds i8, i8* %338, i64 %336
%340 = load i8, i8* %339
%341 = getelementptr inbounds i8, i8* %316, i64 -4
store i8 %340, i8* %341
%342 = icmp sgt i32 %335, 1
br i1 %342, label %314, label %343
343: ; preds = %309, %314, %287
%344 = phi i8* [ %289, %287 ], [ %312, %309 ], [ %341, %314 ]
%345 = sub nsw i32 %83, %290
br label %356
346: ; preds = %107, %99
%347 = sext i32 %100 to i64
%348 = sub nsw i64 0, %347
%349 = getelementptr inbounds i8, i8* %101, i64 %348
%350 = load i8*, i8** %6
%351 = getelementptr inbounds i8, i8* %350, i64 %85
%352 = call i32 @memcpy(i8* %349, i8* %351, i64 %347)
%353 = icmp eq i32 %46, 0
%354 = sext i1 %353 to i32
%355 = add nsw i32 %83, %354
br label %356
356: ; preds = %346, %343
%357 = phi i8* [ %344, %343 ], [ %349, %346 ]
%358 = phi i32 [ %345, %343 ], [ %355, %346 ]
%359 = icmp sgt i32 %358, 0
br i1 %359, label %360, label %365
360: ; preds = %356
%361 = zext i32 %358 to i64
%362 = sub nsw i64 0, %361
%363 = getelementptr inbounds i8, i8* %357, i64 %362
%364 = call i32 @memset(i8* %363, i32 %4, i64 %361)
br label %365
365: ; preds = %360, %356
%366 = phi i8* [ %363, %360 ], [ %357, %356 ]
%367 = ptrtoint i8* %366 to i64
%368 = ptrtoint i8* %63 to i64
%369 = add nsw i64 %62, 1
%370 = add i64 %369, %368
%371 = sub i64 %370, %367
%372 = call i32 @memmove(i8* %63, i8* %366, i64 %371)
br label %373
373: ; preds = %59, %365
%374 = phi i8* [ %63, %365 ], [ null, %59 ]
%375 = load i8*, i8** %6
%376 = call i32 @free(i8* %375)
br label %377
377: ; preds = %373, %53
%378 = phi i8* [ null, %53 ], [ %374, %373 ]
ret i8* %378
}