#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 /*<<< orphan*/ free(char *);
scalar_t__ get_groups(int, char *);
struct lconv *localeconv();
char *malloc(size_t);
int /*<<< orphan*/ memcpy(char *, char *, int);
int /*<<< orphan*/ memmove(char *, char *, size_t);
int /*<<< orphan*/ memset(char *, int, int);
char *realloc(char *, int);
int snprintf(char *, int, char *, double, ...);
int sprintf(char *, char *, double);
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 = malloc(255);
  if (!avalue)
    return (NULL);
  avalue_size = snprintf(avalue, 255, fmt, value);
  if (255 < avalue_size) {
    avalue = realloc(avalue, avalue_size + 1);
    if (!avalue)
      return (NULL);
    avalue_size = sprintf(avalue, fmt, value);
  }
  if (avalue_size < 0)
    return (NULL);
  bufsize = strlen(avalue) * 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, 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    1220 <__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    1250 <__format_grouped_double+0xa0>
mov    -0x80(%rbp),%rax
mov    0x20(%rax),%rax
mov    (%rax),%al
mov    %al,-0x8a(%rbp)
cmpl   $0xffffffff,-0x1c(%rbp)
jne    1261 <__format_grouped_double+0xb1>
movl   $0x0,-0x1c(%rbp)
cmpl   $0xffffffff,-0x20(%rbp)
jne    12b4 <__format_grouped_double+0x104>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
and    $0x40,%eax
cmp    $0x0,%eax
je     128c <__format_grouped_double+0xdc>
mov    -0x80(%rbp),%rax
mov    0x28(%rax),%eax
mov    %eax,-0x20(%rbp)
jmp    1296 <__format_grouped_double+0xe6>
mov    -0x80(%rbp),%rax
mov    0x2c(%rax),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    0x2d48(%rip),%rcx
cmp    (%rcx),%eax
jne    12af <__format_grouped_double+0xff>
movl   $0x2,-0x20(%rbp)
jmp    12b4 <__format_grouped_double+0x104>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     12e2 <__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),%eax
add    -0x20(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    -0x20(%rbp),%ecx
mov    $0x20,%esi
lea    0xcfe(%rip),%rdx
mov    $0x1,%al
call   1070 <snprintf@plt>
mov    $0xff,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
jne    132f <__format_grouped_double+0x17f>
movq   $0x0,-0x8(%rbp)
jmp    17ed <__format_grouped_double+0x63d>
mov    -0x38(%rbp),%rdi
lea    -0x60(%rbp),%rdx
movsd  -0x10(%rbp),%xmm0
mov    $0xff,%esi
mov    $0x1,%al
call   1070 <snprintf@plt>
mov    %eax,-0x3c(%rbp)
mov    $0xff,%eax
cmp    -0x3c(%rbp),%eax
jge    1399 <__format_grouped_double+0x1e9>
mov    -0x38(%rbp),%rdi
mov    -0x3c(%rbp),%esi
add    $0x1,%esi
call   10b0 <realloc@plt>
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
jne    1384 <__format_grouped_double+0x1d4>
movq   $0x0,-0x8(%rbp)
jmp    17ed <__format_grouped_double+0x63d>
mov    -0x38(%rbp),%rdi
lea    -0x60(%rbp),%rsi
movsd  -0x10(%rbp),%xmm0
call   10d0 <sprintf@plt>
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jge    13b0 <__format_grouped_double+0x200>
movq   $0x0,-0x8(%rbp)
jmp    17ed <__format_grouped_double+0x63d>
mov    -0x38(%rbp),%rdi
call   1060 <strlen@plt>
shl    $0x1,%eax
add    $0x1,%eax
cltq
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    13f3 <__format_grouped_double+0x243>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
movq   $0x0,-0x8(%rbp)
jmp    17ed <__format_grouped_double+0x63d>
mov    -0x30(%rbp),%rdi
mov    -0x68(%rbp),%rax
mov    %eax,%edx
xor    %esi,%esi
call   1080 <memset@plt>
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    1447 <__format_grouped_double+0x297>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    141b <__format_grouped_double+0x26b>
cmpl   $0x0,-0x20(%rbp)
jle    14b7 <__format_grouped_double+0x307>
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   1090 <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     173d <__format_grouped_double+0x58d>
movsbl -0x8a(%rbp),%eax
cmp    $0x0,%eax
je     173d <__format_grouped_double+0x58d>
mov    -0x88(%rbp),%rax
movsbl (%rax),%eax
mov    0x2afe(%rip),%rcx
cmp    (%rcx),%eax
je     173d <__format_grouped_double+0x58d>
mov    -0x88(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jle    173d <__format_grouped_double+0x58d>
jmp    150a <__format_grouped_double+0x35a>
mov    -0x3c(%rbp),%eax
mov    -0x88(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jle    16bc <__format_grouped_double+0x50c>
jmp    1524 <__format_grouped_double+0x374>
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    1580 <__format_grouped_double+0x3d0>
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    1534 <__format_grouped_double+0x384>
jmp    1585 <__format_grouped_double+0x3d5>
jmp    158a <__format_grouped_double+0x3da>
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    0x2a14(%rip),%rcx
cmp    (%rcx),%eax
jne    15e1 <__format_grouped_double+0x431>
jmp    16bc <__format_grouped_double+0x50c>
mov    -0x88(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    16b7 <__format_grouped_double+0x507>
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    16b2 <__format_grouped_double+0x502>
jmp    1620 <__format_grouped_double+0x470>
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    167c <__format_grouped_double+0x4cc>
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    1630 <__format_grouped_double+0x480>
jmp    1681 <__format_grouped_double+0x4d1>
jmp    1686 <__format_grouped_double+0x4d6>
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    1606 <__format_grouped_double+0x456>
jmp    16b7 <__format_grouped_double+0x507>
jmp    150a <__format_grouped_double+0x35a>
cmpl   $0x0,-0x3c(%rbp)
je     172a <__format_grouped_double+0x57a>
jmp    16cb <__format_grouped_double+0x51b>
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    1720 <__format_grouped_double+0x570>
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    16d4 <__format_grouped_double+0x524>
jmp    1725 <__format_grouped_double+0x575>
jmp    172a <__format_grouped_double+0x57a>
mov    -0x90(%rbp),%ecx
mov    -0x74(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x74(%rbp)
jmp    1782 <__format_grouped_double+0x5d2>
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   1090 <memcpy@plt>
cmpl   $0x0,-0x20(%rbp)
jne    177d <__format_grouped_double+0x5cd>
mov    -0x74(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x74(%rbp)
jmp    1782 <__format_grouped_double+0x5d2>
cmpl   $0x0,-0x74(%rbp)
jle    17b1 <__format_grouped_double+0x601>
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    $0x68,%rsp
mov    %ecx,%r14d
mov    %edx,%r13d
mov    %esi,%ebp
mov    %rdi,%r12
movsd  %xmm0,0x30(%rsp)
xor    %eax,%eax
call   1040 <localeconv@plt>
mov    0x8(%rax),%rcx
mov    (%rcx),%r15b
test   %r15b,%r15b
jne    11e9 <__format_grouped_double+0x39>
mov    0x10(%rax),%rcx
mov    (%rcx),%r15b
mov    0x18(%rax),%rcx
mov    (%rcx),%dl
test   %dl,%dl
jne    11f9 <__format_grouped_double+0x49>
mov    0x20(%rax),%rcx
mov    (%rcx),%dl
xor    %ebx,%ebx
cmp    $0xffffffff,%ebp
cmovne %ebp,%ebx
mov    (%r12),%ecx
cmp    $0xffffffff,%r13d
jne    122b <__format_grouped_double+0x7b>
xor    %esi,%esi
test   $0x40,%cl
sete   %sil
mov    0x28(%rax,%rsi,4),%edi
mov    0x2dc9(%rip),%rsi
cmp    (%rsi),%edi
mov    $0x2,%r13d
cmovne %edi,%r13d
mov    (%rax),%rsi
test   $0x1,%cl
mov    %dl,0xb(%rsp)
mov    %rsi,0x28(%rsp)
mov    %r12,0x18(%rsp)
je     124c <__format_grouped_double+0x9c>
mov    %ebx,%edi
call   1050 <get_groups@plt>
add    %ebx,%eax
mov    %eax,%ebx
lea    (%rbx,%r13,1),%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
lea    0xd9f(%rip),%rdx
lea    0x40(%rsp),%rdi
mov    $0x20,%esi
mov    %r13d,%ecx
mov    $0x1,%al
call   1070 <snprintf@plt>
mov    $0xff,%edi
call   10a0 <malloc@plt>
test   %rax,%rax
je     13fa <__format_grouped_double+0x24a>
mov    %rax,%r12
mov    %r14d,0xc(%rsp)
lea    0x40(%rsp),%rdx
mov    %rax,%rdi
mov    $0xff,%esi
movsd  0x30(%rsp),%xmm0
mov    $0x1,%al
call   1070 <snprintf@plt>
mov    %eax,%r14d
cmp    $0x100,%eax
jl     12e5 <__format_grouped_double+0x135>
add    $0x1,%r14d
mov    %r12,%rdi
mov    %r14d,%esi
call   10b0 <realloc@plt>
test   %rax,%rax
je     13fa <__format_grouped_double+0x24a>
mov    %rax,%r12
lea    0x40(%rsp),%rsi
mov    %rax,%rdi
movsd  0x30(%rsp),%xmm0
call   10d0 <sprintf@plt>
mov    %eax,%r14d
test   %r14d,%r14d
js     13fa <__format_grouped_double+0x24a>
mov    %r12,%rdi
call   1060 <strlen@plt>
lea    (%rax,%rax,1),%ebp
add    $0x1,%ebp
movslq %ebp,%rdi
mov    %rdi,0x30(%rsp)
call   10a0 <malloc@plt>
xor    %ebx,%ebx
test   %rax,%rax
je     176d <__format_grouped_double+0x5bd>
mov    %rax,0x10(%rsp)
mov    %rax,%rdi
xor    %esi,%esi
mov    %ebp,%edx
call   1080 <memset@plt>
cmpb   $0x20,(%r12)
jne    133f <__format_grouped_double+0x18f>
xor    %ebx,%ebx
xchg   %ax,%ax
cmpb   $0x20,0x1(%r12,%rbx,1)
lea    0x1(%rbx),%rbx
je     1330 <__format_grouped_double+0x180>
sub    %ebx,%r14d
mov    0x10(%rsp),%rax
mov    0x30(%rsp),%rcx
lea    (%rax,%rcx,1),%rbp
add    $0xffffffffffffffff,%rbp
mov    %ebx,%edx
test   %r13d,%r13d
mov    %rdx,0x20(%rsp)
jle    1390 <__format_grouped_double+0x1e0>
mov    %r13d,%eax
sub    %rax,%rbp
movslq %r14d,%r14
lea    (%r12,%r14,1),%rsi
add    %rdx,%rsi
sub    %rax,%rsi
mov    %rbp,%rdi
mov    %r13d,%edx
call   1090 <memcpy@plt>
mov    0x20(%rsp),%rdx
mov    %r15b,-0x1(%rbp)
add    $0xffffffffffffffff,%rbp
mov    %r13d,%eax
not    %eax
add    %eax,%r14d
mov    0xb(%rsp),%r10b
mov    0x28(%rsp),%rbx
lea    (%r12,%rdx,1),%rsi
mov    0x18(%rsp),%rax
testb  $0x1,(%rax)
je     171d <__format_grouped_double+0x56d>
test   %r10b,%r10b
je     171d <__format_grouped_double+0x56d>
movsbl (%rbx),%ecx
test   %ecx,%ecx
jle    171d <__format_grouped_double+0x56d>
mov    0x2c21(%rip),%rax
cmp    %ecx,(%rax)
je     171d <__format_grouped_double+0x56d>
xor    %r8d,%r8d
cmp    %ecx,%r14d
jle    178a <__format_grouped_double+0x5da>
lea    (%r12,%rdx,1),%r11
add    $0xffffffffffffffff,%r11
lea    (%r12,%rdx,1),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,0x18(%rsp)
xor    %r8d,%r8d
mov    %rsi,0x38(%rsp)
jmp    1419 <__format_grouped_double+0x269>
xor    %r14d,%r14d
jmp    1778 <__format_grouped_double+0x5c8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %ecx,%r14d
jle    178a <__format_grouped_double+0x5da>
test   %ecx,%ecx
jle    1578 <__format_grouped_double+0x3c8>
movslq %r14d,%r14
lea    -0x1(%rcx),%r13d
cmp    $0xf,%r13d
jb     1550 <__format_grouped_double+0x3a0>
mov    %r13,%rax
not    %rax
add    %rbp,%rax
lea    (%rsi,%r14,1),%rdi
cmp    %rdi,%rax
jae    1456 <__format_grouped_double+0x2a6>
mov    %r14,%rax
sub    %r13,%rax
add    %r11,%rax
cmp    %rbp,%rax
jb     1550 <__format_grouped_double+0x3a0>
mov    %rbx,0x28(%rsp)
mov    %r10d,%edx
add    $0x1,%r13
mov    %r13,%r15
movabs $0x1fffffff0,%rax
and    %rax,%r15
lea    -0x10(%r15),%rdi
mov    %rdi,%rax
shr    $0x4,%rax
add    $0x1,%rax
mov    %eax,%r10d
and    $0x3,%r10d
cmp    $0x30,%rdi
jae    1492 <__format_grouped_double+0x2e2>
xor    %edi,%edi
jmp    14ea <__format_grouped_double+0x33a>
movabs $0x1ffffffffffffffc,%rdi
ff ff 1f
and    %rdi,%rax
mov    0x18(%rsp),%rdi
lea    (%rdi,%r14,1),%r9
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups (%r9,%rdi,1),%xmm0
movups %xmm0,-0x10(%rbp,%rdi,1)
movups -0x10(%r9,%rdi,1),%xmm0
movups %xmm0,-0x20(%rbp,%rdi,1)
movups -0x20(%r9,%rdi,1),%xmm0
movups %xmm0,-0x30(%rbp,%rdi,1)
movupd -0x30(%r9,%rdi,1),%xmm0
movupd %xmm0,-0x40(%rbp,%rdi,1)
add    $0xffffffffffffffc0,%rdi
add    $0xfffffffffffffffc,%rax
jne    14b0 <__format_grouped_double+0x300>
neg    %rdi
test   %r10,%r10
je     1527 <__format_grouped_double+0x377>
mov    %r14,%r9
sub    %rdi,%r9
add    0x18(%rsp),%r9
mov    %rbp,%rbx
sub    %rdi,%rbx
add    $0xfffffffffffffff0,%rbx
shl    $0x4,%r10
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movupd (%r9,%rdi,1),%xmm0
movupd %xmm0,(%rbx,%rdi,1)
add    $0xfffffffffffffff0,%rdi
mov    %r10,%rax
add    %rdi,%rax
jne    1510 <__format_grouped_double+0x360>
sub    %r15,%r14
sub    %r15,%rbp
cmp    %r15,%r13
jne    153c <__format_grouped_double+0x38c>
mov    %edx,%r10d
mov    0x28(%rsp),%rbx
jmp    1578 <__format_grouped_double+0x3c8>
sub    %r15d,%ecx
mov    %edx,%r10d
mov    0x28(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
add    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%r11,%r14,1),%eax
add    $0xffffffffffffffff,%r14
mov    %al,-0x1(%rbp)
add    $0xffffffffffffffff,%rbp
add    $0xffffffff,%ecx
cmp    $0x1,%ecx
ja     1560 <__format_grouped_double+0x3b0>
mov    %r10b,-0x1(%rbp)
add    $0xffffffffffffffff,%rbp
add    $0x1,%r8d
movsbl 0x1(%rbx),%ecx
mov    0x2a59(%rip),%rax
cmp    %ecx,(%rax)
je     178a <__format_grouped_double+0x5da>
test   %cl,%cl
je     15bc <__format_grouped_double+0x40c>
add    $0x1,%rbx
jmp    1410 <__format_grouped_double+0x260>
mov    %rsi,%rbx
mov    0x38(%rsp),%rsi
nopl   0x0(%rax)
mov    %r10b,-0x1(%rbp)
add    $0xffffffffffffffff,%rbp
add    $0x1,%r8d
movsbl (%rbx),%ecx
cmp    %ecx,%r14d
jle    1410 <__format_grouped_double+0x260>
test   %ecx,%ecx
jle    15b0 <__format_grouped_double+0x400>
movslq %r14d,%r14
lea    -0x1(%rcx),%r13d
cmp    $0xf,%r13d
jb     16f0 <__format_grouped_double+0x540>
mov    %r13,%rax
not    %rax
add    %rbp,%rax
lea    (%rsi,%r14,1),%rdi
cmp    %rdi,%rax
jae    1601 <__format_grouped_double+0x451>
mov    %r14,%rax
sub    %r13,%rax
add    %r11,%rax
cmp    %rbp,%rax
jb     16f0 <__format_grouped_double+0x540>
mov    %rbx,%rsi
add    $0x1,%r13
mov    %r13,%r15
movabs $0x1fffffff0,%rax
and    %rax,%r15
lea    -0x10(%r15),%rax
mov    %rax,%rbx
shr    $0x4,%rbx
add    $0x1,%rbx
mov    %ebx,%r9d
and    $0x3,%r9d
cmp    $0x30,%rax
jae    1640 <__format_grouped_double+0x490>
xor    %eax,%eax
test   %r9,%r9
jne    169b <__format_grouped_double+0x4eb>
jmp    16d6 <__format_grouped_double+0x526>
movabs $0x1ffffffffffffffc,%rax
ff ff 1f
and    %rax,%rbx
mov    0x18(%rsp),%rax
lea    (%rax,%r14,1),%rdi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rdi,%rax,1),%xmm0
movups %xmm0,-0x10(%rbp,%rax,1)
movups -0x10(%rdi,%rax,1),%xmm0
movups %xmm0,-0x20(%rbp,%rax,1)
movups -0x20(%rdi,%rax,1),%xmm0
movups %xmm0,-0x30(%rbp,%rax,1)
movupd -0x30(%rdi,%rax,1),%xmm0
movupd %xmm0,-0x40(%rbp,%rax,1)
add    $0xffffffffffffffc0,%rax
add    $0xfffffffffffffffc,%rbx
jne    1660 <__format_grouped_double+0x4b0>
neg    %rax
test   %r9,%r9
je     16d6 <__format_grouped_double+0x526>
mov    %r14,%rdi
sub    %rax,%rdi
add    0x18(%rsp),%rdi
mov    %rbp,%rbx
sub    %rax,%rbx
add    $0xfffffffffffffff0,%rbx
shl    $0x4,%r9
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movupd (%rdi,%rax,1),%xmm0
movupd %xmm0,(%rbx,%rax,1)
add    $0xfffffffffffffff0,%rax
mov    %r9,%rdx
add    %rax,%rdx
jne    16c0 <__format_grouped_double+0x510>
sub    %r15,%r14
sub    %r15,%rbp
cmp    %r15,%r13
je     15a4 <__format_grouped_double+0x3f4>
sub    %r15d,%ecx
mov    %rsi,%rbx
mov    0x38(%rsp),%rsi
add    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%r11,%r14,1),%eax
add    $0xffffffffffffffff,%r14
mov    %al,-0x1(%rbp)
add    $0xffffffffffffffff,%rbp
add    $0xffffffff,%ecx
cmp    $0x1,%ecx
ja     1700 <__format_grouped_double+0x550>
jmp    15b0 <__format_grouped_double+0x400>
movslq %r14d,%rdx
sub    %rdx,%rbp
mov    %rbp,%rdi
call   1090 <memcpy@plt>
mov    0x20(%rsp),%rdx
cmp    $0x1,%r13d
sbb    $0x0,%edx
mov    0xc(%rsp),%esi
mov    0x10(%rsp),%r14
test   %edx,%edx
jle    1751 <__format_grouped_double+0x5a1>
mov    %edx,%eax
sub    %rax,%rbp
mov    %rbp,%rdi
call   1080 <memset@plt>
mov    %r14,%rdx
add    0x30(%rsp),%rdx
sub    %rbp,%rdx
add    $0x1,%rdx
mov    %r14,%rdi
mov    %rbp,%rsi
call   10c0 <memmove@plt>
jmp    1770 <__format_grouped_double+0x5c0>
xor    %r14d,%r14d
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r14,%rax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
test   %r14d,%r14d
jle    17af <__format_grouped_double+0x5ff>
mov    %r14d,%r10d
add    $0xffffffff,%r14d
cmp    $0xf,%r14d
jae    17c5 <__format_grouped_double+0x615>
mov    0xc(%rsp),%esi
mov    0x10(%rsp),%r14
mov    0x20(%rsp),%rdx
jmp    18ba <__format_grouped_double+0x70a>
mov    0xc(%rsp),%esi
mov    0x10(%rsp),%r14
mov    0x20(%rsp),%rdx
sub    %r8d,%edx
jmp    1740 <__format_grouped_double+0x590>
mov    %r14,%rax
not    %rax
lea    (%rax,%rbp,1),%rcx
mov    0x20(%rsp),%rdx
lea    (%rdx,%r10,1),%rsi
lea    (%r12,%rsi,1),%rdi
cmp    %rdi,%rcx
jae    17f0 <__format_grouped_double+0x640>
add    %rsi,%rax
add    %r12,%rax
cmp    %rbp,%rax
jb     18b1 <__format_grouped_double+0x701>
add    $0x1,%r14
mov    %r14,%r9
and    $0xfffffffffffffff0,%r9
lea    -0x10(%r9),%rcx
mov    %rcx,%rax
shr    $0x4,%rax
add    $0x1,%rax
mov    %eax,%r11d
and    $0x3,%r11d
cmp    $0x30,%rcx
jae    181b <__format_grouped_double+0x66b>
xor    %ebx,%ebx
jmp    185f <__format_grouped_double+0x6af>
and    $0xfffffffffffffffc,%rax
lea    (%r12,%rsi,1),%rcx
add    $0xfffffffffffffff0,%rcx
xor    %ebx,%ebx
movups (%rcx,%rbx,1),%xmm0
movups %xmm0,-0x10(%rbp,%rbx,1)
movups -0x10(%rcx,%rbx,1),%xmm0
movups %xmm0,-0x20(%rbp,%rbx,1)
movups -0x20(%rcx,%rbx,1),%xmm0
movups %xmm0,-0x30(%rbp,%rbx,1)
movupd -0x30(%rcx,%rbx,1),%xmm0
movupd %xmm0,-0x40(%rbp,%rbx,1)
add    $0xffffffffffffffc0,%rbx
add    $0xfffffffffffffffc,%rax
jne    1829 <__format_grouped_double+0x679>
neg    %rbx
test   %r11,%r11
je     1895 <__format_grouped_double+0x6e5>
sub    %rbx,%rsi
lea    (%rsi,%r12,1),%rax
add    $0xfffffffffffffff0,%rax
mov    %rbp,%rcx
sub    %rbx,%rcx
add    $0xfffffffffffffff0,%rcx
shl    $0x4,%r11
xor    %esi,%esi
movupd (%rax,%rsi,1),%xmm0
movupd %xmm0,(%rcx,%rsi,1)
add    $0xfffffffffffffff0,%rsi
mov    %r11,%rdi
add    %rsi,%rdi
jne    187f <__format_grouped_double+0x6cf>
sub    %r9,%rbp
cmp    %r9,%r14
jne    18ae <__format_grouped_double+0x6fe>
mov    0xc(%rsp),%esi
mov    0x10(%rsp),%r14
sub    %r8d,%edx
jmp    1740 <__format_grouped_double+0x590>
sub    %r9,%r10
mov    0xc(%rsp),%esi
mov    0x10(%rsp),%r14
lea    0x1(%r10),%eax
add    %rdx,%r10
lea    (%r12,%r10,1),%rcx
add    $0xffffffffffffffff,%rcx
nopl   0x0(%rax)
movzbl (%rcx),%ebx
mov    %bl,-0x1(%rbp)
add    $0xffffffffffffffff,%rbp
add    $0xffffffff,%eax
add    $0xffffffffffffffff,%rcx
cmp    $0x1,%eax
jg     18d0 <__format_grouped_double+0x720>
sub    %r8d,%edx
jmp    1740 <__format_grouped_double+0x590>

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 = sitofp i32 %100 to double
%102 = load i32, i32* %10
%103 = call i32 (i8*, i32, i8*, double, ...) @snprintf(i8* %96, i32 32, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), double %101, i32 %102)
%104 = call i8* @malloc(i64 255)
store i8* %104, i8** %13
%105 = load i8*, i8** %13
%106 = icmp ne i8* %105, null
br i1 %106, label %108, label %107
107: ; preds = %95
store i8* null, i8** %6
br label %387
108: ; preds = %95
%109 = load i8*, i8** %13
%110 = getelementptr inbounds [32 x i8], [32 x i8]* %15, i64 0, i64 0
%111 = load double, double* %7
%112 = call i32 (i8*, i32, i8*, double, ...) @snprintf(i8* %109, i32 255, i8* %110, double %111)
store i32 %112, i32* %14
%113 = load i32, i32* %14
%114 = icmp slt i32 255, %113
br i1 %114, label %115, label %128
115: ; preds = %108
%116 = load i8*, i8** %13
%117 = load i32, i32* %14
%118 = add nsw i32 %117, 1
%119 = call i8* @realloc(i8* %116, i32 %118)
store i8* %119, i8** %13
%120 = load i8*, i8** %13
%121 = icmp ne i8* %120, null
br i1 %121, label %123, label %122
122: ; preds = %115
store i8* null, i8** %6
br label %387
123: ; preds = %115
%124 = load i8*, i8** %13
%125 = getelementptr inbounds [32 x i8], [32 x i8]* %15, i64 0, i64 0
%126 = load double, double* %7
%127 = call i32 @sprintf(i8* %124, i8* %125, double %126)
store i32 %127, i32* %14
br label %128
128: ; preds = %123, %108
%129 = load i32, i32* %14
%130 = icmp slt i32 %129, 0
br i1 %130, label %131, label %132
131: ; preds = %128
store i8* null, i8** %6
br label %387
132: ; preds = %128
%133 = load i8*, i8** %13
%134 = call i32 @strlen(i8* %133)
%135 = mul nsw i32 %134, 2
%136 = add nsw i32 %135, 1
%137 = sext i32 %136 to i64
store i64 %137, i64* %16
%138 = load i64, i64* %16
%139 = call i8* @malloc(i64 %138)
store i8* %139, i8** %12
%140 = load i8*, i8** %12
%141 = icmp eq i8* %140, null
br i1 %141, label %142, label %145
142: ; preds = %132
%143 = load i8*, i8** %13
%144 = call i32 @free(i8* %143)
store i8* null, i8** %6
br label %387
145: ; preds = %132
%146 = load i8*, i8** %12
%147 = load i64, i64* %16
%148 = trunc i64 %147 to i32
%149 = call i32 @memset(i8* %146, i32 0, i32 %148)
%150 = load i8*, i8** %12
%151 = load i64, i64* %16
%152 = getelementptr inbounds i8, i8* %150, i64 %151
%153 = getelementptr inbounds i8, i8* %152, i64 -1
store i8* %153, i8** %17
store i32 0, i32* %18
br label %154
154: ; preds = %162, %145
%155 = load i8*, i8** %13
%156 = load i32, i32* %18
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i8, i8* %155, i64 %157
%159 = load i8, i8* %158
%160 = sext i8 %159 to i32
%161 = icmp eq i32 %160, 32
br i1 %161, label %162, label %167
162: ; preds = %154
%163 = load i32, i32* %18
%164 = add nsw i32 %163, 1
store i32 %164, i32* %18
%165 = load i32, i32* %14
%166 = add nsw i32 %165, -1
store i32 %166, i32* %14
br label %154
167: ; preds = %154
%168 = load i32, i32* %10
%169 = icmp sgt i32 %168, 0
br i1 %169, label %170, label %197
170: ; preds = %167
%171 = load i32, i32* %10
%172 = load i8*, i8** %17
%173 = sext i32 %171 to i64
%174 = sub i64 0, %173
%175 = getelementptr inbounds i8, i8* %172, i64 %174
store i8* %175, i8** %17
%176 = load i8*, i8** %17
%177 = load i8*, i8** %13
%178 = load i32, i32* %14
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds i8, i8* %177, i64 %179
%181 = load i32, i32* %18
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds i8, i8* %180, i64 %182
%184 = load i32, i32* %10
%185 = sext i32 %184 to i64
%186 = sub i64 0, %185
%187 = getelementptr inbounds i8, i8* %183, i64 %186
%188 = load i32, i32* %10
%189 = call i32 @memcpy(i8* %176, i8* %187, i32 %188)
%190 = load i8, i8* %21
%191 = load i8*, i8** %17
%192 = getelementptr inbounds i8, i8* %191, i32 -1
store i8* %192, i8** %17
store i8 %190, i8* %192
%193 = load i32, i32* %10
%194 = add nsw i32 %193, 1
%195 = load i32, i32* %14
%196 = sub nsw i32 %195, %194
store i32 %196, i32* %14
br label %197
197: ; preds = %170, %167
%198 = load i32*, i32** %8
%199 = load i32, i32* %198
%200 = and i32 %199, 1
%201 = icmp ne i32 %200, 0
br i1 %201, label %202, label %339
202: ; preds = %197
%203 = load i8, i8* %22
%204 = sext i8 %203 to i32
%205 = icmp ne i32 %204, 0
br i1 %205, label %206, label %339
206: ; preds = %202
%207 = load i8*, i8** %20
%208 = load i8, i8* %207
%209 = sext i8 %208 to i32
%210 = load i32, i32* @CHAR_MAX
%211 = icmp ne i32 %209, %210
br i1 %211, label %212, label %339
212: ; preds = %206
%213 = load i8*, i8** %20
%214 = load i8, i8* %213
%215 = sext i8 %214 to i32
%216 = icmp sgt i32 %215, 0
br i1 %216, label %217, label %339
217: ; preds = %212
br label %218
218: ; preds = %309, %217
%219 = load i32, i32* %14
%220 = load i8*, i8** %20
%221 = load i8, i8* %220
%222 = sext i8 %221 to i32
%223 = icmp sgt i32 %219, %222
br i1 %223, label %224, label %310
224: ; preds = %218
br label %225
225: ; preds = %224
%226 = load i8*, i8** %20
%227 = load i8, i8* %226
%228 = sext i8 %227 to i32
store i32 %228, i32* %24
br label %229
229: ; preds = %233, %225
%230 = load i32, i32* %24
%231 = add nsw i32 %230, -1
store i32 %231, i32* %24
%232 = icmp sgt i32 %230, 0
br i1 %232, label %233, label %246
233: ; preds = %229
%234 = load i32, i32* %14
%235 = add nsw i32 %234, -1
store i32 %235, i32* %14
%236 = load i8*, i8** %13
%237 = load i32, i32* %14
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds i8, i8* %236, i64 %238
%240 = load i32, i32* %18
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds i8, i8* %239, i64 %241
%243 = load i8, i8* %242
%244 = load i8*, i8** %17
%245 = getelementptr inbounds i8, i8* %244, i32 -1
store i8* %245, i8** %17
store i8 %243, i8* %245
br label %229
246: ; preds = %229
br label %247
247: ; preds = %246
br label %248
248: ; preds = %247
%249 = load i8, i8* %22
%250 = load i8*, i8** %17
%251 = getelementptr inbounds i8, i8* %250, i32 -1
store i8* %251, i8** %17
store i8 %249, i8* %251
%252 = load i32, i32* %23
%253 = add nsw i32 %252, 1
store i32 %253, i32* %23
br label %254
254: ; preds = %248
%255 = load i8*, i8** %20
%256 = getelementptr inbounds i8, i8* %255, i32 1
store i8* %256, i8** %20
%257 = load i8*, i8** %20
%258 = load i8, i8* %257
%259 = sext i8 %258 to i32
%260 = load i32, i32* @CHAR_MAX
%261 = icmp eq i32 %259, %260
br i1 %261, label %262, label %263
262: ; preds = %254
br label %310
263: ; preds = %254
%264 = load i8*, i8** %20
%265 = load i8, i8* %264
%266 = sext i8 %265 to i32
%267 = icmp eq i32 %266, 0
br i1 %267, label %268, label %309
268: ; preds = %263
%269 = load i8*, i8** %20
%270 = getelementptr inbounds i8, i8* %269, i32 -1
store i8* %270, i8** %20
br label %271
271: ; preds = %307, %268
%272 = load i32, i32* %14
%273 = load i8*, i8** %20
%274 = load i8, i8* %273
%275 = sext i8 %274 to i32
%276 = icmp sgt i32 %272, %275
br i1 %276, label %277, label %308
277: ; preds = %271
br label %278
278: ; preds = %277
%279 = load i8*, i8** %20
%280 = load i8, i8* %279
%281 = sext i8 %280 to i32
store i32 %281, i32* %25
br label %282
282: ; preds = %286, %278
%283 = load i32, i32* %25
%284 = add nsw i32 %283, -1
store i32 %284, i32* %25
%285 = icmp sgt i32 %283, 0
br i1 %285, label %286, label %299
286: ; preds = %282
%287 = load i32, i32* %14
%288 = add nsw i32 %287, -1
store i32 %288, i32* %14
%289 = load i8*, i8** %13
%290 = load i32, i32* %14
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds i8, i8* %289, i64 %291
%293 = load i32, i32* %18
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds i8, i8* %292, i64 %294
%296 = load i8, i8* %295
%297 = load i8*, i8** %17
%298 = getelementptr inbounds i8, i8* %297, i32 -1
store i8* %298, i8** %17
store i8 %296, i8* %298
br label %282
299: ; preds = %282
br label %300
300: ; preds = %299
br label %301
301: ; preds = %300
%302 = load i8, i8* %22
%303 = load i8*, i8** %17
%304 = getelementptr inbounds i8, i8* %303, i32 -1
store i8* %304, i8** %17
store i8 %302, i8* %304
%305 = load i32, i32* %23
%306 = add nsw i32 %305, 1
store i32 %306, i32* %23
br label %307
307: ; preds = %301
br label %271
308: ; preds = %271
br label %309
309: ; preds = %308, %263
br label %218
310: ; preds = %262, %218
%311 = load i32, i32* %14
%312 = icmp ne i32 %311, 0
br i1 %312, label %313, label %335
313: ; preds = %310
br label %314
314: ; preds = %313
%315 = load i32, i32* %14
store i32 %315, i32* %26
br label %316
316: ; preds = %320, %314
%317 = load i32, i32* %26
%318 = add nsw i32 %317, -1
store i32 %318, i32* %26
%319 = icmp sgt i32 %317, 0
br i1 %319, label %320, label %333
320: ; preds = %316
%321 = load i32, i32* %14
%322 = add nsw i32 %321, -1
store i32 %322, i32* %14
%323 = load i8*, i8** %13
%324 = load i32, i32* %14
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds i8, i8* %323, i64 %325
%327 = load i32, i32* %18
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds i8, i8* %326, i64 %328
%330 = load i8, i8* %329
%331 = load i8*, i8** %17
%332 = getelementptr inbounds i8, i8* %331, i32 -1
store i8* %332, i8** %17
store i8 %330, i8* %332
br label %316
333: ; preds = %316
br label %334
334: ; preds = %333
br label %335
335: ; preds = %334, %310
%336 = load i32, i32* %23
%337 = load i32, i32* %18
%338 = sub nsw i32 %337, %336
store i32 %338, i32* %18
br label %358
339: ; preds = %212, %206, %202, %197
%340 = load i32, i32* %14
%341 = load i8*, i8** %17
%342 = sext i32 %340 to i64
%343 = sub i64 0, %342
%344 = getelementptr inbounds i8, i8* %341, i64 %343
store i8* %344, i8** %17
%345 = load i8*, i8** %17
%346 = load i8*, i8** %13
%347 = load i32, i32* %18
%348 = sext i32 %347 to i64
%349 = getelementptr inbounds i8, i8* %346, i64 %348
%350 = load i32, i32* %14
%351 = call i32 @memcpy(i8* %345, i8* %349, i32 %350)
%352 = load i32, i32* %10
%353 = icmp eq i32 %352, 0
br i1 %353, label %354, label %357
354: ; preds = %339
%355 = load i32, i32* %18
%356 = add nsw i32 %355, -1
store i32 %356, i32* %18
br label %357
357: ; preds = %354, %339
br label %358
358: ; preds = %357, %335
%359 = load i32, i32* %18
%360 = icmp sgt i32 %359, 0
br i1 %360, label %361, label %371
361: ; preds = %358
%362 = load i32, i32* %18
%363 = load i8*, i8** %17
%364 = sext i32 %362 to i64
%365 = sub i64 0, %364
%366 = getelementptr inbounds i8, i8* %363, i64 %365
store i8* %366, i8** %17
%367 = load i8*, i8** %17
%368 = load i32, i32* %11
%369 = load i32, i32* %18
%370 = call i32 @memset(i8* %367, i32 %368, i32 %369)
br label %371
371: ; preds = %361, %358
%372 = load i64, i64* %16
%373 = load i8*, i8** %17
%374 = load i8*, i8** %12
%375 = ptrtoint i8* %373 to i64
%376 = ptrtoint i8* %374 to i64
%377 = sub i64 %375, %376
%378 = sub i64 %372, %377
%379 = add i64 %378, 1
store i64 %379, i64* %16
%380 = load i8*, i8** %12
%381 = load i8*, i8** %17
%382 = load i64, i64* %16
%383 = call i32 @memmove(i8* %380, i8* %381, i64 %382)
%384 = load i8*, i8** %13
%385 = call i32 @free(i8* %384)
%386 = load i8*, i8** %12
store i8* %386, i8** %6
br label %387
387: ; preds = %371, %142, %131, %122, %107
%388 = load i8*, i8** %6
ret i8* %388
}

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 [32 x i8]
%7 = getelementptr inbounds [32 x i8], [32 x i8]* %6, i64 0, i64 0
%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 = sitofp i32 %56 to double
%58 = call i32 (i8*, i32, i8*, double, ...) @snprintf(i8* %7, i32 32, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), double %57, i32 %46)
%59 = call dereferenceable_or_null(255) i8* @malloc(i64 255)
%60 = icmp eq i8* %59, null
br i1 %60, label %571, label %61
61: ; preds = %53
%62 = call i32 (i8*, i32, i8*, double, ...) @snprintf(i8* %59, i32 255, i8* %7, double %0)
%63 = icmp sgt i32 %62, 255
br i1 %63, label %64, label %70
64: ; preds = %61
%65 = add nuw nsw i32 %62, 1
%66 = call i8* @realloc(i8* %59, i32 %65)
%67 = icmp eq i8* %66, null
br i1 %67, label %571, label %68
68: ; preds = %64
%69 = call i32 @sprintf(i8* %66, i8* %7, double %0)
br label %70
70: ; preds = %68, %61
%71 = phi i8* [ %66, %68 ], [ %59, %61 ]
%72 = phi i32 [ %69, %68 ], [ %62, %61 ]
%73 = icmp slt i32 %72, 0
br i1 %73, label %571, label %74
74: ; preds = %70
%75 = call i32 @strlen(i8* %71)
%76 = shl nsw i32 %75, 1
%77 = or i32 %76, 1
%78 = sext i32 %77 to i64
%79 = call i8* @malloc(i64 %78)
%80 = icmp eq i8* %79, null
br i1 %80, label %568, label %81
81: ; preds = %74
%82 = call i32 @memset(i8* %79, i32 0, i32 %77)
%83 = getelementptr inbounds i8, i8* %79, i64 %78
%84 = getelementptr inbounds i8, i8* %83, i64 -1
%85 = load i8, i8* %71
%86 = icmp eq i8 %85, 32
br i1 %86, label %87, label %97
87: ; preds = %81, %87
%88 = phi i64 [ %90, %87 ], [ 0, %81 ]
%89 = phi i32 [ %91, %87 ], [ %72, %81 ]
%90 = add nuw nsw i64 %88, 1
%91 = add nsw i32 %89, -1
%92 = getelementptr inbounds i8, i8* %71, i64 %90
%93 = load i8, i8* %92
%94 = icmp eq i8 %93, 32
br i1 %94, label %87, label %95
95: ; preds = %87
%96 = trunc i64 %90 to i32
br label %97
97: ; preds = %95, %81
%98 = phi i32 [ 0, %81 ], [ %96, %95 ]
%99 = phi i32 [ %72, %81 ], [ %91, %95 ]
%100 = zext i32 %98 to i64
%101 = getelementptr inbounds i8, i8* %71, i64 %100
%102 = icmp sgt i32 %46, 0
br i1 %102, label %103, label %115
103: ; preds = %97
%104 = zext i32 %46 to i64
%105 = sub nsw i64 0, %104
%106 = getelementptr inbounds i8, i8* %84, i64 %105
%107 = sext i32 %99 to i64
%108 = getelementptr inbounds i8, i8* %71, i64 %107
%109 = getelementptr inbounds i8, i8* %108, i64 %100
%110 = getelementptr inbounds i8, i8* %109, i64 %105
%111 = call i32 @memcpy(i8* %106, i8* %110, i32 %46)
%112 = getelementptr inbounds i8, i8* %106, i64 -1
store i8 %20, i8* %112
%113 = xor i32 %46, -1
%114 = add i32 %99, %113
br label %115
115: ; preds = %103, %97
%116 = phi i32 [ %114, %103 ], [ %99, %97 ]
%117 = phi i8* [ %112, %103 ], [ %84, %97 ]
%118 = load i32, i32* %1
%119 = and i32 %118, 1
%120 = icmp ne i32 %119, 0
%121 = icmp ne i8 %30, 0
%122 = select i1 %120, i1 %121, i1 false
br i1 %122, label %123, label %543
123: ; preds = %115
%124 = load i8, i8* %10
%125 = sext i8 %124 to i32
%126 = load i32, i32* @CHAR_MAX
%127 = icmp ne i32 %126, %125
%128 = icmp sgt i8 %124, 0
%129 = and i1 %128, %127
br i1 %129, label %130, label %543
130: ; preds = %123
%131 = icmp sgt i32 %116, %125
br i1 %131, label %132, label %423
132: ; preds = %130
%133 = getelementptr inbounds i8, i8* %71, i64 %100
%134 = getelementptr inbounds i8, i8* %71, i64 %100
%135 = add nsw i64 %100, -1
%136 = getelementptr i8, i8* %71, i64 %135
%137 = getelementptr i8, i8* %71, i64 %100
%138 = add nsw i64 %100, -1
%139 = getelementptr i8, i8* %71, i64 %138
%140 = getelementptr i8, i8* %71, i64 %100
%141 = getelementptr inbounds i8, i8* %133, i64 -15
%142 = getelementptr inbounds i8, i8* %133, i64 -15
%143 = getelementptr inbounds i8, i8* %133, i64 -15
%144 = getelementptr inbounds i8, i8* %133, i64 -15
%145 = getelementptr inbounds i8, i8* %133, i64 -15
%146 = getelementptr inbounds i8, i8* %134, i64 -15
%147 = getelementptr inbounds i8, i8* %134, i64 -15
%148 = getelementptr inbounds i8, i8* %134, i64 -15
%149 = getelementptr inbounds i8, i8* %134, i64 -15
%150 = getelementptr inbounds i8, i8* %134, i64 -15
br label %151
151: ; preds = %132, %416
%152 = phi i32 [ %417, %416 ], [ %125, %132 ]
%153 = phi i32 [ %421, %416 ], [ 0, %132 ]
%154 = phi i8* [ %420, %416 ], [ %10, %132 ]
%155 = phi i8* [ %419, %416 ], [ %117, %132 ]
%156 = phi i32 [ %418, %416 ], [ %116, %132 ]
%157 = icmp sgt i32 %152, 0
br i1 %157, label %158, label %271
158: ; preds = %151
%159 = sext i32 %156 to i64
%160 = add nsw i32 %152, -1
%161 = zext i32 %160 to i64
%162 = add nuw nsw i64 %161, 1
%163 = icmp ult i32 %160, 15
br i1 %163, label %253, label %164
164: ; preds = %158
%165 = getelementptr i8, i8* %155, i64 -1
%166 = add nsw i32 %152, -1
%167 = zext i32 %166 to i64
%168 = sub nsw i64 0, %167
%169 = getelementptr i8, i8* %165, i64 %168
%170 = sub nsw i64 %159, %167
%171 = getelementptr i8, i8* %139, i64 %170
%172 = getelementptr i8, i8* %140, i64 %159
%173 = icmp ult i8* %169, %172
%174 = icmp ult i8* %171, %155
%175 = and i1 %173, %174
br i1 %175, label %253, label %176
176: ; preds = %164
%177 = and i64 %162, 8589934576
%178 = sub nsw i64 %159, %177
%179 = trunc i64 %177 to i32
%180 = sub i32 %152, %179
%181 = sub nsw i64 0, %177
%182 = getelementptr i8, i8* %155, i64 %181
%183 = add nsw i64 %177, -16
%184 = lshr exact i64 %183, 4
%185 = add nuw nsw i64 %184, 1
%186 = and i64 %185, 3
%187 = icmp ult i64 %183, 48
br i1 %187, label %232, label %188
188: ; preds = %176
%189 = and i64 %185, 2305843009213693948
%190 = getelementptr i8, i8* %155, i64 -16
%191 = getelementptr i8, i8* %155, i64 -16
%192 = getelementptr i8, i8* %155, i64 -16
%193 = getelementptr i8, i8* %155, i64 -16
br label %194
194: ; preds = %194, %188
%195 = phi i64 [ 0, %188 ], [ %229, %194 ]
%196 = phi i64 [ 0, %188 ], [ %230, %194 ]
%197 = sub i64 0, %195
%198 = xor i64 %195, -1
%199 = add i64 %198, %159
%200 = getelementptr inbounds i8, i8* %141, i64 %199
%201 = bitcast i8* %200 to <16 x i8>*
%202 = load <16 x i8>, <16 x i8>* %201
%203 = getelementptr inbounds i8, i8* %190, i64 %197
%204 = bitcast i8* %203 to <16 x i8>*
store <16 x i8> %202, <16 x i8>* %204
%205 = sub nuw nsw i64 -16, %195
%206 = sub nuw nsw i64 -17, %195
%207 = add i64 %206, %159
%208 = getelementptr inbounds i8, i8* %142, i64 %207
%209 = bitcast i8* %208 to <16 x i8>*
%210 = load <16 x i8>, <16 x i8>* %209
%211 = getelementptr inbounds i8, i8* %191, i64 %205
%212 = bitcast i8* %211 to <16 x i8>*
store <16 x i8> %210, <16 x i8>* %212
%213 = sub nuw nsw i64 -32, %195
%214 = sub nuw nsw i64 -33, %195
%215 = add i64 %214, %159
%216 = getelementptr inbounds i8, i8* %143, i64 %215
%217 = bitcast i8* %216 to <16 x i8>*
%218 = load <16 x i8>, <16 x i8>* %217
%219 = getelementptr inbounds i8, i8* %192, i64 %213
%220 = bitcast i8* %219 to <16 x i8>*
store <16 x i8> %218, <16 x i8>* %220
%221 = sub nuw nsw i64 -48, %195
%222 = sub nuw nsw i64 -49, %195
%223 = add i64 %222, %159
%224 = getelementptr inbounds i8, i8* %144, i64 %223
%225 = bitcast i8* %224 to <16 x i8>*
%226 = load <16 x i8>, <16 x i8>* %225
%227 = getelementptr inbounds i8, i8* %193, i64 %221
%228 = bitcast i8* %227 to <16 x i8>*
store <16 x i8> %226, <16 x i8>* %228
%229 = add nuw i64 %195, 64
%230 = add i64 %196, 4
%231 = icmp eq i64 %230, %189
br i1 %231, label %232, label %194
232: ; preds = %194, %176
%233 = phi i64 [ 0, %176 ], [ %229, %194 ]
%234 = icmp eq i64 %186, 0
br i1 %234, label %251, label %235
235: ; preds = %232
%236 = getelementptr i8, i8* %155, i64 -16
br label %237
237: ; preds = %237, %235
%238 = phi i64 [ %233, %235 ], [ %248, %237 ]
%239 = phi i64 [ 0, %235 ], [ %249, %237 ]
%240 = sub i64 0, %238
%241 = xor i64 %238, -1
%242 = add i64 %241, %159
%243 = getelementptr inbounds i8, i8* %145, i64 %242
%244 = bitcast i8* %243 to <16 x i8>*
%245 = load <16 x i8>, <16 x i8>* %244
%246 = getelementptr inbounds i8, i8* %236, i64 %240
%247 = bitcast i8* %246 to <16 x i8>*
store <16 x i8> %245, <16 x i8>* %247
%248 = add nuw i64 %238, 16
%249 = add i64 %239, 1
%250 = icmp eq i64 %249, %186
br i1 %250, label %251, label %237
251: ; preds = %237, %232
%252 = icmp eq i64 %162, %177
br i1 %252, label %267, label %253
253: ; preds = %164, %158, %251
%254 = phi i64 [ %159, %164 ], [ %159, %158 ], [ %178, %251 ]
%255 = phi i32 [ %152, %164 ], [ %152, %158 ], [ %180, %251 ]
%256 = phi i8* [ %155, %164 ], [ %155, %158 ], [ %182, %251 ]
br label %257
257: ; preds = %253, %257
%258 = phi i64 [ %262, %257 ], [ %254, %253 ]
%259 = phi i32 [ %261, %257 ], [ %255, %253 ]
%260 = phi i8* [ %265, %257 ], [ %256, %253 ]
%261 = add nsw i32 %259, -1
%262 = add nsw i64 %258, -1
%263 = getelementptr inbounds i8, i8* %133, i64 %262
%264 = load i8, i8* %263
%265 = getelementptr inbounds i8, i8* %260, i64 -1
store i8 %264, i8* %265
%266 = icmp ugt i32 %259, 1
br i1 %266, label %257, label %267
267: ; preds = %257, %251
%268 = phi i64 [ %178, %251 ], [ %262, %257 ]
%269 = phi i8* [ %182, %251 ], [ %265, %257 ]
%270 = trunc i64 %268 to i32
br label %271
271: ; preds = %267, %151
%272 = phi i32 [ %156, %151 ], [ %270, %267 ]
%273 = phi i8* [ %155, %151 ], [ %269, %267 ]
%274 = getelementptr inbounds i8, i8* %273, i64 -1
store i8 %30, i8* %274
%275 = add nsw i32 %153, 1
%276 = getelementptr inbounds i8, i8* %154, i64 1
%277 = load i8, i8* %276
%278 = sext i8 %277 to i32
%279 = load i32, i32* @CHAR_MAX
%280 = icmp eq i32 %279, %278
br i1 %280, label %423, label %281
281: ; preds = %271
%282 = icmp eq i8 %277, 0
br i1 %282, label %283, label %416
283: ; preds = %281
%284 = load i8, i8* %154
%285 = sext i8 %284 to i32
%286 = icmp sgt i32 %272, %285
br i1 %286, label %287, label %416
287: ; preds = %283, %406
%288 = phi i32 [ %412, %406 ], [ %285, %283 ]
%289 = phi i32 [ %410, %406 ], [ %275, %283 ]
%290 = phi i8* [ %409, %406 ], [ %274, %283 ]
%291 = phi i32 [ %407, %406 ], [ %272, %283 ]
%292 = icmp sgt i32 %288, 0
br i1 %292, label %293, label %406
293: ; preds = %287
%294 = sext i32 %291 to i64
%295 = add nsw i32 %288, -1
%296 = zext i32 %295 to i64
%297 = add nuw nsw i64 %296, 1
%298 = icmp ult i32 %295, 15
br i1 %298, label %388, label %299
299: ; preds = %293
%300 = getelementptr i8, i8* %290, i64 -1
%301 = add nsw i32 %288, -1
%302 = zext i32 %301 to i64
%303 = sub nsw i64 0, %302
%304 = getelementptr i8, i8* %300, i64 %303
%305 = sub nsw i64 %294, %302
%306 = getelementptr i8, i8* %136, i64 %305
%307 = getelementptr i8, i8* %137, i64 %294
%308 = icmp ult i8* %304, %307
%309 = icmp ult i8* %306, %290
%310 = and i1 %308, %309
br i1 %310, label %388, label %311
311: ; preds = %299
%312 = and i64 %297, 8589934576
%313 = sub nsw i64 %294, %312
%314 = trunc i64 %312 to i32
%315 = sub i32 %288, %314
%316 = sub nsw i64 0, %312
%317 = getelementptr i8, i8* %290, i64 %316
%318 = add nsw i64 %312, -16
%319 = lshr exact i64 %318, 4
%320 = add nuw nsw i64 %319, 1
%321 = and i64 %320, 3
%322 = icmp ult i64 %318, 48
br i1 %322, label %367, label %323
323: ; preds = %311
%324 = and i64 %320, 2305843009213693948
%325 = getelementptr i8, i8* %290, i64 -16
%326 = getelementptr i8, i8* %290, i64 -16
%327 = getelementptr i8, i8* %290, i64 -16
%328 = getelementptr i8, i8* %290, i64 -16
br label %329
329: ; preds = %329, %323
%330 = phi i64 [ 0, %323 ], [ %364, %329 ]
%331 = phi i64 [ 0, %323 ], [ %365, %329 ]
%332 = sub i64 0, %330
%333 = xor i64 %330, -1
%334 = add i64 %333, %294
%335 = getelementptr inbounds i8, i8* %146, i64 %334
%336 = bitcast i8* %335 to <16 x i8>*
%337 = load <16 x i8>, <16 x i8>* %336
%338 = getelementptr inbounds i8, i8* %325, i64 %332
%339 = bitcast i8* %338 to <16 x i8>*
store <16 x i8> %337, <16 x i8>* %339
%340 = sub nuw nsw i64 -16, %330
%341 = sub nuw nsw i64 -17, %330
%342 = add i64 %341, %294
%343 = getelementptr inbounds i8, i8* %147, i64 %342
%344 = bitcast i8* %343 to <16 x i8>*
%345 = load <16 x i8>, <16 x i8>* %344
%346 = getelementptr inbounds i8, i8* %326, i64 %340
%347 = bitcast i8* %346 to <16 x i8>*
store <16 x i8> %345, <16 x i8>* %347
%348 = sub nuw nsw i64 -32, %330
%349 = sub nuw nsw i64 -33, %330
%350 = add i64 %349, %294
%351 = getelementptr inbounds i8, i8* %148, i64 %350
%352 = bitcast i8* %351 to <16 x i8>*
%353 = load <16 x i8>, <16 x i8>* %352
%354 = getelementptr inbounds i8, i8* %327, i64 %348
%355 = bitcast i8* %354 to <16 x i8>*
store <16 x i8> %353, <16 x i8>* %355
%356 = sub nuw nsw i64 -48, %330
%357 = sub nuw nsw i64 -49, %330
%358 = add i64 %357, %294
%359 = getelementptr inbounds i8, i8* %149, i64 %358
%360 = bitcast i8* %359 to <16 x i8>*
%361 = load <16 x i8>, <16 x i8>* %360
%362 = getelementptr inbounds i8, i8* %328, i64 %356
%363 = bitcast i8* %362 to <16 x i8>*
store <16 x i8> %361, <16 x i8>* %363
%364 = add nuw i64 %330, 64
%365 = add i64 %331, 4
%366 = icmp eq i64 %365, %324
br i1 %366, label %367, label %329
367: ; preds = %329, %311
%368 = phi i64 [ 0, %311 ], [ %364, %329 ]
%369 = icmp eq i64 %321, 0
br i1 %369, label %386, label %370
370: ; preds = %367
%371 = getelementptr i8, i8* %290, i64 -16
br label %372
372: ; preds = %372, %370
%373 = phi i64 [ %368, %370 ], [ %383, %372 ]
%374 = phi i64 [ 0, %370 ], [ %384, %372 ]
%375 = sub i64 0, %373
%376 = xor i64 %373, -1
%377 = add i64 %376, %294
%378 = getelementptr inbounds i8, i8* %150, i64 %377
%379 = bitcast i8* %378 to <16 x i8>*
%380 = load <16 x i8>, <16 x i8>* %379
%381 = getelementptr inbounds i8, i8* %371, i64 %375
%382 = bitcast i8* %381 to <16 x i8>*
store <16 x i8> %380, <16 x i8>* %382
%383 = add nuw i64 %373, 16
%384 = add i64 %374, 1
%385 = icmp eq i64 %384, %321
br i1 %385, label %386, label %372
386: ; preds = %372, %367
%387 = icmp eq i64 %297, %312
br i1 %387, label %402, label %388
388: ; preds = %299, %293, %386
%389 = phi i64 [ %294, %299 ], [ %294, %293 ], [ %313, %386 ]
%390 = phi i32 [ %288, %299 ], [ %288, %293 ], [ %315, %386 ]
%391 = phi i8* [ %290, %299 ], [ %290, %293 ], [ %317, %386 ]
br label %392
392: ; preds = %388, %392
%393 = phi i64 [ %397, %392 ], [ %389, %388 ]
%394 = phi i32 [ %396, %392 ], [ %390, %388 ]
%395 = phi i8* [ %400, %392 ], [ %391, %388 ]
%396 = add nsw i32 %394, -1
%397 = add nsw i64 %393, -1
%398 = getelementptr inbounds i8, i8* %134, i64 %397
%399 = load i8, i8* %398
%400 = getelementptr inbounds i8, i8* %395, i64 -1
store i8 %399, i8* %400
%401 = icmp ugt i32 %394, 1
br i1 %401, label %392, label %402
402: ; preds = %392, %386
%403 = phi i64 [ %313, %386 ], [ %397, %392 ]
%404 = phi i8* [ %317, %386 ], [ %400, %392 ]
%405 = trunc i64 %403 to i32
br label %406
406: ; preds = %402, %287
%407 = phi i32 [ %291, %287 ], [ %405, %402 ]
%408 = phi i8* [ %290, %287 ], [ %404, %402 ]
%409 = getelementptr inbounds i8, i8* %408, i64 -1
store i8 %30, i8* %409
%410 = add nsw i32 %289, 1
%411 = load i8, i8* %154
%412 = sext i8 %411 to i32
%413 = icmp sgt i32 %407, %412
br i1 %413, label %287, label %414
414: ; preds = %406
%415 = sext i8 %411 to i32
br label %416
416: ; preds = %414, %283, %281
%417 = phi i32 [ %285, %283 ], [ %278, %281 ], [ %415, %414 ]
%418 = phi i32 [ %272, %283 ], [ %272, %281 ], [ %407, %414 ]
%419 = phi i8* [ %274, %283 ], [ %274, %281 ], [ %409, %414 ]
%420 = phi i8* [ %154, %283 ], [ %276, %281 ], [ %154, %414 ]
%421 = phi i32 [ %275, %283 ], [ %275, %281 ], [ %410, %414 ]
%422 = icmp sgt i32 %418, %417
br i1 %422, label %151, label %423
423: ; preds = %416, %271, %130
%424 = phi i32 [ %116, %130 ], [ %272, %271 ], [ %418, %416 ]
%425 = phi i8* [ %117, %130 ], [ %274, %271 ], [ %419, %416 ]
%426 = phi i32 [ 0, %130 ], [ %275, %271 ], [ %421, %416 ]
%427 = icmp sgt i32 %424, 0
br i1 %427, label %428, label %540
428: ; preds = %423
%429 = zext i32 %424 to i64
%430 = getelementptr inbounds i8, i8* %71, i64 %100
%431 = add i32 %424, -1
%432 = zext i32 %431 to i64
%433 = add nuw nsw i64 %432, 1
%434 = icmp ult i32 %431, 15
br i1 %434, label %528, label %435
435: ; preds = %428
%436 = add i32 %424, -1
%437 = zext i32 %436 to i64
%438 = xor i64 %437, -1
%439 = getelementptr i8, i8* %425, i64 %438
%440 = add nuw nsw i64 %100, %429
%441 = xor i64 %437, -1
%442 = add nsw i64 %440, %441
%443 = getelementptr i8, i8* %71, i64 %442
%444 = getelementptr i8, i8* %71, i64 %440
%445 = icmp ult i8* %439, %444
%446 = icmp ult i8* %443, %425
%447 = and i1 %445, %446
br i1 %447, label %528, label %448
448: ; preds = %435
%449 = and i64 %433, 8589934576
%450 = sub nsw i64 %429, %449
%451 = sub nsw i64 0, %449
%452 = getelementptr i8, i8* %425, i64 %451
%453 = add nsw i64 %449, -16
%454 = lshr exact i64 %453, 4
%455 = add nuw nsw i64 %454, 1
%456 = and i64 %455, 3
%457 = icmp ult i64 %453, 48
br i1 %457, label %506, label %458
458: ; preds = %448
%459 = and i64 %455, 2305843009213693948
%460 = getelementptr inbounds i8, i8* %430, i64 -15
%461 = getelementptr i8, i8* %425, i64 -16
%462 = getelementptr inbounds i8, i8* %430, i64 -15
%463 = getelementptr i8, i8* %425, i64 -16
%464 = getelementptr inbounds i8, i8* %430, i64 -15
%465 = getelementptr i8, i8* %425, i64 -16
%466 = getelementptr inbounds i8, i8* %430, i64 -15
%467 = getelementptr i8, i8* %425, i64 -16
br label %468
468: ; preds = %468, %458
%469 = phi i64 [ 0, %458 ], [ %503, %468 ]
%470 = phi i64 [ 0, %458 ], [ %504, %468 ]
%471 = sub i64 0, %469
%472 = xor i64 %469, -1
%473 = add i64 %472, %429
%474 = getelementptr inbounds i8, i8* %460, i64 %473
%475 = bitcast i8* %474 to <16 x i8>*
%476 = load <16 x i8>, <16 x i8>* %475
%477 = getelementptr inbounds i8, i8* %461, i64 %471
%478 = bitcast i8* %477 to <16 x i8>*
store <16 x i8> %476, <16 x i8>* %478
%479 = sub nuw nsw i64 -16, %469
%480 = sub nuw nsw i64 -17, %469
%481 = add i64 %480, %429
%482 = getelementptr inbounds i8, i8* %462, i64 %481
%483 = bitcast i8* %482 to <16 x i8>*
%484 = load <16 x i8>, <16 x i8>* %483
%485 = getelementptr inbounds i8, i8* %463, i64 %479
%486 = bitcast i8* %485 to <16 x i8>*
store <16 x i8> %484, <16 x i8>* %486
%487 = sub nuw nsw i64 -32, %469
%488 = sub nuw nsw i64 -33, %469
%489 = add i64 %488, %429
%490 = getelementptr inbounds i8, i8* %464, i64 %489
%491 = bitcast i8* %490 to <16 x i8>*
%492 = load <16 x i8>, <16 x i8>* %491
%493 = getelementptr inbounds i8, i8* %465, i64 %487
%494 = bitcast i8* %493 to <16 x i8>*
store <16 x i8> %492, <16 x i8>* %494
%495 = sub nuw nsw i64 -48, %469
%496 = sub nuw nsw i64 -49, %469
%497 = add i64 %496, %429
%498 = getelementptr inbounds i8, i8* %466, i64 %497
%499 = bitcast i8* %498 to <16 x i8>*
%500 = load <16 x i8>, <16 x i8>* %499
%501 = getelementptr inbounds i8, i8* %467, i64 %495
%502 = bitcast i8* %501 to <16 x i8>*
store <16 x i8> %500, <16 x i8>* %502
%503 = add nuw i64 %469, 64
%504 = add i64 %470, 4
%505 = icmp eq i64 %504, %459
br i1 %505, label %506, label %468
506: ; preds = %468, %448
%507 = phi i64 [ 0, %448 ], [ %503, %468 ]
%508 = icmp eq i64 %456, 0
br i1 %508, label %526, label %509
509: ; preds = %506
%510 = getelementptr inbounds i8, i8* %430, i64 -15
%511 = getelementptr i8, i8* %425, i64 -16
br label %512
512: ; preds = %512, %509
%513 = phi i64 [ %507, %509 ], [ %523, %512 ]
%514 = phi i64 [ 0, %509 ], [ %524, %512 ]
%515 = sub i64 0, %513
%516 = xor i64 %513, -1
%517 = add i64 %516, %429
%518 = getelementptr inbounds i8, i8* %510, i64 %517
%519 = bitcast i8* %518 to <16 x i8>*
%520 = load <16 x i8>, <16 x i8>* %519
%521 = getelementptr inbounds i8, i8* %511, i64 %515
%522 = bitcast i8* %521 to <16 x i8>*
store <16 x i8> %520, <16 x i8>* %522
%523 = add nuw i64 %513, 16
%524 = add i64 %514, 1
%525 = icmp eq i64 %524, %456
br i1 %525, label %526, label %512
526: ; preds = %512, %506
%527 = icmp eq i64 %433, %449
br i1 %527, label %540, label %528
528: ; preds = %435, %428, %526
%529 = phi i64 [ %429, %435 ], [ %429, %428 ], [ %450, %526 ]
%530 = phi i8* [ %425, %435 ], [ %425, %428 ], [ %452, %526 ]
br label %531
531: ; preds = %528, %531
%532 = phi i64 [ %535, %531 ], [ %529, %528 ]
%533 = phi i8* [ %538, %531 ], [ %530, %528 ]
%534 = trunc i64 %532 to i32
%535 = add nsw i64 %532, -1
%536 = getelementptr inbounds i8, i8* %430, i64 %535
%537 = load i8, i8* %536
%538 = getelementptr inbounds i8, i8* %533, i64 -1
store i8 %537, i8* %538
%539 = icmp sgt i32 %534, 1
br i1 %539, label %531, label %540
540: ; preds = %531, %526, %423
%541 = phi i8* [ %425, %423 ], [ %452, %526 ], [ %538, %531 ]
%542 = sub nsw i32 %98, %426
br label %551
543: ; preds = %123, %115
%544 = sext i32 %116 to i64
%545 = sub nsw i64 0, %544
%546 = getelementptr inbounds i8, i8* %117, i64 %545
%547 = call i32 @memcpy(i8* %546, i8* %101, i32 %116)
%548 = icmp eq i32 %46, 0
%549 = sext i1 %548 to i32
%550 = add nsw i32 %98, %549
br label %551
551: ; preds = %543, %540
%552 = phi i8* [ %541, %540 ], [ %546, %543 ]
%553 = phi i32 [ %542, %540 ], [ %550, %543 ]
%554 = icmp sgt i32 %553, 0
br i1 %554, label %555, label %560
555: ; preds = %551
%556 = zext i32 %553 to i64
%557 = sub nsw i64 0, %556
%558 = getelementptr inbounds i8, i8* %552, i64 %557
%559 = call i32 @memset(i8* %558, i32 %4, i32 %553)
br label %560
560: ; preds = %555, %551
%561 = phi i8* [ %558, %555 ], [ %552, %551 ]
%562 = ptrtoint i8* %561 to i64
%563 = ptrtoint i8* %79 to i64
%564 = add i64 %563, 1
%565 = add i64 %564, %78
%566 = sub i64 %565, %562
%567 = call i32 @memmove(i8* %79, i8* %561, i64 %566)
br label %568
568: ; preds = %74, %560
%569 = phi i8* [ %79, %560 ], [ null, %74 ]
%570 = call i32 @free(i8* %71)
br label %571
571: ; preds = %568, %70, %64, %53
%572 = phi i8* [ null, %53 ], [ null, %64 ], [ null, %70 ], [ %569, %568 ]
ret i8* %572
}