void reverse_string(char *str) {
  int fst_p = 0;
  int lst_p = 0;
  int k = 0;
  char temp[256];
  for (int i = 0; i < 256; i++) {
    if (str[i] == ' ') {
      lst_p = i;
      for (int j = lst_p - 1; j >= fst_p; j--) {
        temp[k] = str[j];
        k++;
      }
      temp[k] = ' ';
      k++;
      fst_p = i + 1;
    } else if (str[i] == '\n') {
      lst_p = i;
      for (int j = lst_p - 1; j >= fst_p; j--) {
        temp[k] = str[j];
        k++;
      }
      temp[k] = '\0';
      break;
    }
  }
  k = 0;
  while (1) {
    str[k] = temp[k];
    if (temp[k] == '\0') {
      break;
    }
    k++;
  }
  str[k] = '\0';
}


x86 assembly (clang, -O0):
<reverse_string>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x124(%rbp)
cmpl   $0x100,-0x124(%rbp)
jge    1277 <reverse_string+0x177>
mov    -0x8(%rbp),%rax
movslq -0x124(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    11d6 <reverse_string+0xd6>
mov    -0x124(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x128(%rbp)
mov    -0x128(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     11b0 <reverse_string+0xb0>
mov    -0x8(%rbp),%rax
movslq -0x128(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0x120(%rbp,%rax,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x128(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x128(%rbp)
jmp    116b <reverse_string+0x6b>
movslq -0x14(%rbp),%rax
movb   $0x20,-0x120(%rbp,%rax,1)
20
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x124(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    125e <reverse_string+0x15e>
mov    -0x8(%rbp),%rax
movslq -0x124(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
jne    1259 <reverse_string+0x159>
mov    -0x124(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x12c(%rbp)
mov    -0x12c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1248 <reverse_string+0x148>
mov    -0x8(%rbp),%rax
movslq -0x12c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0x120(%rbp,%rax,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x12c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x12c(%rbp)
jmp    1203 <reverse_string+0x103>
movslq -0x14(%rbp),%rax
movb   $0x0,-0x120(%rbp,%rax,1)
jmp    1277 <reverse_string+0x177>
jmp    125e <reverse_string+0x15e>
jmp    1263 <reverse_string+0x163>
mov    -0x124(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x124(%rbp)
jmp    112e <reverse_string+0x2e>
movl   $0x0,-0x14(%rbp)
movslq -0x14(%rbp),%rax
mov    -0x120(%rbp,%rax,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
movslq -0x14(%rbp),%rax
movsbl -0x120(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
jne    12ae <reverse_string+0x1ae>
jmp    12bc <reverse_string+0x1bc>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    127e <reverse_string+0x17e>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<reverse_string>:
push   %r15
push   %r14
push   %rbx
sub    $0x80,%rsp
lea    -0x10(%rdi),%r9
xor    %r11d,%r11d
lea    -0x70(%rsp),%r8
pxor   %xmm0,%xmm0
xor    %ecx,%ecx
xor    %eax,%eax
jmp    114f <reverse_string+0x4f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %ecx,%rcx
movb   $0x20,-0x80(%rsp,%rcx,1)
add    $0x1,%ecx
add    $0x1,%r11
mov    %r11d,%eax
cmp    $0x100,%r11
je     135f <reverse_string+0x25f>
mov    (%rdi,%r11,1),%dl
cmp    $0x20,%dl
je     1170 <reverse_string+0x70>
cmp    $0xa,%dl
je     125b <reverse_string+0x15b>
add    $0x1,%r11
jmp    1142 <reverse_string+0x42>
nopw   0x0(%rax,%rax,1)
movslq %eax,%r14
mov    %r11,%r10
sub    %r14,%r10
jle    1130 <reverse_string+0x30>
movslq %ecx,%rdx
cmp    $0x20,%r10
jae    118f <reverse_string+0x8f>
mov    %rdx,%rcx
mov    %r11,%rax
jmp    1240 <reverse_string+0x140>
mov    %r10,%r15
and    $0xffffffffffffffe0,%r15
lea    (%r15,%rdx,1),%rcx
mov    %r11,%rax
sub    %r15,%rax
lea    (%r9,%r11,1),%rsi
add    %r8,%rdx
xor    %ebx,%ebx
nopl   0x0(%rax)
movdqu -0x10(%rsi),%xmm1
movdqu (%rsi),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,-0x10(%rdx,%rbx,1)
movdqu %xmm1,(%rdx,%rbx,1)
add    $0x20,%rbx
add    $0xffffffffffffffe0,%rsi
cmp    %rbx,%r15
jne    11b0 <reverse_string+0xb0>
cmp    %r15,%r10
je     1130 <reverse_string+0x30>
cs nopw 0x0(%rax,%rax,1)
movzbl -0x1(%rdi,%rax,1),%edx
add    $0xffffffffffffffff,%rax
mov    %dl,-0x80(%rsp,%rcx,1)
add    $0x1,%rcx
cmp    %r14,%rax
jg     1240 <reverse_string+0x140>
jmp    1130 <reverse_string+0x30>
cmp    %r11d,%eax
jge    1357 <reverse_string+0x257>
movslq %eax,%r9
movslq %ecx,%rax
lea    -0x1(%r11),%rcx
cmp    %r9,%rcx
cmovge %r9,%rcx
mov    %r11,%r8
sub    %rcx,%r8
cmp    $0x20,%r8
jae    1289 <reverse_string+0x189>
mov    %rax,%rcx
jmp    1340 <reverse_string+0x240>
mov    %r8,%rdx
and    $0xffffffffffffffe0,%rdx
lea    (%rdx,%rax,1),%rcx
lea    (%rdi,%r11,1),%rbx
add    $0xfffffffffffffff0,%rbx
sub    %rdx,%r11
lea    (%rsp,%rax,1),%rsi
add    $0xffffffffffffff90,%rsi
xor    %eax,%eax
pxor   %xmm0,%xmm0
nopl   (%rax)
movdqu -0x10(%rbx),%xmm1
movdqu (%rbx),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,-0x10(%rsi,%rax,1)
movdqu %xmm1,(%rsi,%rax,1)
add    $0x20,%rax
add    $0xffffffffffffffe0,%rbx
cmp    %rax,%rdx
jne    12b0 <reverse_string+0x1b0>
cmp    %rdx,%r8
je     1357 <reverse_string+0x257>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl -0x1(%rdi,%r11,1),%eax
add    $0xffffffffffffffff,%r11
mov    %al,-0x80(%rsp,%rcx,1)
add    $0x1,%rcx
cmp    %r9,%r11
jg     1340 <reverse_string+0x240>
movslq %ecx,%rax
movb   $0x0,-0x80(%rsp,%rax,1)
mov    $0xffffffffffffffff,%rax
cs nopw 0x0(%rax,%rax,1)
movzbl -0x7f(%rsp,%rax,1),%ecx
mov    %cl,0x1(%rdi,%rax,1)
add    $0x1,%rax
test   %cl,%cl
jne    1370 <reverse_string+0x270>
mov    %eax,%eax
movb   $0x0,(%rdi,%rax,1)
add    $0x80,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @reverse_string(i8* %0) {
%2 = alloca i8*
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca [256 x i8]
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
store i8* %0, i8** %2
store i32 0, i32* %3
store i32 0, i32* %4
store i32 0, i32* %5
store i32 0, i32* %7
br label %10
10: ; preds = %87, %1
%11 = load i32, i32* %7
%12 = icmp slt i32 %11, 256
br i1 %12, label %13, label %90
13: ; preds = %10
%14 = load i8*, i8** %2
%15 = load i32, i32* %7
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds i8, i8* %14, i64 %16
%18 = load i8, i8* %17
%19 = sext i8 %18 to i32
%20 = icmp eq i32 %19, 32
br i1 %20, label %21, label %51
21: ; preds = %13
%22 = load i32, i32* %7
store i32 %22, i32* %4
%23 = load i32, i32* %4
%24 = sub nsw i32 %23, 1
store i32 %24, i32* %8
br label %25
25: ; preds = %40, %21
%26 = load i32, i32* %8
%27 = load i32, i32* %3
%28 = icmp sge i32 %26, %27
br i1 %28, label %29, label %43
29: ; preds = %25
%30 = load i8*, i8** %2
%31 = load i32, i32* %8
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds i8, i8* %30, i64 %32
%34 = load i8, i8* %33
%35 = load i32, i32* %5
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %36
store i8 %34, i8* %37
%38 = load i32, i32* %5
%39 = add nsw i32 %38, 1
store i32 %39, i32* %5
br label %40
40: ; preds = %29
%41 = load i32, i32* %8
%42 = add nsw i32 %41, -1
store i32 %42, i32* %8
br label %25
43: ; preds = %25
%44 = load i32, i32* %5
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %45
store i8 32, i8* %46
%47 = load i32, i32* %5
%48 = add nsw i32 %47, 1
store i32 %48, i32* %5
%49 = load i32, i32* %7
%50 = add nsw i32 %49, 1
store i32 %50, i32* %3
br label %86
51: ; preds = %13
%52 = load i8*, i8** %2
%53 = load i32, i32* %7
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i8, i8* %52, i64 %54
%56 = load i8, i8* %55
%57 = sext i8 %56 to i32
%58 = icmp eq i32 %57, 10
br i1 %58, label %59, label %85
59: ; preds = %51
%60 = load i32, i32* %7
store i32 %60, i32* %4
%61 = load i32, i32* %4
%62 = sub nsw i32 %61, 1
store i32 %62, i32* %9
br label %63
63: ; preds = %78, %59
%64 = load i32, i32* %9
%65 = load i32, i32* %3
%66 = icmp sge i32 %64, %65
br i1 %66, label %67, label %81
67: ; preds = %63
%68 = load i8*, i8** %2
%69 = load i32, i32* %9
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds i8, i8* %68, i64 %70
%72 = load i8, i8* %71
%73 = load i32, i32* %5
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %74
store i8 %72, i8* %75
%76 = load i32, i32* %5
%77 = add nsw i32 %76, 1
store i32 %77, i32* %5
br label %78
78: ; preds = %67
%79 = load i32, i32* %9
%80 = add nsw i32 %79, -1
store i32 %80, i32* %9
br label %63
81: ; preds = %63
%82 = load i32, i32* %5
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %83
store i8 0, i8* %84
br label %90
85: ; preds = %51
br label %86
86: ; preds = %85, %43
br label %87
87: ; preds = %86
%88 = load i32, i32* %7
%89 = add nsw i32 %88, 1
store i32 %89, i32* %7
br label %10
90: ; preds = %81, %10
store i32 0, i32* %5
br label %91
91: ; preds = %90, %107
%92 = load i32, i32* %5
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %93
%95 = load i8, i8* %94
%96 = load i8*, i8** %2
%97 = load i32, i32* %5
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds i8, i8* %96, i64 %98
store i8 %95, i8* %99
%100 = load i32, i32* %5
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %101
%103 = load i8, i8* %102
%104 = sext i8 %103 to i32
%105 = icmp eq i32 %104, 0
br i1 %105, label %106, label %107
106: ; preds = %91
br label %110
107: ; preds = %91
%108 = load i32, i32* %5
%109 = add nsw i32 %108, 1
store i32 %109, i32* %5
br label %91
110: ; preds = %106
%111 = load i8*, i8** %2
%112 = load i32, i32* %5
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i8, i8* %111, i64 %113
store i8 0, i8* %114
ret void
}

LLVM IR (-O2):
define void @reverse_string(i8* nocapture %0) {
%2 = alloca [256 x i8]
%3 = getelementptr inbounds [256 x i8], [256 x i8]* %2, i64 0, i64 0
br label %4
4: ; preds = %1, %124
%5 = phi i64 [ 0, %1 ], [ %125, %124 ]
%6 = phi i32 [ 0, %1 ], [ %127, %124 ]
%7 = phi i32 [ 0, %1 ], [ %126, %124 ]
%8 = getelementptr inbounds i8, i8* %0, i64 %5
%9 = load i8, i8* %8
switch i8 %9, label %10 [
i8 32, label %12
i8 10, label %49
]
10: ; preds = %4
%11 = add nuw nsw i64 %5, 1
br label %124
12: ; preds = %4
%13 = sext i32 %7 to i64
%14 = icmp sgt i64 %5, %13
br i1 %14, label %15, label %92
15: ; preds = %12
%16 = sext i32 %6 to i64
%17 = sub i64 %5, %13
%18 = icmp ult i64 %17, 32
br i1 %18, label %46, label %19
19: ; preds = %15
%20 = and i64 %17, -32
%21 = add i64 %20, %16
%22 = sub i64 %5, %20
br label %23
23: ; preds = %23, %19
%24 = phi i64 [ 0, %19 ], [ %42, %23 ]
%25 = add i64 %24, %16
%26 = xor i64 %24, -1
%27 = add i64 %5, %26
%28 = getelementptr inbounds i8, i8* %0, i64 %27
%29 = getelementptr inbounds i8, i8* %28, i64 -15
%30 = bitcast i8* %29 to <16 x i8>*
%31 = load <16 x i8>, <16 x i8>* %30
%32 = shufflevector <16 x i8> %31, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%33 = getelementptr inbounds i8, i8* %28, i64 -16
%34 = getelementptr inbounds i8, i8* %33, i64 -15
%35 = bitcast i8* %34 to <16 x i8>*
%36 = load <16 x i8>, <16 x i8>* %35
%37 = shufflevector <16 x i8> %36, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%38 = getelementptr inbounds [256 x i8], [256 x i8]* %2, i64 0, i64 %25
%39 = bitcast i8* %38 to <16 x i8>*
store <16 x i8> %32, <16 x i8>* %39
%40 = getelementptr inbounds i8, i8* %38, i64 16
%41 = bitcast i8* %40 to <16 x i8>*
store <16 x i8> %37, <16 x i8>* %41
%42 = add nuw i64 %24, 32
%43 = icmp eq i64 %42, %20
br i1 %43, label %44, label %23
44: ; preds = %23
%45 = icmp eq i64 %17, %20
br i1 %45, label %89, label %46
46: ; preds = %15, %44
%47 = phi i64 [ %16, %15 ], [ %21, %44 ]
%48 = phi i64 [ %5, %15 ], [ %22, %44 ]
br label %99
49: ; preds = %4
%50 = trunc i64 %5 to i32
%51 = icmp slt i32 %7, %50
br i1 %51, label %52, label %111
52: ; preds = %49
%53 = sext i32 %7 to i64
%54 = sext i32 %6 to i64
%55 = add i64 %5, -1
%56 = call i64 @llvm.smin.i64(i64 %55, i64 %53)
%57 = sub i64 %5, %56
%58 = icmp ult i64 %57, 32
br i1 %58, label %86, label %59
59: ; preds = %52
%60 = and i64 %57, -32
%61 = add i64 %60, %54
%62 = sub i64 %5, %60
br label %63
63: ; preds = %63, %59
%64 = phi i64 [ 0, %59 ], [ %82, %63 ]
%65 = add i64 %64, %54
%66 = xor i64 %64, -1
%67 = add i64 %5, %66
%68 = getelementptr inbounds i8, i8* %0, i64 %67
%69 = getelementptr inbounds i8, i8* %68, i64 -15
%70 = bitcast i8* %69 to <16 x i8>*
%71 = load <16 x i8>, <16 x i8>* %70
%72 = shufflevector <16 x i8> %71, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%73 = getelementptr inbounds i8, i8* %68, i64 -16
%74 = getelementptr inbounds i8, i8* %73, i64 -15
%75 = bitcast i8* %74 to <16 x i8>*
%76 = load <16 x i8>, <16 x i8>* %75
%77 = shufflevector <16 x i8> %76, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%78 = getelementptr inbounds [256 x i8], [256 x i8]* %2, i64 0, i64 %65
%79 = bitcast i8* %78 to <16 x i8>*
store <16 x i8> %72, <16 x i8>* %79
%80 = getelementptr inbounds i8, i8* %78, i64 16
%81 = bitcast i8* %80 to <16 x i8>*
store <16 x i8> %77, <16 x i8>* %81
%82 = add nuw i64 %64, 32
%83 = icmp eq i64 %82, %60
br i1 %83, label %84, label %63
84: ; preds = %63
%85 = icmp eq i64 %57, %60
br i1 %85, label %108, label %86
86: ; preds = %52, %84
%87 = phi i64 [ %54, %52 ], [ %61, %84 ]
%88 = phi i64 [ %5, %52 ], [ %62, %84 ]
br label %115
89: ; preds = %99, %44
%90 = phi i64 [ %21, %44 ], [ %106, %99 ]
%91 = trunc i64 %90 to i32
br label %92
92: ; preds = %89, %12
%93 = phi i32 [ %6, %12 ], [ %91, %89 ]
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds [256 x i8], [256 x i8]* %2, i64 0, i64 %94
store i8 32, i8* %95
%96 = add nsw i32 %93, 1
%97 = add nuw nsw i64 %5, 1
%98 = trunc i64 %97 to i32
br label %124
99: ; preds = %46, %99
%100 = phi i64 [ %106, %99 ], [ %47, %46 ]
%101 = phi i64 [ %102, %99 ], [ %48, %46 ]
%102 = add nsw i64 %101, -1
%103 = getelementptr inbounds i8, i8* %0, i64 %102
%104 = load i8, i8* %103
%105 = getelementptr inbounds [256 x i8], [256 x i8]* %2, i64 0, i64 %100
store i8 %104, i8* %105
%106 = add nsw i64 %100, 1
%107 = icmp sgt i64 %102, %13
br i1 %107, label %99, label %89
108: ; preds = %115, %84
%109 = phi i64 [ %61, %84 ], [ %122, %115 ]
%110 = trunc i64 %109 to i32
br label %111
111: ; preds = %108, %49
%112 = phi i32 [ %6, %49 ], [ %110, %108 ]
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds [256 x i8], [256 x i8]* %2, i64 0, i64 %113
store i8 0, i8* %114
br label %129
115: ; preds = %86, %115
%116 = phi i64 [ %122, %115 ], [ %87, %86 ]
%117 = phi i64 [ %118, %115 ], [ %88, %86 ]
%118 = add nsw i64 %117, -1
%119 = getelementptr inbounds i8, i8* %0, i64 %118
%120 = load i8, i8* %119
%121 = getelementptr inbounds [256 x i8], [256 x i8]* %2, i64 0, i64 %116
store i8 %120, i8* %121
%122 = add nsw i64 %116, 1
%123 = icmp sgt i64 %118, %53
br i1 %123, label %115, label %108
124: ; preds = %10, %92
%125 = phi i64 [ %11, %10 ], [ %97, %92 ]
%126 = phi i32 [ %7, %10 ], [ %98, %92 ]
%127 = phi i32 [ %6, %10 ], [ %96, %92 ]
%128 = icmp eq i64 %125, 256
br i1 %128, label %129, label %4
129: ; preds = %124, %111
br label %130
130: ; preds = %129, %130
%131 = phi i64 [ %136, %130 ], [ 0, %129 ]
%132 = getelementptr inbounds [256 x i8], [256 x i8]* %2, i64 0, i64 %131
%133 = load i8, i8* %132
%134 = getelementptr inbounds i8, i8* %0, i64 %131
store i8 %133, i8* %134
%135 = icmp eq i8 %133, 0
%136 = add nuw i64 %131, 1
br i1 %135, label %137, label %130
137: ; preds = %130
%138 = and i64 %131, 4294967295
%139 = getelementptr inbounds i8, i8* %0, i64 %138
store i8 0, i8* %139
ret void
}