#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 */

/* Variables and functions */
int /*<<< orphan*/ Q_sprintf(char *, char *, ...);
char *Q_strstr(char *, char *);
double fabs(float);
int max(int, int /*<<< orphan*/);
char *Q_pretifymem(float value, int digitsafterdecimal) {
  static char output[8][32];
  static int current;
  float onekb = 1024.0f;
  float onemb = onekb * onekb;
  char suffix[8];
  char *out = output[current];
  char val[32], *i, *o, *dot;
  int pos;
  current = (current + 1) & (8 - 1);
  if (value > onemb) {
    value /= onemb;
    Q_sprintf(suffix, " Mb");
  } else if (value > onekb) {
    value /= onekb;
    Q_sprintf(suffix, " Kb");
  } else
    Q_sprintf(suffix, " bytes");
  digitsafterdecimal = max(digitsafterdecimal, 0);
  if (fabs(value - (int)value) < 0.00001) {
    Q_sprintf(val, "%i%s", (int)value, suffix);
  } else {
    char fmt[32];
    Q_sprintf(fmt, "%%.%if%s", digitsafterdecimal, suffix);
    Q_sprintf(val, fmt, value);
  }
  i = val;
  o = out;
  dot = Q_strstr(i, ".");
  if (!dot)
    dot = Q_strstr(i, " ");
  pos = dot - i;
  pos -= 3;
  while (*i) {
    if (pos >= 0 && !(pos % 3)) {
      if (o != out)
        *o++ = ',';
    }
    pos--;
    *o++ = *i++;
  }
  *o = 0;
  return out;
}


x86 assembly (clang, -O0):
<Q_pretifymem>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movss  %xmm0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
movss  0xea5(%rip),%xmm0
movss  %xmm0,-0xc(%rbp)
movss  -0xc(%rbp),%xmm0
mulss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x10(%rbp)
movslq 0x2fda(%rip),%rcx
lea    0x2ed3(%rip),%rax
shl    $0x5,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    0x2fc2(%rip),%eax
add    $0x1,%eax
and    $0x7,%eax
mov    %eax,0x2fb6(%rip)
movss  -0x4(%rbp),%xmm0
ucomiss -0x10(%rbp),%xmm0
jbe    11d3 <Q_pretifymem+0x93>
movss  -0x10(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x4(%rbp)
lea    -0x18(%rbp),%rdi
lea    0xe49(%rip),%rsi
mov    $0x0,%al
call   1030 <Q_sprintf@plt>
jmp    1223 <Q_pretifymem+0xe3>
movss  -0x4(%rbp),%xmm0
ucomiss -0xc(%rbp),%xmm0
jbe    120c <Q_pretifymem+0xcc>
movss  -0xc(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x4(%rbp)
lea    -0x18(%rbp),%rdi
lea    0xe14(%rip),%rsi
mov    $0x0,%al
call   1030 <Q_sprintf@plt>
jmp    121e <Q_pretifymem+0xde>
lea    -0x18(%rbp),%rdi
lea    0xe01(%rip),%rsi
mov    $0x0,%al
call   1030 <Q_sprintf@plt>
jmp    1223 <Q_pretifymem+0xe3>
mov    -0x8(%rbp),%edi
xor    %esi,%esi
call   1050 <max@plt>
mov    %eax,-0x8(%rbp)
movss  -0x4(%rbp),%xmm0
cvttss2si -0x4(%rbp),%eax
cvtsi2ss %eax,%xmm1
subss  %xmm1,%xmm0
call   1060 <fabs@plt>
movaps %xmm0,%xmm1
movsd  0xdb6(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    127c <Q_pretifymem+0x13c>
lea    -0x40(%rbp),%rdi
cvttss2si -0x4(%rbp),%edx
lea    -0x18(%rbp),%rcx
lea    0xdaf(%rip),%rsi
mov    $0x0,%al
call   1030 <Q_sprintf@plt>
jmp    12ad <Q_pretifymem+0x16d>
lea    -0x80(%rbp),%rdi
mov    -0x8(%rbp),%edx
lea    -0x18(%rbp),%rcx
lea    0xd96(%rip),%rsi
mov    $0x0,%al
call   1030 <Q_sprintf@plt>
lea    -0x40(%rbp),%rdi
lea    -0x80(%rbp),%rsi
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <Q_sprintf@plt>
lea    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rdi
lea    0xd65(%rip),%rsi
call   1040 <Q_strstr@plt>
mov    %rax,-0x58(%rbp)
cmpq   $0x0,-0x58(%rbp)
jne    12f0 <Q_pretifymem+0x1b0>
mov    -0x48(%rbp),%rdi
lea    0xd48(%rip),%rsi
call   1040 <Q_strstr@plt>
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x48(%rbp),%rax
cmpb   $0x0,(%rax)
je     1387 <Q_pretifymem+0x247>
cmpl   $0x0,-0x5c(%rbp)
jl     1357 <Q_pretifymem+0x217>
mov    -0x5c(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1357 <Q_pretifymem+0x217>
mov    -0x50(%rbp),%rax
cmp    -0x20(%rbp),%rax
je     1352 <Q_pretifymem+0x212>
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x50(%rbp)
movb   $0x2c,(%rax)
jmp    1357 <Q_pretifymem+0x217>
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x48(%rbp)
mov    (%rax),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
jmp    1307 <Q_pretifymem+0x1c7>
mov    -0x50(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x20(%rbp),%rax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Q_pretifymem>:
push   %r15
push   %r14
push   %rbx
sub    $0x60,%rsp
mov    %edi,%ebx
mov    0x2ffe(%rip),%r15d
lea    0x1(%r15),%eax
and    $0x7,%eax
mov    %eax,0x2ff1(%rip)
ucomiss 0xe9a(%rip),%xmm0
jbe    117d <Q_pretifymem+0x3d>
mulss  0xe9c(%rip),%xmm0
movaps %xmm0,(%rsp)
lea    0xe9d(%rip),%rsi
jmp    11a6 <Q_pretifymem+0x66>
ucomiss 0xe80(%rip),%xmm0
jbe    119b <Q_pretifymem+0x5b>
mulss  0xe7a(%rip),%xmm0
movaps %xmm0,(%rsp)
lea    0xe83(%rip),%rsi
jmp    11a6 <Q_pretifymem+0x66>
lea    0xe7e(%rip),%rsi
movaps %xmm0,(%rsp)
lea    0x18(%rsp),%rdi
xor    %eax,%eax
call   1030 <Q_sprintf@plt>
mov    %ebx,%edi
xor    %esi,%esi
call   1050 <max@plt>
mov    %eax,%ebx
movaps (%rsp),%xmm2
cvttps2dq %xmm2,%xmm0
cvtdq2ps %xmm0,%xmm1
movaps %xmm2,%xmm0
subss  %xmm1,%xmm0
call   1060 <fabs@plt>
movsd  0xe34(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    1201 <Q_pretifymem+0xc1>
cvttss2si (%rsp),%edx
lea    0xe39(%rip),%rsi
lea    0x20(%rsp),%rdi
lea    0x18(%rsp),%rcx
xor    %eax,%eax
call   1030 <Q_sprintf@plt>
jmp    1235 <Q_pretifymem+0xf5>
lea    0xe24(%rip),%rsi
lea    0x40(%rsp),%r14
lea    0x18(%rsp),%rcx
mov    %r14,%rdi
mov    %ebx,%edx
xor    %eax,%eax
call   1030 <Q_sprintf@plt>
movaps (%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x20(%rsp),%rdi
mov    %r14,%rsi
mov    $0x1,%al
call   1030 <Q_sprintf@plt>
shl    $0x5,%r15
lea    0x2e10(%rip),%r14
lea    0xdee(%rip),%rsi
lea    0x20(%rsp),%rdi
call   1040 <Q_strstr@plt>
test   %rax,%rax
jne    1267 <Q_pretifymem+0x127>
lea    0xdda(%rip),%rsi
lea    0x20(%rsp),%rdi
call   1040 <Q_strstr@plt>
add    %r15,%r14
mov    0x20(%rsp),%r8b
mov    %r14,%rdx
test   %r8b,%r8b
je     12dc <Q_pretifymem+0x19c>
lea    0x20(%rsp),%rdx
sub    %edx,%eax
add    $0xfffffffd,%eax
lea    0x21(%rsp),%rsi
mov    %r14,%rdx
jmp    12a7 <Q_pretifymem+0x167>
nopl   0x0(%rax,%rax,1)
add    $0xffffffff,%eax
mov    %r8b,(%rdx)
add    $0x1,%rdx
movzbl (%rsi),%r8d
add    $0x1,%rsi
test   %r8b,%r8b
je     12dc <Q_pretifymem+0x19c>
test   %eax,%eax
js     1290 <Q_pretifymem+0x150>
movslq %eax,%rdi
imul   $0x55555556,%rdi,%rbx
mov    %rbx,%rcx
shr    $0x3f,%rcx
shr    $0x20,%rbx
add    %ecx,%ebx
lea    (%rbx,%rbx,2),%ecx
sub    %ecx,%edi
jne    1290 <Q_pretifymem+0x150>
cmp    %r14,%rdx
je     1290 <Q_pretifymem+0x150>
movb   $0x2c,(%rdx)
add    $0x1,%rdx
movzbl -0x1(%rsi),%r8d
jmp    1290 <Q_pretifymem+0x150>
movb   $0x0,(%rdx)
mov    %r14,%rax
add    $0x60,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@Q_pretifymem.output = internal global [8 x [32 x i8]] zeroinitializer
@Q_pretifymem.current = internal global i32 0
@.str = [4 x i8] c" Mb\00"
@.str.1 = [4 x i8] c" Kb\00"
@.str.2 = [7 x i8] c" bytes\00"
@.str.3 = [5 x i8] c"%i%s\00"
@.str.4 = [9 x i8] c"%%.%if%s\00"
@.str.5 = [2 x i8] c".\00"
@.str.6 = [2 x i8] c" \00"
define i8* @Q_pretifymem(float %0, i32 %1) {
%3 = alloca float
%4 = alloca i32
%5 = alloca float
%6 = alloca float
%7 = alloca [8 x i8]
%8 = alloca i8*
%9 = alloca [32 x i8]
%10 = alloca i8*
%11 = alloca i8*
%12 = alloca i8*
%13 = alloca i32
%14 = alloca [32 x i8]
store float %0, float* %3
store i32 %1, i32* %4
store float 1.024000e+03, float* %5
%15 = load float, float* %5
%16 = load float, float* %5
%17 = fmul float %15, %16
store float %17, float* %6
%18 = load i32, i32* @Q_pretifymem.current
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds [8 x [32 x i8]], [8 x [32 x i8]]* @Q_pretifymem.output, i64 0, i64 %19
%21 = getelementptr inbounds [32 x i8], [32 x i8]* %20, i64 0, i64 0
store i8* %21, i8** %8
%22 = load i32, i32* @Q_pretifymem.current
%23 = add nsw i32 %22, 1
%24 = and i32 %23, 7
store i32 %24, i32* @Q_pretifymem.current
%25 = load float, float* %3
%26 = load float, float* %6
%27 = fcmp ogt float %25, %26
br i1 %27, label %28, label %34
28: ; preds = %2
%29 = load float, float* %6
%30 = load float, float* %3
%31 = fdiv float %30, %29
store float %31, float* %3
%32 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 0
%33 = call i32 (i8*, i8*, ...) @Q_sprintf(i8* %32, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0))
br label %48
34: ; preds = %2
%35 = load float, float* %3
%36 = load float, float* %5
%37 = fcmp ogt float %35, %36
br i1 %37, label %38, label %44
38: ; preds = %34
%39 = load float, float* %5
%40 = load float, float* %3
%41 = fdiv float %40, %39
store float %41, float* %3
%42 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 0
%43 = call i32 (i8*, i8*, ...) @Q_sprintf(i8* %42, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0))
br label %47
44: ; preds = %34
%45 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 0
%46 = call i32 (i8*, i8*, ...) @Q_sprintf(i8* %45, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.2, i64 0, i64 0))
br label %47
47: ; preds = %44, %38
br label %48
48: ; preds = %47, %28
%49 = load i32, i32* %4
%50 = call i32 @max(i32 %49, i32 0)
store i32 %50, i32* %4
%51 = load float, float* %3
%52 = load float, float* %3
%53 = fptosi float %52 to i32
%54 = sitofp i32 %53 to float
%55 = fsub float %51, %54
%56 = call double @fabs(float %55)
%57 = fcmp olt double %56, 1.000000e-05
br i1 %57, label %58, label %64
58: ; preds = %48
%59 = getelementptr inbounds [32 x i8], [32 x i8]* %9, i64 0, i64 0
%60 = load float, float* %3
%61 = fptosi float %60 to i32
%62 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 0
%63 = call i32 (i8*, i8*, ...) @Q_sprintf(i8* %59, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %61, i8* %62)
br label %74
64: ; preds = %48
%65 = getelementptr inbounds [32 x i8], [32 x i8]* %14, i64 0, i64 0
%66 = load i32, i32* %4
%67 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 0
%68 = call i32 (i8*, i8*, ...) @Q_sprintf(i8* %65, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.4, i64 0, i64 0), i32 %66, i8* %67)
%69 = getelementptr inbounds [32 x i8], [32 x i8]* %9, i64 0, i64 0
%70 = getelementptr inbounds [32 x i8], [32 x i8]* %14, i64 0, i64 0
%71 = load float, float* %3
%72 = fpext float %71 to double
%73 = call i32 (i8*, i8*, ...) @Q_sprintf(i8* %69, i8* %70, double %72)
br label %74
74: ; preds = %64, %58
%75 = getelementptr inbounds [32 x i8], [32 x i8]* %9, i64 0, i64 0
store i8* %75, i8** %10
%76 = load i8*, i8** %8
store i8* %76, i8** %11
%77 = load i8*, i8** %10
%78 = call i8* @Q_strstr(i8* %77, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
store i8* %78, i8** %12
%79 = load i8*, i8** %12
%80 = icmp ne i8* %79, null
br i1 %80, label %84, label %81
81: ; preds = %74
%82 = load i8*, i8** %10
%83 = call i8* @Q_strstr(i8* %82, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
store i8* %83, i8** %12
br label %84
84: ; preds = %81, %74
%85 = load i8*, i8** %12
%86 = load i8*, i8** %10
%87 = ptrtoint i8* %85 to i64
%88 = ptrtoint i8* %86 to i64
%89 = sub i64 %87, %88
%90 = trunc i64 %89 to i32
store i32 %90, i32* %13
%91 = load i32, i32* %13
%92 = sub nsw i32 %91, 3
store i32 %92, i32* %13
br label %93
93: ; preds = %112, %84
%94 = load i8*, i8** %10
%95 = load i8, i8* %94
%96 = icmp ne i8 %95, 0
br i1 %96, label %97, label %120
97: ; preds = %93
%98 = load i32, i32* %13
%99 = icmp sge i32 %98, 0
br i1 %99, label %100, label %112
100: ; preds = %97
%101 = load i32, i32* %13
%102 = srem i32 %101, 3
%103 = icmp ne i32 %102, 0
br i1 %103, label %112, label %104
104: ; preds = %100
%105 = load i8*, i8** %11
%106 = load i8*, i8** %8
%107 = icmp ne i8* %105, %106
br i1 %107, label %108, label %111
108: ; preds = %104
%109 = load i8*, i8** %11
%110 = getelementptr inbounds i8, i8* %109, i32 1
store i8* %110, i8** %11
store i8 44, i8* %109
br label %111
111: ; preds = %108, %104
br label %112
112: ; preds = %111, %100, %97
%113 = load i32, i32* %13
%114 = add nsw i32 %113, -1
store i32 %114, i32* %13
%115 = load i8*, i8** %10
%116 = getelementptr inbounds i8, i8* %115, i32 1
store i8* %116, i8** %10
%117 = load i8, i8* %115
%118 = load i8*, i8** %11
%119 = getelementptr inbounds i8, i8* %118, i32 1
store i8* %119, i8** %11
store i8 %117, i8* %118
br label %93
120: ; preds = %93
%121 = load i8*, i8** %11
store i8 0, i8* %121
%122 = load i8*, i8** %8
ret i8* %122
}

LLVM IR (-O2):
@Q_pretifymem.output = internal global [8 x [32 x i8]] zeroinitializer
@Q_pretifymem.current = internal unnamed_addr global i32 0
@.str = [4 x i8] c" Mb\00"
@.str.1 = [4 x i8] c" Kb\00"
@.str.2 = [7 x i8] c" bytes\00"
@.str.3 = [5 x i8] c"%i%s\00"
@.str.4 = [9 x i8] c"%%.%if%s\00"
@.str.5 = [2 x i8] c".\00"
@.str.6 = [2 x i8] c" \00"
define i8* @Q_pretifymem(float %0, i32 %1) {
%3 = alloca [8 x i8]
%4 = alloca [32 x i8]
%5 = alloca [32 x i8]
%6 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 0
%7 = load i32, i32* @Q_pretifymem.current
%8 = zext i32 %7 to i64
%9 = getelementptr inbounds [8 x [32 x i8]], [8 x [32 x i8]]* @Q_pretifymem.output, i64 0, i64 %8, i64 0
%10 = getelementptr inbounds [32 x i8], [32 x i8]* %4, i64 0, i64 0
%11 = add nsw i32 %7, 1
%12 = and i32 %11, 7
store i32 %12, i32* @Q_pretifymem.current
%13 = fcmp ogt float %0, 0x4130000000000000
br i1 %13, label %14, label %16
14: ; preds = %2
%15 = fmul float %0, 0x3EB0000000000000
br label %20
16: ; preds = %2
%17 = fcmp ogt float %0, 1.024000e+03
br i1 %17, label %18, label %20
18: ; preds = %16
%19 = fmul float %0, 0x3F50000000000000
br label %20
20: ; preds = %16, %18, %14
%21 = phi i8* [ getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), %18 ], [ getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), %14 ], [ getelementptr inbounds ([7 x i8], [7 x i8]* @.str.2, i64 0, i64 0), %16 ]
%22 = phi float [ %19, %18 ], [ %15, %14 ], [ %0, %16 ]
%23 = call i32 (i8*, i8*, ...) @Q_sprintf(i8* %6, i8* %21)
%24 = call i32 @max(i32 %1, i32 0)
%25 = fptosi float %22 to i32
%26 = sitofp i32 %25 to float
%27 = fsub float %22, %26
%28 = call double @fabs(float %27)
%29 = fcmp olt double %28, 1.000000e-05
br i1 %29, label %30, label %32
30: ; preds = %20
%31 = call i32 (i8*, i8*, ...) @Q_sprintf(i8* %10, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %25, i8* %6)
br label %37
32: ; preds = %20
%33 = getelementptr inbounds [32 x i8], [32 x i8]* %5, i64 0, i64 0
%34 = call i32 (i8*, i8*, ...) @Q_sprintf(i8* %33, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.4, i64 0, i64 0), i32 %24, i8* %6)
%35 = fpext float %22 to double
%36 = call i32 (i8*, i8*, ...) @Q_sprintf(i8* %10, i8* %33, double %35)
br label %37
37: ; preds = %32, %30
%38 = call i8* @Q_strstr(i8* %10, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
%39 = icmp eq i8* %38, null
br i1 %39, label %40, label %42
40: ; preds = %37
%41 = call i8* @Q_strstr(i8* %10, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
br label %42
42: ; preds = %40, %37
%43 = phi i8* [ %38, %37 ], [ %41, %40 ]
%44 = load i8, i8* %10
%45 = icmp eq i8 %44, 0
br i1 %45, label %74, label %46
46: ; preds = %42
%47 = ptrtoint i8* %43 to i64
%48 = ptrtoint [32 x i8]* %4 to i64
%49 = sub i64 %47, %48
%50 = trunc i64 %49 to i32
%51 = add nsw i32 %50, -3
br label %52
52: ; preds = %46, %66
%53 = phi i8 [ %72, %66 ], [ %44, %46 ]
%54 = phi i32 [ %69, %66 ], [ %51, %46 ]
%55 = phi i8* [ %71, %66 ], [ %9, %46 ]
%56 = phi i8* [ %70, %66 ], [ %10, %46 ]
%57 = icmp slt i32 %54, 0
%58 = srem i32 %54, 3
%59 = icmp ne i32 %58, 0
%60 = or i1 %57, %59
%61 = icmp eq i8* %55, %9
%62 = select i1 %60, i1 true, i1 %61
br i1 %62, label %66, label %63
63: ; preds = %52
%64 = getelementptr inbounds i8, i8* %55, i64 1
store i8 44, i8* %55
%65 = load i8, i8* %56
br label %66
66: ; preds = %63, %52
%67 = phi i8 [ %65, %63 ], [ %53, %52 ]
%68 = phi i8* [ %64, %63 ], [ %55, %52 ]
%69 = add nsw i32 %54, -1
%70 = getelementptr inbounds i8, i8* %56, i64 1
%71 = getelementptr inbounds i8, i8* %68, i64 1
store i8 %67, i8* %68
%72 = load i8, i8* %70
%73 = icmp eq i8 %72, 0
br i1 %73, label %74, label %52
74: ; preds = %66, %42
%75 = phi i8* [ %9, %42 ], [ %71, %66 ]
store i8 0, i8* %75
ret i8* %9
}