#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 */
typedef int uint32_t;
typedef int int32_t;

/* Variables and functions */
unsigned int embedded_ftoa(char *print_buf, float input, signed int dp,
                           unsigned int sci) {
  char *s;
  unsigned int neg = 0;
  unsigned long t;
  int32_t integer;
  uint32_t decimal;
  int Exp = 0;
  int Exp_sg = 0;
  unsigned int return_value = 0;
  if (dp > 4) {
    dp = 4;
  }
  if (dp < 1) {
    dp = 1;
  }
  float number;
  number = input;
  if (number < 0) {
    neg = 1;
    number *= -1;
  }
  if (sci) {
    if (number >= 10) {
      while (number >= 10) {
        number /= 10;
        Exp++;
      }
    }
    if ((number < 1) && (number != 0)) {
      while (number < 1) {
        number *= 10;
        Exp--;
      }
    }
    if (Exp < 0) {
      Exp *= -1;
      Exp_sg = 1;
    }
  }
  integer = (int32_t)number;
  number = number - (float)integer;
  unsigned int ii;
  unsigned int mult = 1;
  for (ii = 0; ii < dp; ++ii) {
    mult *= 10;
  }
  decimal = (uint32_t)(number * (float)mult);
  s = print_buf + 36 - 1;
  *s = '\0';
  if (sci) {
    do {
      t = Exp % 10;
      if (t >= 10)
        t += 'a' - '0' - 10;
      *--s = t + '0';
      Exp /= 10;
    } while (Exp);
    if (Exp_sg) {
      *--s = '-';
    }
    *--s = 'e';
  }
  while (dp) {
    t = decimal % 10;
    if (t >= 10)
      t += 'a' - '0' - 10;
    *--s = t + '0';
    decimal /= 10;
    --dp;
  }
  *--s = '.';
  do {
    t = integer % 10;
    if (t >= 10)
      t += 'a' - '0' - 10;
    *--s = t + '0';
    integer /= 10;
  } while (integer);
  if (neg) {
    *--s = '-';
  }
  int count;
  count = s - print_buf;
  int xx;
  for (xx = 0; xx < count; xx++) {
    print_buf[xx] = *s;
    s++;
  }
  return return_value;
}


x86 assembly (clang, -O0):
<embedded_ftoa>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
mov    %esi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
cmpl   $0x4,-0x10(%rbp)
jle    1140 <embedded_ftoa+0x40>
movl   $0x4,-0x10(%rbp)
cmpl   $0x1,-0x10(%rbp)
jge    1151 <embedded_ftoa+0x51>
movl   $0x1,-0x10(%rbp)
movss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
ucomiss -0x48(%rbp),%xmm0
jbe    1181 <embedded_ftoa+0x81>
movl   $0x1,-0x24(%rbp)
movss  0xe89(%rip),%xmm0
mulss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
cmpl   $0x0,-0x14(%rbp)
je     126c <embedded_ftoa+0x16c>
movss  -0x48(%rbp),%xmm0
movss  0xe6c(%rip),%xmm1
ucomiss %xmm1,%xmm0
jb     11e5 <embedded_ftoa+0xe5>
jmp    11a6 <embedded_ftoa+0xa6>
movss  -0x48(%rbp),%xmm0
movss  0xe51(%rip),%xmm1
ucomiss %xmm1,%xmm0
jb     11e0 <embedded_ftoa+0xe0>
movss  -0x48(%rbp),%xmm0
movss  0xe3b(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11a6 <embedded_ftoa+0xa6>
jmp    11e5 <embedded_ftoa+0xe5>
movss  0xe1b(%rip),%xmm0
ucomiss -0x48(%rbp),%xmm0
jbe    124f <embedded_ftoa+0x14f>
movss  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1213 <embedded_ftoa+0x113>
jp     1213 <embedded_ftoa+0x113>
jmp    124f <embedded_ftoa+0x14f>
jmp    1218 <embedded_ftoa+0x118>
movss  0xde8(%rip),%xmm0
ucomiss -0x48(%rbp),%xmm0
jbe    124a <embedded_ftoa+0x14a>
movss  0xdd2(%rip),%xmm0
mulss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1218 <embedded_ftoa+0x118>
jmp    124f <embedded_ftoa+0x14f>
cmpl   $0x0,-0x3c(%rbp)
jge    1267 <embedded_ftoa+0x167>
imul   $0xffffffff,-0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,-0x40(%rbp)
jmp    126c <embedded_ftoa+0x16c>
cvttss2si -0x48(%rbp),%eax
mov    %eax,-0x34(%rbp)
movss  -0x48(%rbp),%xmm0
cvtsi2ssl -0x34(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movl   $0x1,-0x50(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jae    12b6 <embedded_ftoa+0x1b6>
imul   $0xa,-0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1295 <embedded_ftoa+0x195>
movss  -0x48(%rbp),%xmm0
mov    -0x50(%rbp),%eax
cvtsi2ss %rax,%xmm1
mulss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
add    $0x24,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movb   $0x0,(%rax)
cmpl   $0x0,-0x14(%rbp)
je     1381 <embedded_ftoa+0x281>
jmp    12f4 <embedded_ftoa+0x1f4>
mov    -0x3c(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
movslq %edx,%rax
mov    %rax,-0x30(%rbp)
cmpq   $0xa,-0x30(%rbp)
jb     131d <embedded_ftoa+0x21d>
mov    -0x30(%rbp),%rax
add    $0x27,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
add    $0x30,%rax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,-0x1(%rax)
mov    -0x3c(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jne    12f4 <embedded_ftoa+0x1f4>
cmpl   $0x0,-0x40(%rbp)
je     136e <embedded_ftoa+0x26e>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x2d,-0x1(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x65,-0x1(%rax)
jmp    1386 <embedded_ftoa+0x286>
cmpl   $0x0,-0x10(%rbp)
je     13f1 <embedded_ftoa+0x2f1>
mov    -0x38(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
movslq %edx,%rax
mov    %rax,-0x30(%rbp)
cmpq   $0xa,-0x30(%rbp)
jb     13b9 <embedded_ftoa+0x2b9>
mov    -0x30(%rbp),%rax
add    $0x27,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
add    $0x30,%rax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,-0x1(%rax)
mov    -0x38(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1386 <embedded_ftoa+0x286>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x2e,-0x1(%rax)
mov    -0x34(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
movslq %edx,%rax
mov    %rax,-0x30(%rbp)
cmpq   $0xa,-0x30(%rbp)
jb     142d <embedded_ftoa+0x32d>
mov    -0x30(%rbp),%rax
add    $0x27,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
add    $0x30,%rax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,-0x1(%rax)
mov    -0x34(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    1404 <embedded_ftoa+0x304>
cmpl   $0x0,-0x24(%rbp)
je     147e <embedded_ftoa+0x37e>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x2d,-0x1(%rax)
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    14ca <embedded_ftoa+0x3ca>
mov    -0x20(%rbp),%rax
mov    (%rax),%dl
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1493 <embedded_ftoa+0x393>
mov    -0x44(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<embedded_ftoa>:
push   %rbx
cmp    $0x4,%esi
mov    $0x4,%r11d
cmovl  %esi,%r11d
test   %r11d,%r11d
mov    $0x1,%r9d
cmovg  %r11d,%r9d
movaps 0xede(%rip),%xmm2
xorps  %xmm0,%xmm2
xorps  %xmm3,%xmm3
movaps %xmm0,%xmm1
cmpltss %xmm3,%xmm1
andps  %xmm1,%xmm2
andnps %xmm0,%xmm1
orps   %xmm2,%xmm1
test   %edx,%edx
je     11ab <embedded_ftoa+0xab>
xor    %eax,%eax
ucomiss 0xeea(%rip),%xmm1
jb     116c <embedded_ftoa+0x6c>
xor    %eax,%eax
movss  0xede(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
divss  %xmm2,%xmm1
add    $0x1,%eax
ucomiss %xmm2,%xmm1
jae    1160 <embedded_ftoa+0x60>
movss  0xec0(%rip),%xmm2
ucomiss %xmm1,%xmm2
jbe    119c <embedded_ftoa+0x9c>
xorps  %xmm3,%xmm3
ucomiss %xmm3,%xmm1
jne    1183 <embedded_ftoa+0x83>
jnp    119c <embedded_ftoa+0x9c>
movss  0xea5(%rip),%xmm3
nopl   0x0(%rax,%rax,1)
mulss  %xmm3,%xmm1
add    $0xffffffff,%eax
ucomiss %xmm1,%xmm2
ja     1190 <embedded_ftoa+0x90>
test   %eax,%eax
setns  %r8b
mov    %eax,%esi
neg    %esi
cmovs  %eax,%esi
jmp    11b0 <embedded_ftoa+0xb0>
mov    $0x1,%r8b
xor    %esi,%esi
lea    -0x1(%r9),%ebx
lea    0x23(%rdi),%rax
movd   %ebx,%xmm2
pshufd $0x0,%xmm2,%xmm2
cvttps2dq %xmm1,%xmm3
cvtdq2ps %xmm3,%xmm3
pxor   0xe30(%rip),%xmm2
movdqa 0xe38(%rip),%xmm4
pcmpgtd %xmm2,%xmm4
movdqa %xmm4,%xmm2
pandn  0xe38(%rip),%xmm2
psubd  %xmm4,%xmm2
pshufd $0xee,%xmm2,%xmm4
pshufd $0xff,%xmm2,%xmm5
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm5,%xmm6
pmuludq %xmm2,%xmm4
pmuludq %xmm6,%xmm4
movd   %xmm4,%ebx
movaps %xmm1,%xmm2
subss  %xmm3,%xmm2
xorps  %xmm3,%xmm3
cvtsi2ss %rbx,%xmm3
mulss  %xmm2,%xmm3
cvttss2si %xmm3,%r10d
movb   $0x0,0x23(%rdi)
test   %edx,%edx
je     128d <embedded_ftoa+0x18d>
nopl   0x0(%rax,%rax,1)
movslq %esi,%rcx
imul   $0x66666667,%rcx,%rsi
mov    %rsi,%rbx
shr    $0x3f,%rbx
sar    $0x22,%rsi
add    %ebx,%esi
lea    (%rsi,%rsi,1),%ebx
lea    (%rbx,%rbx,4),%ebx
mov    %ecx,%edx
sub    %ebx,%edx
lea    0x27(%rdx),%ebx
cmp    $0xa,%edx
movzbl %bl,%ebx
cmovb  %edx,%ebx
add    $0x30,%bl
mov    %bl,-0x1(%rax)
add    $0xffffffffffffffff,%rax
add    $0x9,%ecx
cmp    $0x12,%ecx
ja     1230 <embedded_ftoa+0x130>
mov    $0xffffffffffffffff,%rdx
test   %r8b,%r8b
jne    1286 <embedded_ftoa+0x186>
movb   $0x2d,-0x1(%rax)
mov    $0xfffffffffffffffe,%rdx
movb   $0x65,(%rax,%rdx,1)
add    %rdx,%rax
movslq %r10d,%rbx
imul   $0x66666667,%rbx,%rsi
mov    %rsi,%rcx
shr    $0x3f,%rcx
sar    $0x22,%rsi
add    %ecx,%esi
lea    (%rsi,%rsi,1),%ecx
lea    (%rcx,%rcx,4),%ecx
mov    %ebx,%edx
sub    %ecx,%edx
lea    0x27(%rdx),%ecx
cmp    $0xa,%edx
movzbl %cl,%ecx
cmovb  %edx,%ecx
add    $0x30,%cl
mov    %cl,-0x1(%rax)
cmp    $0x2,%r11d
jl     13a1 <embedded_ftoa+0x2a1>
movslq %esi,%rcx
imul   $0x66666667,%rcx,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x22,%rcx
add    %edx,%ecx
add    %ecx,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%esi
lea    0x27(%rsi),%ecx
cmp    $0xa,%esi
movzbl %cl,%ecx
cmovb  %esi,%ecx
add    $0x30,%cl
mov    %cl,-0x2(%rax)
cmp    $0x2,%r9d
jne    1309 <embedded_ftoa+0x209>
add    $0xffffffffffffffff,%rax
jmp    13a1 <embedded_ftoa+0x2a1>
imul   $0x51eb851f,%rbx,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x25,%rcx
add    %edx,%ecx
movslq %ecx,%rcx
imul   $0x66666667,%rcx,%rdx
mov    %rdx,%rsi
shr    $0x3f,%rsi
sar    $0x22,%rdx
add    %esi,%edx
add    %edx,%edx
lea    (%rdx,%rdx,4),%edx
sub    %edx,%ecx
lea    0x27(%rcx),%edx
cmp    $0xa,%ecx
movzbl %dl,%edx
cmovb  %ecx,%edx
add    $0x30,%dl
mov    %dl,-0x3(%rax)
cmp    $0x3,%r9d
jne    1359 <embedded_ftoa+0x259>
add    $0xfffffffffffffffe,%rax
jmp    13a1 <embedded_ftoa+0x2a1>
imul   $0x10624dd3,%rbx,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x26,%rcx
add    %edx,%ecx
movslq %ecx,%rcx
imul   $0x66666667,%rcx,%rdx
mov    %rdx,%rsi
shr    $0x3f,%rsi
sar    $0x22,%rdx
add    %esi,%edx
add    %edx,%edx
lea    (%rdx,%rdx,4),%edx
sub    %edx,%ecx
lea    0x27(%rcx),%edx
cmp    $0xa,%ecx
movzbl %dl,%edx
cmovb  %ecx,%edx
add    $0x30,%dl
mov    %dl,-0x4(%rax)
add    $0xfffffffffffffffd,%rax
cvttss2si %xmm1,%ecx
movb   $0x2e,-0x2(%rax)
add    $0xfffffffffffffffd,%rax
nopl   (%rax)
movslq %ecx,%rbx
imul   $0x66666667,%rbx,%rcx
mov    %rcx,%rsi
shr    $0x3f,%rsi
sar    $0x22,%rcx
add    %esi,%ecx
lea    (%rcx,%rcx,1),%esi
lea    (%rsi,%rsi,4),%esi
mov    %ebx,%edx
sub    %esi,%edx
lea    0x27(%rdx),%esi
cmp    $0xa,%edx
movzbl %sil,%esi
cmovb  %edx,%esi
add    $0x30,%sil
mov    %sil,(%rax)
add    $0x9,%ebx
add    $0xffffffffffffffff,%rax
cmp    $0x12,%ebx
ja     13b0 <embedded_ftoa+0x2b0>
xorps  %xmm1,%xmm1
ucomiss %xmm0,%xmm1
jbe    1401 <embedded_ftoa+0x301>
movb   $0x2d,(%rax)
mov    $0x2d,%sil
jmp    1405 <embedded_ftoa+0x305>
add    $0x1,%rax
mov    %rax,%rdx
sub    %rdi,%rdx
test   %edx,%edx
jle    14cb <embedded_ftoa+0x3cb>
mov    %edx,%r10d
mov    %sil,(%rdi)
cmp    $0x1,%r10
je     14cb <embedded_ftoa+0x3cb>
lea    0x1(%rax),%r9
lea    -0x1(%r10),%r8
mov    $0x1,%esi
cmp    $0x8,%r8
jb     1450 <embedded_ftoa+0x350>
lea    0x1(%rdi),%rcx
lea    (%rax,%r10,1),%rbx
cmp    %rbx,%rcx
jae    14cf <embedded_ftoa+0x3cf>
lea    (%rdi,%r10,1),%rcx
cmp    %rcx,%r9
jae    14cf <embedded_ftoa+0x3cf>
mov    %r9,%rax
sub    %esi,%edx
mov    %rsi,%rcx
not    %rcx
add    %r10,%rcx
and    $0x3,%rdx
je     1484 <embedded_ftoa+0x384>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rax),%ebx
mov    %bl,(%rdi,%rsi,1)
add    $0x1,%rax
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
jne    1470 <embedded_ftoa+0x370>
cmp    $0x3,%rcx
jb     14cb <embedded_ftoa+0x3cb>
sub    %rsi,%r10
lea    (%rsi,%rdi,1),%rcx
add    $0x3,%rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movzbl (%rax,%rdx,1),%ebx
mov    %bl,-0x3(%rcx,%rdx,1)
movzbl 0x1(%rax,%rdx,1),%ebx
mov    %bl,-0x2(%rcx,%rdx,1)
movzbl 0x2(%rax,%rdx,1),%ebx
mov    %bl,-0x1(%rcx,%rdx,1)
movzbl 0x3(%rax,%rdx,1),%ebx
mov    %bl,(%rcx,%rdx,1)
add    $0x4,%rdx
cmp    %rdx,%r10
jne    14a0 <embedded_ftoa+0x3a0>
xor    %eax,%eax
pop    %rbx
ret
cmp    $0x20,%r8
jae    14dc <embedded_ftoa+0x3dc>
xor    %ecx,%ecx
jmp    15a3 <embedded_ftoa+0x4a3>
mov    %r8,%rcx
and    $0xffffffffffffffe0,%rcx
lea    -0x20(%rcx),%rsi
mov    %rsi,%rbx
shr    $0x5,%rbx
add    $0x1,%rbx
mov    %ebx,%r11d
and    $0x3,%r11d
cmp    $0x60,%rsi
jae    1503 <embedded_ftoa+0x403>
xor    %esi,%esi
jmp    156a <embedded_ftoa+0x46a>
and    $0xfffffffffffffffc,%rbx
xor    %esi,%esi
nopl   0x0(%rax)
movups 0x1(%rax,%rsi,1),%xmm0
movups 0x11(%rax,%rsi,1),%xmm1
movups %xmm0,0x1(%rdi,%rsi,1)
movups %xmm1,0x11(%rdi,%rsi,1)
movups 0x21(%rax,%rsi,1),%xmm0
movups 0x31(%rax,%rsi,1),%xmm1
movups %xmm0,0x21(%rdi,%rsi,1)
movups %xmm1,0x31(%rdi,%rsi,1)
movups 0x41(%rax,%rsi,1),%xmm0
movups 0x51(%rax,%rsi,1),%xmm1
movups %xmm0,0x41(%rdi,%rsi,1)
movups %xmm1,0x51(%rdi,%rsi,1)
movups 0x61(%rax,%rsi,1),%xmm0
movups 0x71(%rax,%rsi,1),%xmm1
movups %xmm0,0x61(%rdi,%rsi,1)
movups %xmm1,0x71(%rdi,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rbx
jne    1510 <embedded_ftoa+0x410>
test   %r11,%r11
je     1594 <embedded_ftoa+0x494>
nop
mov    %rsi,%rbx
or     $0x1,%rbx
movups 0x1(%rax,%rsi,1),%xmm0
movups 0x11(%rax,%rsi,1),%xmm1
movups %xmm0,(%rdi,%rbx,1)
movups %xmm1,0x10(%rdi,%rbx,1)
add    $0x20,%rsi
add    $0xffffffffffffffff,%r11
jne    1570 <embedded_ftoa+0x470>
cmp    %rcx,%r8
je     14cb <embedded_ftoa+0x3cb>
test   $0x18,%r8b
je     15e0 <embedded_ftoa+0x4e0>
mov    %r8,%r11
and    $0xfffffffffffffff8,%r11
lea    0x1(%r11),%rsi
lea    (%r9,%r11,1),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r9,%rcx,1),%rbx
mov    %rbx,0x1(%rdi,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%r11
jne    15c0 <embedded_ftoa+0x4c0>
cmp    %r11,%r8
jne    1453 <embedded_ftoa+0x353>
jmp    14cb <embedded_ftoa+0x3cb>
add    %rcx,%r9
or     $0x1,%rcx
mov    %rcx,%rsi
jmp    1450 <embedded_ftoa+0x350>

LLVM IR (-O0):
define i32 @embedded_ftoa(i8* %0, float %1, i32 %2, i32 %3) {
%5 = alloca i8*
%6 = alloca float
%7 = alloca i32
%8 = alloca i32
%9 = alloca i8*
%10 = alloca i32
%11 = alloca i64
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca float
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
store i8* %0, i8** %5
store float %1, float* %6
store i32 %2, i32* %7
store i32 %3, i32* %8
store i32 0, i32* %10
store i32 0, i32* %14
store i32 0, i32* %15
store i32 0, i32* %16
%22 = load i32, i32* %7
%23 = icmp sgt i32 %22, 4
br i1 %23, label %24, label %25
24: ; preds = %4
store i32 4, i32* %7
br label %25
25: ; preds = %24, %4
%26 = load i32, i32* %7
%27 = icmp slt i32 %26, 1
br i1 %27, label %28, label %29
28: ; preds = %25
store i32 1, i32* %7
br label %29
29: ; preds = %28, %25
%30 = load float, float* %6
store float %30, float* %17
%31 = load float, float* %17
%32 = fcmp olt float %31, 0.000000e+00
br i1 %32, label %33, label %36
33: ; preds = %29
store i32 1, i32* %10
%34 = load float, float* %17
%35 = fmul float %34, -1.000000e+00
store float %35, float* %17
br label %36
36: ; preds = %33, %29
%37 = load i32, i32* %8
%38 = icmp ne i32 %37, 0
br i1 %38, label %39, label %75
39: ; preds = %36
%40 = load float, float* %17
%41 = fcmp oge float %40, 1.000000e+01
br i1 %41, label %42, label %52
42: ; preds = %39
br label %43
43: ; preds = %46, %42
%44 = load float, float* %17
%45 = fcmp oge float %44, 1.000000e+01
br i1 %45, label %46, label %51
46: ; preds = %43
%47 = load float, float* %17
%48 = fdiv float %47, 1.000000e+01
store float %48, float* %17
%49 = load i32, i32* %14
%50 = add nsw i32 %49, 1
store i32 %50, i32* %14
br label %43
51: ; preds = %43
br label %52
52: ; preds = %51, %39
%53 = load float, float* %17
%54 = fcmp olt float %53, 1.000000e+00
br i1 %54, label %55, label %68
55: ; preds = %52
%56 = load float, float* %17
%57 = fcmp une float %56, 0.000000e+00
br i1 %57, label %58, label %68
58: ; preds = %55
br label %59
59: ; preds = %62, %58
%60 = load float, float* %17
%61 = fcmp olt float %60, 1.000000e+00
br i1 %61, label %62, label %67
62: ; preds = %59
%63 = load float, float* %17
%64 = fmul float %63, 1.000000e+01
store float %64, float* %17
%65 = load i32, i32* %14
%66 = add nsw i32 %65, -1
store i32 %66, i32* %14
br label %59
67: ; preds = %59
br label %68
68: ; preds = %67, %55, %52
%69 = load i32, i32* %14
%70 = icmp slt i32 %69, 0
br i1 %70, label %71, label %74
71: ; preds = %68
%72 = load i32, i32* %14
%73 = mul nsw i32 %72, -1
store i32 %73, i32* %14
store i32 1, i32* %15
br label %74
74: ; preds = %71, %68
br label %75
75: ; preds = %74, %36
%76 = load float, float* %17
%77 = fptosi float %76 to i32
store i32 %77, i32* %12
%78 = load float, float* %17
%79 = load i32, i32* %12
%80 = sitofp i32 %79 to float
%81 = fsub float %78, %80
store float %81, float* %17
store i32 1, i32* %19
store i32 0, i32* %18
br label %82
82: ; preds = %89, %75
%83 = load i32, i32* %18
%84 = load i32, i32* %7
%85 = icmp ult i32 %83, %84
br i1 %85, label %86, label %92
86: ; preds = %82
%87 = load i32, i32* %19
%88 = mul i32 %87, 10
store i32 %88, i32* %19
br label %89
89: ; preds = %86
%90 = load i32, i32* %18
%91 = add i32 %90, 1
store i32 %91, i32* %18
br label %82
92: ; preds = %82
%93 = load float, float* %17
%94 = load i32, i32* %19
%95 = uitofp i32 %94 to float
%96 = fmul float %93, %95
%97 = fptosi float %96 to i32
store i32 %97, i32* %13
%98 = load i8*, i8** %5
%99 = getelementptr inbounds i8, i8* %98, i64 36
%100 = getelementptr inbounds i8, i8* %99, i64 -1
store i8* %100, i8** %9
%101 = load i8*, i8** %9
store i8 0, i8* %101
%102 = load i32, i32* %8
%103 = icmp ne i32 %102, 0
br i1 %103, label %104, label %134
104: ; preds = %92
br label %105
105: ; preds = %122, %104
%106 = load i32, i32* %14
%107 = srem i32 %106, 10
%108 = sext i32 %107 to i64
store i64 %108, i64* %11
%109 = load i64, i64* %11
%110 = icmp uge i64 %109, 10
br i1 %110, label %111, label %114
111: ; preds = %105
%112 = load i64, i64* %11
%113 = add i64 %112, 39
store i64 %113, i64* %11
br label %114
114: ; preds = %111, %105
%115 = load i64, i64* %11
%116 = add i64 %115, 48
%117 = trunc i64 %116 to i8
%118 = load i8*, i8** %9
%119 = getelementptr inbounds i8, i8* %118, i32 -1
store i8* %119, i8** %9
store i8 %117, i8* %119
%120 = load i32, i32* %14
%121 = sdiv i32 %120, 10
store i32 %121, i32* %14
br label %122
122: ; preds = %114
%123 = load i32, i32* %14
%124 = icmp ne i32 %123, 0
br i1 %124, label %105, label %125
125: ; preds = %122
%126 = load i32, i32* %15
%127 = icmp ne i32 %126, 0
br i1 %127, label %128, label %131
128: ; preds = %125
%129 = load i8*, i8** %9
%130 = getelementptr inbounds i8, i8* %129, i32 -1
store i8* %130, i8** %9
store i8 45, i8* %130
br label %131
131: ; preds = %128, %125
%132 = load i8*, i8** %9
%133 = getelementptr inbounds i8, i8* %132, i32 -1
store i8* %133, i8** %9
store i8 101, i8* %133
br label %134
134: ; preds = %131, %92
br label %135
135: ; preds = %147, %134
%136 = load i32, i32* %7
%137 = icmp ne i32 %136, 0
br i1 %137, label %138, label %157
138: ; preds = %135
%139 = load i32, i32* %13
%140 = srem i32 %139, 10
%141 = sext i32 %140 to i64
store i64 %141, i64* %11
%142 = load i64, i64* %11
%143 = icmp uge i64 %142, 10
br i1 %143, label %144, label %147
144: ; preds = %138
%145 = load i64, i64* %11
%146 = add i64 %145, 39
store i64 %146, i64* %11
br label %147
147: ; preds = %144, %138
%148 = load i64, i64* %11
%149 = add i64 %148, 48
%150 = trunc i64 %149 to i8
%151 = load i8*, i8** %9
%152 = getelementptr inbounds i8, i8* %151, i32 -1
store i8* %152, i8** %9
store i8 %150, i8* %152
%153 = load i32, i32* %13
%154 = sdiv i32 %153, 10
store i32 %154, i32* %13
%155 = load i32, i32* %7
%156 = add nsw i32 %155, -1
store i32 %156, i32* %7
br label %135
157: ; preds = %135
%158 = load i8*, i8** %9
%159 = getelementptr inbounds i8, i8* %158, i32 -1
store i8* %159, i8** %9
store i8 46, i8* %159
br label %160
160: ; preds = %177, %157
%161 = load i32, i32* %12
%162 = srem i32 %161, 10
%163 = sext i32 %162 to i64
store i64 %163, i64* %11
%164 = load i64, i64* %11
%165 = icmp uge i64 %164, 10
br i1 %165, label %166, label %169
166: ; preds = %160
%167 = load i64, i64* %11
%168 = add i64 %167, 39
store i64 %168, i64* %11
br label %169
169: ; preds = %166, %160
%170 = load i64, i64* %11
%171 = add i64 %170, 48
%172 = trunc i64 %171 to i8
%173 = load i8*, i8** %9
%174 = getelementptr inbounds i8, i8* %173, i32 -1
store i8* %174, i8** %9
store i8 %172, i8* %174
%175 = load i32, i32* %12
%176 = sdiv i32 %175, 10
store i32 %176, i32* %12
br label %177
177: ; preds = %169
%178 = load i32, i32* %12
%179 = icmp ne i32 %178, 0
br i1 %179, label %160, label %180
180: ; preds = %177
%181 = load i32, i32* %10
%182 = icmp ne i32 %181, 0
br i1 %182, label %183, label %186
183: ; preds = %180
%184 = load i8*, i8** %9
%185 = getelementptr inbounds i8, i8* %184, i32 -1
store i8* %185, i8** %9
store i8 45, i8* %185
br label %186
186: ; preds = %183, %180
%187 = load i8*, i8** %9
%188 = load i8*, i8** %5
%189 = ptrtoint i8* %187 to i64
%190 = ptrtoint i8* %188 to i64
%191 = sub i64 %189, %190
%192 = trunc i64 %191 to i32
store i32 %192, i32* %20
store i32 0, i32* %21
br label %193
193: ; preds = %206, %186
%194 = load i32, i32* %21
%195 = load i32, i32* %20
%196 = icmp slt i32 %194, %195
br i1 %196, label %197, label %209
197: ; preds = %193
%198 = load i8*, i8** %9
%199 = load i8, i8* %198
%200 = load i8*, i8** %5
%201 = load i32, i32* %21
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds i8, i8* %200, i64 %202
store i8 %199, i8* %203
%204 = load i8*, i8** %9
%205 = getelementptr inbounds i8, i8* %204, i32 1
store i8* %205, i8** %9
br label %206
206: ; preds = %197
%207 = load i32, i32* %21
%208 = add nsw i32 %207, 1
store i32 %208, i32* %21
br label %193
209: ; preds = %193
%210 = load i32, i32* %16
ret i32 %210
}

LLVM IR (-O2):
define i32 @embedded_ftoa(i8* %0, float %1, i32 %2, i32 %3) {
%5 = icmp slt i32 %2, 4
%6 = select i1 %5, i32 %2, i32 4
%7 = icmp sgt i32 %6, 1
%8 = select i1 %7, i32 %6, i32 1
%9 = fcmp olt float %1, 0.000000e+00
%10 = fneg float %1
%11 = select i1 %9, float %10, float %1
%12 = icmp eq i32 %3, 0
br i1 %12, label %40, label %13
13: ; preds = %4
%14 = fcmp ult float %11, 1.000000e+01
br i1 %14, label %21, label %15
15: ; preds = %13, %15
%16 = phi i32 [ %19, %15 ], [ 0, %13 ]
%17 = phi float [ %18, %15 ], [ %11, %13 ]
%18 = fdiv float %17, 1.000000e+01
%19 = add nuw nsw i32 %16, 1
%20 = fcmp ult float %18, 1.000000e+01
br i1 %20, label %21, label %15
21: ; preds = %15, %13
%22 = phi i32 [ 0, %13 ], [ %19, %15 ]
%23 = phi float [ %11, %13 ], [ %18, %15 ]
%24 = fcmp olt float %23, 1.000000e+00
%25 = fcmp une float %23, 0.000000e+00
%26 = and i1 %24, %25
br i1 %26, label %27, label %33
27: ; preds = %21, %27
%28 = phi i32 [ %31, %27 ], [ %22, %21 ]
%29 = phi float [ %30, %27 ], [ %23, %21 ]
%30 = fmul float %29, 1.000000e+01
%31 = add nsw i32 %28, -1
%32 = fcmp olt float %30, 1.000000e+00
br i1 %32, label %27, label %33
33: ; preds = %27, %21
%34 = phi i32 [ %22, %21 ], [ %31, %27 ]
%35 = phi float [ %23, %21 ], [ %30, %27 ]
%36 = icmp slt i32 %34, 0
%37 = sub nsw i32 0, %34
%38 = select i1 %36, i32 %37, i32 %34
%39 = xor i1 %36, true
br label %40
40: ; preds = %33, %4
%41 = phi i32 [ 0, %4 ], [ %38, %33 ]
%42 = phi i1 [ true, %4 ], [ %39, %33 ]
%43 = phi float [ %11, %4 ], [ %35, %33 ]
%44 = fptosi float %43 to i32
%45 = add nsw i32 %8, -1
%46 = insertelement <4 x i32> poison, i32 %45, i64 0
%47 = shufflevector <4 x i32> %46, <4 x i32> poison, <4 x i32> zeroinitializer
%48 = sitofp i32 %44 to float
%49 = icmp ult <4 x i32> %47, <i32 0, i32 1, i32 2, i32 3>
%50 = select <4 x i1> %49, <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32> <i32 10, i32 10, i32 10, i32 10>
%51 = call i32 @llvm.vector.reduce.mul.v4i32(<4 x i32> %50)
%52 = fsub float %43, %48
%53 = uitofp i32 %51 to float
%54 = fmul float %52, %53
%55 = fptosi float %54 to i32
%56 = getelementptr inbounds i8, i8* %0, i64 35
store i8 0, i8* %56
br i1 %12, label %78, label %57
57: ; preds = %40, %57
%58 = phi i32 [ %68, %57 ], [ %41, %40 ]
%59 = phi i8* [ %67, %57 ], [ %56, %40 ]
%60 = srem i32 %58, 10
%61 = zext i32 %60 to i64
%62 = icmp ugt i32 %60, 9
%63 = add nuw nsw i64 %61, 39
%64 = select i1 %62, i64 %63, i64 %61
%65 = trunc i64 %64 to i8
%66 = add nsw i8 %65, 48
%67 = getelementptr inbounds i8, i8* %59, i64 -1
store i8 %66, i8* %67
%68 = sdiv i32 %58, 10
%69 = add i32 %58, 9
%70 = icmp ult i32 %69, 19
br i1 %70, label %71, label %57
71: ; preds = %57
br i1 %42, label %74, label %72
72: ; preds = %71
%73 = getelementptr inbounds i8, i8* %59, i64 -2
store i8 45, i8* %73
br label %74
74: ; preds = %72, %71
%75 = phi i64 [ -2, %72 ], [ -1, %71 ]
%76 = getelementptr inbounds i8, i8* %59, i64 %75
%77 = getelementptr inbounds i8, i8* %76, i64 -1
store i8 101, i8* %77
br label %78
78: ; preds = %40, %74
%79 = phi i8* [ %56, %40 ], [ %77, %74 ]
%80 = srem i32 %55, 10
%81 = sdiv i32 %55, 10
%82 = zext i32 %80 to i64
%83 = icmp ugt i32 %80, 9
%84 = add nuw nsw i64 %82, 39
%85 = select i1 %83, i64 %84, i64 %82
%86 = trunc i64 %85 to i8
%87 = add nsw i8 %86, 48
%88 = getelementptr inbounds i8, i8* %79, i64 -1
store i8 %87, i8* %88
%89 = icmp slt i32 %6, 2
br i1 %89, label %121, label %90
90: ; preds = %78
%91 = srem i32 %81, 10
%92 = zext i32 %91 to i64
%93 = icmp ugt i32 %91, 9
%94 = add nuw nsw i64 %92, 39
%95 = select i1 %93, i64 %94, i64 %92
%96 = trunc i64 %95 to i8
%97 = add nsw i8 %96, 48
%98 = getelementptr inbounds i8, i8* %79, i64 -2
store i8 %97, i8* %98
%99 = icmp eq i32 %8, 2
br i1 %99, label %121, label %100
100: ; preds = %90
%101 = sdiv i32 %55, 100
%102 = srem i32 %101, 10
%103 = zext i32 %102 to i64
%104 = icmp ugt i32 %102, 9
%105 = add nuw nsw i64 %103, 39
%106 = select i1 %104, i64 %105, i64 %103
%107 = trunc i64 %106 to i8
%108 = add nsw i8 %107, 48
%109 = getelementptr inbounds i8, i8* %79, i64 -3
store i8 %108, i8* %109
%110 = icmp eq i32 %8, 3
br i1 %110, label %121, label %111
111: ; preds = %100
%112 = sdiv i32 %55, 1000
%113 = srem i32 %112, 10
%114 = zext i32 %113 to i64
%115 = icmp ugt i32 %113, 9
%116 = add nuw nsw i64 %114, 39
%117 = select i1 %115, i64 %116, i64 %114
%118 = trunc i64 %117 to i8
%119 = add nsw i8 %118, 48
%120 = getelementptr inbounds i8, i8* %79, i64 -4
store i8 %119, i8* %120
br label %121
121: ; preds = %111, %100, %90, %78
%122 = phi i8* [ %79, %78 ], [ %88, %90 ], [ %98, %100 ], [ %109, %111 ]
%123 = getelementptr inbounds i8, i8* %122, i64 -2
store i8 46, i8* %123
br label %124
124: ; preds = %124, %121
%125 = phi i32 [ %44, %121 ], [ %135, %124 ]
%126 = phi i8* [ %123, %121 ], [ %134, %124 ]
%127 = srem i32 %125, 10
%128 = zext i32 %127 to i64
%129 = icmp ugt i32 %127, 9
%130 = add nuw nsw i64 %128, 39
%131 = select i1 %129, i64 %130, i64 %128
%132 = trunc i64 %131 to i8
%133 = add nsw i8 %132, 48
%134 = getelementptr inbounds i8, i8* %126, i64 -1
store i8 %133, i8* %134
%135 = sdiv i32 %125, 10
%136 = add i32 %125, 9
%137 = icmp ult i32 %136, 19
br i1 %137, label %138, label %124
138: ; preds = %124
br i1 %9, label %139, label %141
139: ; preds = %138
%140 = getelementptr inbounds i8, i8* %126, i64 -2
store i8 45, i8* %140
br label %141
141: ; preds = %139, %138
%142 = phi i8 [ 45, %139 ], [ %133, %138 ]
%143 = phi i8* [ %140, %139 ], [ %134, %138 ]
%144 = ptrtoint i8* %143 to i64
%145 = ptrtoint i8* %0 to i64
%146 = sub i64 %144, %145
%147 = trunc i64 %146 to i32
%148 = icmp sgt i32 %147, 0
br i1 %148, label %149, label %314
149: ; preds = %141
%150 = and i64 %146, 4294967295
store i8 %142, i8* %0
%151 = getelementptr i8, i8* %143, i64 1
%152 = icmp eq i64 %150, 1
br i1 %152, label %314, label %153
153: ; preds = %149
%154 = add nsw i64 %150, -1
%155 = icmp ult i64 %154, 8
br i1 %155, label %272, label %156
156: ; preds = %153
%157 = getelementptr i8, i8* %0, i64 1
%158 = getelementptr i8, i8* %0, i64 %150
%159 = getelementptr i8, i8* %143, i64 %150
%160 = icmp ult i8* %157, %159
%161 = icmp ult i8* %151, %158
%162 = and i1 %160, %161
br i1 %162, label %272, label %163
163: ; preds = %156
%164 = icmp ult i64 %154, 32
br i1 %164, label %254, label %165
165: ; preds = %163
%166 = and i64 %154, -32
%167 = add nsw i64 %166, -32
%168 = lshr exact i64 %167, 5
%169 = add nuw nsw i64 %168, 1
%170 = and i64 %169, 3
%171 = icmp ult i64 %167, 96
br i1 %171, label %227, label %172
172: ; preds = %165
%173 = and i64 %169, 1152921504606846972
br label %174
174: ; preds = %174, %172
%175 = phi i64 [ 0, %172 ], [ %224, %174 ]
%176 = phi i64 [ 0, %172 ], [ %225, %174 ]
%177 = or i64 %175, 1
%178 = getelementptr i8, i8* %151, i64 %175
%179 = bitcast i8* %178 to <16 x i8>*
%180 = load <16 x i8>, <16 x i8>* %179
%181 = getelementptr i8, i8* %178, i64 16
%182 = bitcast i8* %181 to <16 x i8>*
%183 = load <16 x i8>, <16 x i8>* %182
%184 = getelementptr inbounds i8, i8* %0, i64 %177
%185 = bitcast i8* %184 to <16 x i8>*
store <16 x i8> %180, <16 x i8>* %185
%186 = getelementptr inbounds i8, i8* %184, i64 16
%187 = bitcast i8* %186 to <16 x i8>*
store <16 x i8> %183, <16 x i8>* %187
%188 = or i64 %175, 32
%189 = or i64 %175, 33
%190 = getelementptr i8, i8* %151, i64 %188
%191 = bitcast i8* %190 to <16 x i8>*
%192 = load <16 x i8>, <16 x i8>* %191
%193 = getelementptr i8, i8* %190, i64 16
%194 = bitcast i8* %193 to <16 x i8>*
%195 = load <16 x i8>, <16 x i8>* %194
%196 = getelementptr inbounds i8, i8* %0, i64 %189
%197 = bitcast i8* %196 to <16 x i8>*
store <16 x i8> %192, <16 x i8>* %197
%198 = getelementptr inbounds i8, i8* %196, i64 16
%199 = bitcast i8* %198 to <16 x i8>*
store <16 x i8> %195, <16 x i8>* %199
%200 = or i64 %175, 64
%201 = or i64 %175, 65
%202 = getelementptr i8, i8* %151, i64 %200
%203 = bitcast i8* %202 to <16 x i8>*
%204 = load <16 x i8>, <16 x i8>* %203
%205 = getelementptr i8, i8* %202, i64 16
%206 = bitcast i8* %205 to <16 x i8>*
%207 = load <16 x i8>, <16 x i8>* %206
%208 = getelementptr inbounds i8, i8* %0, i64 %201
%209 = bitcast i8* %208 to <16 x i8>*
store <16 x i8> %204, <16 x i8>* %209
%210 = getelementptr inbounds i8, i8* %208, i64 16
%211 = bitcast i8* %210 to <16 x i8>*
store <16 x i8> %207, <16 x i8>* %211
%212 = or i64 %175, 96
%213 = or i64 %175, 97
%214 = getelementptr i8, i8* %151, i64 %212
%215 = bitcast i8* %214 to <16 x i8>*
%216 = load <16 x i8>, <16 x i8>* %215
%217 = getelementptr i8, i8* %214, i64 16
%218 = bitcast i8* %217 to <16 x i8>*
%219 = load <16 x i8>, <16 x i8>* %218
%220 = getelementptr inbounds i8, i8* %0, i64 %213
%221 = bitcast i8* %220 to <16 x i8>*
store <16 x i8> %216, <16 x i8>* %221
%222 = getelementptr inbounds i8, i8* %220, i64 16
%223 = bitcast i8* %222 to <16 x i8>*
store <16 x i8> %219, <16 x i8>* %223
%224 = add nuw i64 %175, 128
%225 = add i64 %176, 4
%226 = icmp eq i64 %225, %173
br i1 %226, label %227, label %174
227: ; preds = %174, %165
%228 = phi i64 [ 0, %165 ], [ %224, %174 ]
%229 = icmp eq i64 %170, 0
br i1 %229, label %247, label %230
230: ; preds = %227, %230
%231 = phi i64 [ %244, %230 ], [ %228, %227 ]
%232 = phi i64 [ %245, %230 ], [ 0, %227 ]
%233 = or i64 %231, 1
%234 = getelementptr i8, i8* %151, i64 %231
%235 = bitcast i8* %234 to <16 x i8>*
%236 = load <16 x i8>, <16 x i8>* %235
%237 = getelementptr i8, i8* %234, i64 16
%238 = bitcast i8* %237 to <16 x i8>*
%239 = load <16 x i8>, <16 x i8>* %238
%240 = getelementptr inbounds i8, i8* %0, i64 %233
%241 = bitcast i8* %240 to <16 x i8>*
store <16 x i8> %236, <16 x i8>* %241
%242 = getelementptr inbounds i8, i8* %240, i64 16
%243 = bitcast i8* %242 to <16 x i8>*
store <16 x i8> %239, <16 x i8>* %243
%244 = add nuw i64 %231, 32
%245 = add i64 %232, 1
%246 = icmp eq i64 %245, %170
br i1 %246, label %247, label %230
247: ; preds = %230, %227
%248 = icmp eq i64 %154, %166
br i1 %248, label %314, label %249
249: ; preds = %247
%250 = getelementptr i8, i8* %151, i64 %166
%251 = or i64 %166, 1
%252 = and i64 %154, 24
%253 = icmp eq i64 %252, 0
br i1 %253, label %272, label %254
254: ; preds = %163, %249
%255 = phi i64 [ %166, %249 ], [ 0, %163 ]
%256 = add nsw i64 %150, -1
%257 = and i64 %256, -8
%258 = or i64 %257, 1
%259 = getelementptr i8, i8* %151, i64 %257
br label %260
260: ; preds = %260, %254
%261 = phi i64 [ %255, %254 ], [ %268, %260 ]
%262 = or i64 %261, 1
%263 = getelementptr i8, i8* %151, i64 %261
%264 = bitcast i8* %263 to <8 x i8>*
%265 = load <8 x i8>, <8 x i8>* %264
%266 = getelementptr inbounds i8, i8* %0, i64 %262
%267 = bitcast i8* %266 to <8 x i8>*
store <8 x i8> %265, <8 x i8>* %267
%268 = add nuw i64 %261, 8
%269 = icmp eq i64 %268, %257
br i1 %269, label %270, label %260
270: ; preds = %260
%271 = icmp eq i64 %256, %257
br i1 %271, label %314, label %272
272: ; preds = %156, %153, %249, %270
%273 = phi i64 [ 1, %153 ], [ 1, %156 ], [ %251, %249 ], [ %258, %270 ]
%274 = phi i8* [ %151, %153 ], [ %151, %156 ], [ %250, %249 ], [ %259, %270 ]
%275 = sub i64 %146, %273
%276 = xor i64 %273, -1
%277 = add nsw i64 %150, %276
%278 = and i64 %275, 3
%279 = icmp eq i64 %278, 0
br i1 %279, label %290, label %280
280: ; preds = %272, %280
%281 = phi i64 [ %287, %280 ], [ %273, %272 ]
%282 = phi i8* [ %286, %280 ], [ %274, %272 ]
%283 = phi i64 [ %288, %280 ], [ 0, %272 ]
%284 = load i8, i8* %282
%285 = getelementptr inbounds i8, i8* %0, i64 %281
store i8 %284, i8* %285
%286 = getelementptr inbounds i8, i8* %282, i64 1
%287 = add nuw nsw i64 %281, 1
%288 = add i64 %283, 1
%289 = icmp eq i64 %288, %278
br i1 %289, label %290, label %280
290: ; preds = %280, %272
%291 = phi i64 [ %273, %272 ], [ %287, %280 ]
%292 = phi i8* [ %274, %272 ], [ %286, %280 ]
%293 = icmp ult i64 %277, 3
br i1 %293, label %314, label %294
294: ; preds = %290, %294
%295 = phi i64 [ %312, %294 ], [ %291, %290 ]
%296 = phi i8* [ %311, %294 ], [ %292, %290 ]
%297 = load i8, i8* %296
%298 = getelementptr inbounds i8, i8* %0, i64 %295
store i8 %297, i8* %298
%299 = getelementptr inbounds i8, i8* %296, i64 1
%300 = add nuw nsw i64 %295, 1
%301 = load i8, i8* %299
%302 = getelementptr inbounds i8, i8* %0, i64 %300
store i8 %301, i8* %302
%303 = getelementptr inbounds i8, i8* %296, i64 2
%304 = add nuw nsw i64 %295, 2
%305 = load i8, i8* %303
%306 = getelementptr inbounds i8, i8* %0, i64 %304
store i8 %305, i8* %306
%307 = getelementptr inbounds i8, i8* %296, i64 3
%308 = add nuw nsw i64 %295, 3
%309 = load i8, i8* %307
%310 = getelementptr inbounds i8, i8* %0, i64 %308
store i8 %309, i8* %310
%311 = getelementptr inbounds i8, i8* %296, i64 4
%312 = add nuw nsw i64 %295, 4
%313 = icmp eq i64 %312, %150
br i1 %313, label %314, label %294
314: ; preds = %290, %294, %149, %270, %247, %141
ret i32 0
}