#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;
};
typedef int /*<<< orphan*/ fmt;

/* Variables and functions */
int CHAR_MAX;
int asprintf(char **, char *, double);
char *calloc(int, size_t);
int /*<<< orphan*/ free(char *);
scalar_t__ get_groups(int, char *);
struct lconv *localeconv();
int /*<<< orphan*/ memcpy(char *, char *, int);
int /*<<< orphan*/ memmove(char *, char *, size_t);
int /*<<< orphan*/ memset(char *, int, int);
int /*<<< orphan*/ snprintf(char *, int, char *, int, int);
int strlen(char *);
char *__format_grouped_double(double value, int *flags, int left_prec,
                              int right_prec, int pad_char) {
  char *rslt;
  char *avalue;
  int avalue_size;
  char fmt[32];
  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);
  snprintf(fmt, sizeof(fmt), "%%%d.%df", left_prec + right_prec + 1,
           right_prec);
  avalue_size = asprintf(&avalue, fmt, value);
  if (avalue_size < 0)
    return (NULL);
  bufsize = strlen(avalue) * 2 + 1;
  rslt = calloc(1, bufsize);
  if (rslt == NULL) {
    free(avalue);
    return (NULL);
  }
  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, right_prec);
    *--bufend = decimal_point;
    avalue_size -= (right_prec + 1);
  }
  if ((*flags & 0x01) && thousands_sep != '\0' && *grouping != 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 (*grouping == 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, avalue_size);
    if (right_prec == 0)
      padded--;
  }
  if (padded > 0) {
    bufend -= padded;
    memset(bufend, pad_char, 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    $0xa0,%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,-0x80(%rbp)
movl   $0x0,-0x90(%rbp)
mov    -0x80(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x88(%rbp)
mov    -0x80(%rbp),%rax
mov    0x8(%rax),%rax
mov    (%rax),%al
mov    %al,-0x89(%rbp)
movsbl -0x89(%rbp),%eax
cmp    $0x0,%eax
jne    1210 <__format_grouped_double+0x70>
mov    -0x80(%rbp),%rax
mov    0x10(%rax),%rax
mov    (%rax),%al
mov    %al,-0x89(%rbp)
mov    -0x80(%rbp),%rax
mov    0x18(%rax),%rax
mov    (%rax),%al
mov    %al,-0x8a(%rbp)
movsbl -0x8a(%rbp),%eax
cmp    $0x0,%eax
jne    1240 <__format_grouped_double+0xa0>
mov    -0x80(%rbp),%rax
mov    0x20(%rax),%rax
mov    (%rax),%al
mov    %al,-0x8a(%rbp)
cmpl   $0xffffffff,-0x1c(%rbp)
jne    1251 <__format_grouped_double+0xb1>
movl   $0x0,-0x1c(%rbp)
cmpl   $0xffffffff,-0x20(%rbp)
jne    12a4 <__format_grouped_double+0x104>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
and    $0x40,%eax
cmp    $0x0,%eax
je     127c <__format_grouped_double+0xdc>
mov    -0x80(%rbp),%rax
mov    0x28(%rax),%eax
mov    %eax,-0x20(%rbp)
jmp    1286 <__format_grouped_double+0xe6>
mov    -0x80(%rbp),%rax
mov    0x2c(%rax),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    0x2d58(%rip),%rcx
cmp    (%rcx),%eax
jne    129f <__format_grouped_double+0xff>
movl   $0x2,-0x20(%rbp)
jmp    12a4 <__format_grouped_double+0x104>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     12d2 <__format_grouped_double+0x132>
mov    -0x1c(%rbp),%edi
mov    -0x88(%rbp),%rsi
call   1050 <get_groups@plt>
mov    %rax,%rcx
movslq -0x1c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x1c(%rbp)
lea    -0x60(%rbp),%rdi
mov    -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
add    $0x1,%ecx
mov    -0x20(%rbp),%r8d
mov    $0x20,%esi
lea    0xd11(%rip),%rdx
call   1070 <snprintf@plt>
lea    -0x60(%rbp),%rsi
movsd  -0x10(%rbp),%xmm0
lea    -0x38(%rbp),%rdi
call   10b0 <asprintf@plt>
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jge    1320 <__format_grouped_double+0x180>
movq   $0x0,-0x8(%rbp)
jmp    1751 <__format_grouped_double+0x5b1>
mov    -0x38(%rbp),%rdi
call   1060 <strlen@plt>
shl    $0x1,%eax
add    $0x1,%eax
cltq
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rsi
mov    $0x1,%edi
call   1090 <calloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    1368 <__format_grouped_double+0x1c8>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
movq   $0x0,-0x8(%rbp)
jmp    1751 <__format_grouped_double+0x5b1>
mov    -0x30(%rbp),%rax
add    -0x68(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    13ab <__format_grouped_double+0x20b>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    137f <__format_grouped_double+0x1df>
cmpl   $0x0,-0x20(%rbp)
jle    141b <__format_grouped_double+0x27b>
mov    -0x20(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rdi
mov    -0x38(%rbp),%rsi
movslq -0x3c(%rbp),%rax
add    %rax,%rsi
movslq -0x74(%rbp),%rax
add    %rax,%rsi
movslq -0x20(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rsi
mov    -0x20(%rbp),%edx
call   10a0 <memcpy@plt>
mov    -0x89(%rbp),%cl
mov    -0x70(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x70(%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     16a1 <__format_grouped_double+0x501>
movsbl -0x8a(%rbp),%eax
cmp    $0x0,%eax
je     16a1 <__format_grouped_double+0x501>
mov    -0x88(%rbp),%rax
movsbl (%rax),%eax
mov    0x2b9a(%rip),%rcx
cmp    (%rcx),%eax
je     16a1 <__format_grouped_double+0x501>
mov    -0x88(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jle    16a1 <__format_grouped_double+0x501>
jmp    146e <__format_grouped_double+0x2ce>
mov    -0x3c(%rbp),%eax
mov    -0x88(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jle    1620 <__format_grouped_double+0x480>
jmp    1488 <__format_grouped_double+0x2e8>
mov    -0x88(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x94(%rbp)
cmp    $0x0,%eax
jle    14e4 <__format_grouped_double+0x344>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
add    %rcx,%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x70(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x70(%rbp)
mov    %cl,-0x1(%rax)
jmp    1498 <__format_grouped_double+0x2f8>
jmp    14e9 <__format_grouped_double+0x349>
jmp    14ee <__format_grouped_double+0x34e>
mov    -0x8a(%rbp),%cl
mov    -0x70(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x70(%rbp)
mov    %cl,-0x1(%rax)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
movsbl (%rax),%eax
mov    0x2ab0(%rip),%rcx
cmp    (%rcx),%eax
jne    1545 <__format_grouped_double+0x3a5>
jmp    1620 <__format_grouped_double+0x480>
mov    -0x88(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    161b <__format_grouped_double+0x47b>
mov    -0x88(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x88(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x88(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jle    1616 <__format_grouped_double+0x476>
jmp    1584 <__format_grouped_double+0x3e4>
mov    -0x88(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x98(%rbp)
cmp    $0x0,%eax
jle    15e0 <__format_grouped_double+0x440>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
add    %rcx,%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x70(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x70(%rbp)
mov    %cl,-0x1(%rax)
jmp    1594 <__format_grouped_double+0x3f4>
jmp    15e5 <__format_grouped_double+0x445>
jmp    15ea <__format_grouped_double+0x44a>
mov    -0x8a(%rbp),%cl
mov    -0x70(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x70(%rbp)
mov    %cl,-0x1(%rax)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    156a <__format_grouped_double+0x3ca>
jmp    161b <__format_grouped_double+0x47b>
jmp    146e <__format_grouped_double+0x2ce>
cmpl   $0x0,-0x3c(%rbp)
je     168e <__format_grouped_double+0x4ee>
jmp    162f <__format_grouped_double+0x48f>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x9c(%rbp)
cmp    $0x0,%eax
jle    1684 <__format_grouped_double+0x4e4>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
add    %rcx,%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x70(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x70(%rbp)
mov    %cl,-0x1(%rax)
jmp    1638 <__format_grouped_double+0x498>
jmp    1689 <__format_grouped_double+0x4e9>
jmp    168e <__format_grouped_double+0x4ee>
mov    -0x90(%rbp),%ecx
mov    -0x74(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x74(%rbp)
jmp    16e6 <__format_grouped_double+0x546>
mov    -0x3c(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rdi
mov    -0x38(%rbp),%rsi
movslq -0x74(%rbp),%rax
add    %rax,%rsi
mov    -0x3c(%rbp),%edx
call   10a0 <memcpy@plt>
cmpl   $0x0,-0x20(%rbp)
jne    16e1 <__format_grouped_double+0x541>
mov    -0x74(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x74(%rbp)
jmp    16e6 <__format_grouped_double+0x546>
cmpl   $0x0,-0x74(%rbp)
jle    1715 <__format_grouped_double+0x575>
mov    -0x74(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x74(%rbp),%edx
call   1080 <memset@plt>
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    -0x30(%rbp),%rdx
sub    %rdx,%rcx
sub    %rcx,%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x70(%rbp),%rsi
mov    -0x68(%rbp),%rdx
call   10c0 <memmove@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<__format_grouped_double>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %ecx,%r13d
mov    %edx,%r15d
mov    %esi,%ebp
mov    %rdi,%r14
movsd  %xmm0,0x10(%rsp)
xor    %eax,%eax
call   1040 <localeconv@plt>
mov    0x8(%rax),%rcx
mov    (%rcx),%dil
test   %dil,%dil
jne    11d9 <__format_grouped_double+0x39>
mov    0x10(%rax),%rcx
mov    (%rcx),%dil
mov    0x18(%rax),%rcx
mov    (%rcx),%r12b
test   %r12b,%r12b
jne    11ec <__format_grouped_double+0x4c>
mov    0x20(%rax),%rcx
mov    (%rcx),%r12b
xor    %ebx,%ebx
cmp    $0xffffffff,%ebp
cmovne %ebp,%ebx
mov    %r14,0x28(%rsp)
mov    (%r14),%ecx
cmp    $0xffffffff,%r15d
jne    1221 <__format_grouped_double+0x81>
xor    %edx,%edx
test   $0x40,%cl
sete   %dl
mov    0x28(%rax,%rdx,4),%edx
mov    0x2dd3(%rip),%rsi
cmp    (%rsi),%edx
mov    $0x2,%r15d
cmovne %edx,%r15d
mov    (%rax),%r14
test   $0x1,%cl
mov    %dil,0xf(%rsp)
je     123c <__format_grouped_double+0x9c>
mov    %ebx,%edi
mov    %r14,%rsi
call   1050 <get_groups@plt>
add    %ebx,%eax
mov    %eax,%ebx
lea    (%r15,%rbx,1),%ecx
add    $0x1,%ecx
lea    0xdb6(%rip),%rdx
lea    0x30(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x20,%esi
mov    %r15d,%r8d
call   1070 <snprintf@plt>
mov    %rsp,%rdi
mov    %rbx,%rsi
movsd  0x10(%rsp),%xmm0
call   10b0 <asprintf@plt>
test   %eax,%eax
js     1507 <__format_grouped_double+0x367>
mov    %eax,%ebx
mov    (%rsp),%rdi
call   1060 <strlen@plt>
add    %eax,%eax
add    $0x1,%eax
movslq %eax,%rbp
mov    $0x1,%edi
mov    %rbp,%rsi
call   1090 <calloc@plt>
mov    %rax,%rcx
xor    %eax,%eax
test   %rcx,%rcx
je     1563 <__format_grouped_double+0x3c3>
mov    (%rsp),%rsi
cmpb   $0x20,(%rsi)
jne    12cd <__format_grouped_double+0x12d>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpb   $0x20,0x1(%rsi,%rax,1)
lea    0x1(%rax),%rax
je     12c0 <__format_grouped_double+0x120>
sub    %eax,%ebx
mov    %r13d,0x1c(%rsp)
mov    %rcx,0x10(%rsp)
mov    %rbp,0x20(%rsp)
add    %rcx,%rbp
add    $0xffffffffffffffff,%rbp
mov    %eax,%r13d
test   %r15d,%r15d
jle    131a <__format_grouped_double+0x17a>
mov    %r15d,%eax
sub    %rax,%rbp
movslq %ebx,%rbx
add    %rbx,%rsi
add    %r13,%rsi
sub    %rax,%rsi
mov    %rbp,%rdi
mov    %r15d,%edx
call   10a0 <memcpy@plt>
mov    0xf(%rsp),%al
mov    %al,-0x1(%rbp)
add    $0xffffffffffffffff,%rbp
mov    %r15d,%eax
not    %eax
add    %eax,%ebx
mov    0x28(%rsp),%rax
testb  $0x1,(%rax)
je     150b <__format_grouped_double+0x36b>
test   %r12b,%r12b
je     150b <__format_grouped_double+0x36b>
movsbl (%r14),%edx
test   %edx,%edx
jle    150b <__format_grouped_double+0x36b>
mov    0x2ca4(%rip),%r8
cmp    %edx,(%r8)
je     150b <__format_grouped_double+0x36b>
xor    %r10d,%r10d
cmp    %edx,%ebx
jle    1580 <__format_grouped_double+0x3e0>
xor    %r10d,%r10d
jmp    1368 <__format_grouped_double+0x1c8>
nopl   (%rax)
cmp    %edx,%ebx
jle    1580 <__format_grouped_double+0x3e0>
test   %edx,%edx
jle    1412 <__format_grouped_double+0x272>
movslq %ebx,%rbx
lea    -0x1(%rdx),%r9d
mov    %edx,%edi
and    $0x3,%edi
je     13a0 <__format_grouped_double+0x200>
xor    %ecx,%ecx
mov    (%rsp),%rsi
add    %r13,%rsi
movzbl -0x1(%rbx,%rsi,1),%eax
add    $0xffffffffffffffff,%rbx
mov    %al,-0x1(%rbp)
add    $0xffffffffffffffff,%rbp
add    $0x1,%ecx
cmp    %ecx,%edi
jne    1380 <__format_grouped_double+0x1e0>
sub    %ecx,%edx
cmp    $0x3,%r9d
jb     1412 <__format_grouped_double+0x272>
lea    (%rbx,%r13,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(%rbp,%rdx,1)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x2(%rdx,%rax,1),%eax
mov    %al,-0x2(%rbp,%rdx,1)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x3(%rdx,%rax,1),%eax
mov    %al,-0x3(%rbp,%rdx,1)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x4(%rdx,%rax,1),%eax
mov    %al,-0x4(%rbp,%rdx,1)
add    $0xfffffffffffffffc,%rdx
lea    (%rdx,%rdi,1),%eax
cmp    $0xfffffffe,%eax
jb     13c0 <__format_grouped_double+0x220>
add    %rdx,%rbx
add    %rdx,%rbp
mov    %r12b,-0x1(%rbp)
add    $0xffffffffffffffff,%rbp
add    $0x1,%r10d
movsbl 0x1(%r14),%edx
cmp    %edx,(%r8)
je     1580 <__format_grouped_double+0x3e0>
test   %dl,%dl
je     144c <__format_grouped_double+0x2ac>
add    $0x1,%r14
jmp    1360 <__format_grouped_double+0x1c0>
nopl   0x0(%rax)
mov    %r12b,-0x1(%rbp)
add    $0xffffffffffffffff,%rbp
add    $0x1,%r10d
movsbl (%r14),%edx
cmp    %edx,%ebx
jle    1360 <__format_grouped_double+0x1c0>
test   %edx,%edx
jle    1440 <__format_grouped_double+0x2a0>
movslq %ebx,%rbx
lea    -0x1(%rdx),%esi
mov    %edx,%edi
and    $0x3,%edi
je     1490 <__format_grouped_double+0x2f0>
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
mov    (%rsp),%rax
add    %r13,%rax
movzbl -0x1(%rbx,%rax,1),%eax
add    $0xffffffffffffffff,%rbx
mov    %al,-0x1(%rbp)
add    $0xffffffffffffffff,%rbp
add    $0x1,%ecx
cmp    %ecx,%edi
jne    1470 <__format_grouped_double+0x2d0>
sub    %ecx,%edx
cmp    $0x3,%esi
jb     1440 <__format_grouped_double+0x2a0>
lea    (%rbx,%r13,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(%rbp,%rdx,1)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x2(%rdx,%rax,1),%eax
mov    %al,-0x2(%rbp,%rdx,1)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x3(%rdx,%rax,1),%eax
mov    %al,-0x3(%rbp,%rdx,1)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x4(%rdx,%rax,1),%eax
mov    %al,-0x4(%rbp,%rdx,1)
add    $0xfffffffffffffffc,%rdx
lea    (%rdx,%rdi,1),%eax
cmp    $0xfffffffe,%eax
jb     14b0 <__format_grouped_double+0x310>
add    %rdx,%rbx
add    %rdx,%rbp
jmp    1440 <__format_grouped_double+0x2a0>
xor    %ebx,%ebx
jmp    156e <__format_grouped_double+0x3ce>
movslq %ebx,%rdx
sub    %rdx,%rbp
mov    %r13,%rsi
add    (%rsp),%rsi
mov    %rbp,%rdi
call   10a0 <memcpy@plt>
cmp    $0x1,%r15d
sbb    $0x0,%r13d
test   %r13d,%r13d
jle    1542 <__format_grouped_double+0x3a2>
mov    %r13d,%eax
sub    %rax,%rbp
mov    %rbp,%rdi
mov    0x1c(%rsp),%esi
mov    %r13d,%edx
call   1080 <memset@plt>
mov    0x10(%rsp),%rbx
mov    %rbx,%rdx
add    0x20(%rsp),%rdx
sub    %rbp,%rdx
add    $0x1,%rdx
mov    %rbx,%rdi
mov    %rbp,%rsi
call   10c0 <memmove@plt>
jmp    1565 <__format_grouped_double+0x3c5>
xor    %ebx,%ebx
mov    (%rsp),%rdi
call   1030 <free@plt>
mov    %rbx,%rax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
test   %ebx,%ebx
jle    1622 <__format_grouped_double+0x482>
mov    %ebx,%ecx
lea    -0x1(%rbx),%edx
and    $0x3,%ebx
je     15bc <__format_grouped_double+0x41c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rsp),%rax
add    %r13,%rax
movzbl -0x1(%rcx,%rax,1),%eax
add    $0xffffffffffffffff,%rcx
mov    %al,-0x1(%rbp)
add    $0xffffffffffffffff,%rbp
add    $0xffffffff,%ebx
jne    15a0 <__format_grouped_double+0x400>
cmp    $0x3,%edx
jb     1622 <__format_grouped_double+0x482>
lea    (%rcx,%r13,1),%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x1(%rdx,%rax,1),%eax
mov    %al,-0x1(%rbp,%rdx,1)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x2(%rdx,%rax,1),%eax
mov    %al,-0x2(%rbp,%rdx,1)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x3(%rdx,%rax,1),%eax
mov    %al,-0x3(%rbp,%rdx,1)
mov    (%rsp),%rax
add    %rsi,%rax
movzbl -0x4(%rdx,%rax,1),%eax
mov    %al,-0x4(%rbp,%rdx,1)
add    $0xfffffffffffffffc,%rdx
lea    (%rcx,%rdx,1),%eax
add    $0x1,%eax
cmp    $0x1,%eax
jg     15d0 <__format_grouped_double+0x430>
add    %rdx,%rbp
sub    %r10d,%r13d
test   %r13d,%r13d
jg     152d <__format_grouped_double+0x38d>
jmp    1542 <__format_grouped_double+0x3a2>

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

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