#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 strlen(char *);
void justArgs(char *str) {
  int i, j, len;
  len = strlen(str);
  for (i = 0, j = -1; i < len; i++) {
    if (str[i] == '/') {
      j = i;
    }
  }
  if (j != -1) {
    for (i = 0, j++; j < len; i++, j++) {
      str[i] = str[j];
    }
    str[i] = '\0';
  }
}


x86 assembly (clang, -O0):
<justArgs>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x14(%rbp)
movl   $0x0,-0xc(%rbp)
movl   $0xffffffff,-0x10(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1170 <justArgs+0x60>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2f,%eax
jne    115d <justArgs+0x4d>
mov    -0xc(%rbp),%eax
mov    %eax,-0x10(%rbp)
jmp    1162 <justArgs+0x52>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1136 <justArgs+0x26>
cmpl   $0xffffffff,-0x10(%rbp)
je     11cf <justArgs+0xbf>
movl   $0x0,-0xc(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11c3 <justArgs+0xb3>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    118a <justArgs+0x7a>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<justArgs>:
push   %r14
push   %rbx
push   %rax
mov    %rdi,%r14
call   1030 <strlen@plt>
test   %eax,%eax
jle    1284 <justArgs+0x174>
mov    %eax,%r8d
lea    -0x1(%r8),%rdx
mov    %r8d,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    1140 <justArgs+0x30>
mov    $0xffffffff,%esi
xor    %edx,%edx
jmp    1185 <justArgs+0x75>
and    $0xfffffffc,%r8d
mov    $0xffffffff,%esi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
cmpb   $0x2f,(%r14,%rdx,1)
cmove  %edx,%esi
cmpb   $0x2f,0x1(%r14,%rdx,1)
lea    0x1(%rdx),%ebx
cmovne %esi,%ebx
lea    0x2(%rdx),%edi
cmpb   $0x2f,0x2(%r14,%rdx,1)
cmovne %ebx,%edi
lea    0x3(%rdx),%esi
cmpb   $0x2f,0x3(%r14,%rdx,1)
cmovne %edi,%esi
add    $0x4,%rdx
cmp    %r8,%rdx
jne    1150 <justArgs+0x40>
test   %rcx,%rcx
je     11a2 <justArgs+0x92>
nopw   0x0(%rax,%rax,1)
cmpb   $0x2f,(%r14,%rdx,1)
cmove  %edx,%esi
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    1190 <justArgs+0x80>
cmp    $0xffffffff,%esi
je     1284 <justArgs+0x174>
lea    0x1(%rsi),%ecx
cmp    %eax,%ecx
jge    127d <justArgs+0x16d>
movslq %ecx,%r8
not    %esi
add    %esi,%eax
cmp    $0x8,%eax
jb     11e3 <justArgs+0xd3>
lea    (%r8,%rax,1),%rcx
add    %r14,%rcx
cmp    %r14,%rcx
jbe    128c <justArgs+0x17c>
lea    (%r14,%rax,1),%rcx
lea    (%r14,%r8,1),%rdx
cmp    %rcx,%rdx
jae    128c <justArgs+0x17c>
xor    %r9d,%r9d
mov    %r8,%rsi
mov    %r9,%r8
not    %r8
add    %rax,%r8
mov    %rax,%rcx
and    $0x3,%rcx
je     122b <justArgs+0x11b>
neg    %rcx
xor    %edi,%edi
mov    %r14,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rbx,%rsi,1),%edx
mov    %dl,(%rbx,%r9,1)
add    $0xffffffffffffffff,%rdi
add    $0x1,%rbx
cmp    %rdi,%rcx
jne    1210 <justArgs+0x100>
sub    %rdi,%r9
sub    %rdi,%rsi
cmp    $0x3,%r8
jb     127f <justArgs+0x16f>
mov    %rax,%rcx
sub    %r9,%rcx
lea    (%r9,%r14,1),%rdx
add    $0x3,%rdx
add    %r14,%rsi
add    $0x3,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movzbl -0x3(%rsi,%rdi,1),%ebx
mov    %bl,-0x3(%rdx,%rdi,1)
movzbl -0x2(%rsi,%rdi,1),%ebx
mov    %bl,-0x2(%rdx,%rdi,1)
movzbl -0x1(%rsi,%rdi,1),%ebx
mov    %bl,-0x1(%rdx,%rdi,1)
movzbl (%rsi,%rdi,1),%ebx
mov    %bl,(%rdx,%rdi,1)
add    $0x4,%rdi
cmp    %rdi,%rcx
jne    1250 <justArgs+0x140>
jmp    127f <justArgs+0x16f>
xor    %eax,%eax
movb   $0x0,(%r14,%rax,1)
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret
cmp    $0x20,%eax
jae    1299 <justArgs+0x189>
xor    %r9d,%r9d
jmp    1369 <justArgs+0x259>
mov    %eax,%r9d
and    $0xffffffe0,%r9d
lea    -0x20(%r9),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x60,%rcx
jae    12be <justArgs+0x1ae>
xor    %edx,%edx
jmp    1330 <justArgs+0x220>
and    $0xfffffffffffffffc,%rdi
lea    (%r8,%r14,1),%rcx
add    $0x70,%rcx
xor    %edx,%edx
nopl   0x0(%rax)
movups -0x70(%rcx,%rdx,1),%xmm0
movups -0x60(%rcx,%rdx,1),%xmm1
movups %xmm0,(%r14,%rdx,1)
movups %xmm1,0x10(%r14,%rdx,1)
movups -0x50(%rcx,%rdx,1),%xmm0
movups -0x40(%rcx,%rdx,1),%xmm1
movups %xmm0,0x20(%r14,%rdx,1)
movups %xmm1,0x30(%r14,%rdx,1)
movups -0x30(%rcx,%rdx,1),%xmm0
movups -0x20(%rcx,%rdx,1),%xmm1
movups %xmm0,0x40(%r14,%rdx,1)
movups %xmm1,0x50(%r14,%rdx,1)
movups -0x10(%rcx,%rdx,1),%xmm0
movups (%rcx,%rdx,1),%xmm1
movups %xmm0,0x60(%r14,%rdx,1)
movups %xmm1,0x70(%r14,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rdi
jne    12d0 <justArgs+0x1c0>
test   %rsi,%rsi
je     135c <justArgs+0x24c>
lea    (%rdx,%r14,1),%rcx
add    $0x10,%rcx
nopl   (%rax)
movups -0x10(%rcx,%r8,1),%xmm0
movups (%rcx,%r8,1),%xmm1
movups %xmm0,-0x10(%rcx)
movups %xmm1,(%rcx)
add    $0x20,%rcx
add    $0xffffffffffffffff,%rsi
jne    1340 <justArgs+0x230>
cmp    %rax,%r9
je     127f <justArgs+0x16f>
test   $0x18,%al
je     139f <justArgs+0x28f>
mov    %r9,%rcx
mov    %eax,%r9d
and    $0xfffffff8,%r9d
lea    (%r9,%r8,1),%rsi
lea    (%r14,%rcx,1),%rdx
sub    %r9,%rcx
xchg   %ax,%ax
mov    (%rdx,%r8,1),%rdi
mov    %rdi,(%rdx)
add    $0x8,%rdx
add    $0x8,%rcx
jne    1380 <justArgs+0x270>
cmp    %rax,%r9
jne    11e9 <justArgs+0xd9>
jmp    127f <justArgs+0x16f>
add    %r9,%r8
jmp    11e6 <justArgs+0xd6>

LLVM IR (-O0):
define void @justArgs(i8* %0) {
%2 = alloca i8*
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
store i8* %0, i8** %2
%6 = load i8*, i8** %2
%7 = call i32 @strlen(i8* %6)
store i32 %7, i32* %5
store i32 0, i32* %3
store i32 -1, i32* %4
br label %8
8: ; preds = %23, %1
%9 = load i32, i32* %3
%10 = load i32, i32* %5
%11 = icmp slt i32 %9, %10
br i1 %11, label %12, label %26
12: ; preds = %8
%13 = load i8*, i8** %2
%14 = load i32, i32* %3
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds i8, i8* %13, i64 %15
%17 = load i8, i8* %16
%18 = sext i8 %17 to i32
%19 = icmp eq i32 %18, 47
br i1 %19, label %20, label %22
20: ; preds = %12
%21 = load i32, i32* %3
store i32 %21, i32* %4
br label %22
22: ; preds = %20, %12
br label %23
23: ; preds = %22
%24 = load i32, i32* %3
%25 = add nsw i32 %24, 1
store i32 %25, i32* %3
br label %8
26: ; preds = %8
%27 = load i32, i32* %4
%28 = icmp ne i32 %27, -1
br i1 %28, label %29, label %56
29: ; preds = %26
store i32 0, i32* %3
%30 = load i32, i32* %4
%31 = add nsw i32 %30, 1
store i32 %31, i32* %4
br label %32
32: ; preds = %46, %29
%33 = load i32, i32* %4
%34 = load i32, i32* %5
%35 = icmp slt i32 %33, %34
br i1 %35, label %36, label %51
36: ; preds = %32
%37 = load i8*, i8** %2
%38 = load i32, i32* %4
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i8, i8* %37, i64 %39
%41 = load i8, i8* %40
%42 = load i8*, i8** %2
%43 = load i32, i32* %3
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i8, i8* %42, i64 %44
store i8 %41, i8* %45
br label %46
46: ; preds = %36
%47 = load i32, i32* %3
%48 = add nsw i32 %47, 1
store i32 %48, i32* %3
%49 = load i32, i32* %4
%50 = add nsw i32 %49, 1
store i32 %50, i32* %4
br label %32
51: ; preds = %32
%52 = load i8*, i8** %2
%53 = load i32, i32* %3
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i8, i8* %52, i64 %54
store i8 0, i8* %55
br label %56
56: ; preds = %51, %26
ret void
}

LLVM IR (-O2):
define void @justArgs(i8* %0) {
%2 = tail call i32 @strlen(i8* %0)
%3 = icmp sgt i32 %2, 0
br i1 %3, label %4, label %235
4: ; preds = %1
%5 = zext i32 %2 to i64
%6 = add nsw i64 %5, -1
%7 = and i64 %5, 3
%8 = icmp ult i64 %6, 3
br i1 %8, label %41, label %9
9: ; preds = %4
%10 = and i64 %5, 4294967292
br label %11
11: ; preds = %11, %9
%12 = phi i64 [ 0, %9 ], [ %38, %11 ]
%13 = phi i32 [ -1, %9 ], [ %37, %11 ]
%14 = phi i64 [ 0, %9 ], [ %39, %11 ]
%15 = getelementptr inbounds i8, i8* %0, i64 %12
%16 = load i8, i8* %15
%17 = icmp eq i8 %16, 47
%18 = trunc i64 %12 to i32
%19 = select i1 %17, i32 %18, i32 %13
%20 = or i64 %12, 1
%21 = getelementptr inbounds i8, i8* %0, i64 %20
%22 = load i8, i8* %21
%23 = icmp eq i8 %22, 47
%24 = trunc i64 %20 to i32
%25 = select i1 %23, i32 %24, i32 %19
%26 = or i64 %12, 2
%27 = getelementptr inbounds i8, i8* %0, i64 %26
%28 = load i8, i8* %27
%29 = icmp eq i8 %28, 47
%30 = trunc i64 %26 to i32
%31 = select i1 %29, i32 %30, i32 %25
%32 = or i64 %12, 3
%33 = getelementptr inbounds i8, i8* %0, i64 %32
%34 = load i8, i8* %33
%35 = icmp eq i8 %34, 47
%36 = trunc i64 %32 to i32
%37 = select i1 %35, i32 %36, i32 %31
%38 = add nuw nsw i64 %12, 4
%39 = add i64 %14, 4
%40 = icmp eq i64 %39, %10
br i1 %40, label %41, label %11
41: ; preds = %11, %4
%42 = phi i32 [ undef, %4 ], [ %37, %11 ]
%43 = phi i64 [ 0, %4 ], [ %38, %11 ]
%44 = phi i32 [ -1, %4 ], [ %37, %11 ]
%45 = icmp eq i64 %7, 0
br i1 %45, label %58, label %46
46: ; preds = %41, %46
%47 = phi i64 [ %55, %46 ], [ %43, %41 ]
%48 = phi i32 [ %54, %46 ], [ %44, %41 ]
%49 = phi i64 [ %56, %46 ], [ 0, %41 ]
%50 = getelementptr inbounds i8, i8* %0, i64 %47
%51 = load i8, i8* %50
%52 = icmp eq i8 %51, 47
%53 = trunc i64 %47 to i32
%54 = select i1 %52, i32 %53, i32 %48
%55 = add nuw nsw i64 %47, 1
%56 = add i64 %49, 1
%57 = icmp eq i64 %56, %7
br i1 %57, label %58, label %46
58: ; preds = %46, %41
%59 = phi i32 [ %42, %41 ], [ %54, %46 ]
%60 = icmp eq i32 %59, -1
br i1 %60, label %235, label %61
61: ; preds = %58
%62 = add nuw i32 %59, 1
%63 = icmp slt i32 %62, %2
br i1 %63, label %64, label %232
64: ; preds = %61
%65 = sext i32 %62 to i64
%66 = xor i32 %59, -1
%67 = add i32 %2, %66
%68 = zext i32 %67 to i64
%69 = icmp ult i32 %67, 8
br i1 %69, label %184, label %70
70: ; preds = %64
%71 = getelementptr i8, i8* %0, i64 %68
%72 = getelementptr i8, i8* %0, i64 %65
%73 = add nsw i64 %65, %68
%74 = getelementptr i8, i8* %0, i64 %73
%75 = icmp ugt i8* %74, %0
%76 = icmp ult i8* %72, %71
%77 = and i1 %75, %76
br i1 %77, label %184, label %78
78: ; preds = %70
%79 = icmp ult i32 %67, 32
br i1 %79, label %168, label %80
80: ; preds = %78
%81 = and i64 %68, 4294967264
%82 = add nsw i64 %81, -32
%83 = lshr exact i64 %82, 5
%84 = add nuw nsw i64 %83, 1
%85 = and i64 %84, 3
%86 = icmp ult i64 %82, 96
br i1 %86, label %142, label %87
87: ; preds = %80
%88 = and i64 %84, 1152921504606846972
br label %89
89: ; preds = %89, %87
%90 = phi i64 [ 0, %87 ], [ %139, %89 ]
%91 = phi i64 [ 0, %87 ], [ %140, %89 ]
%92 = add i64 %90, %65
%93 = getelementptr inbounds i8, i8* %0, i64 %92
%94 = bitcast i8* %93 to <16 x i8>*
%95 = load <16 x i8>, <16 x i8>* %94
%96 = getelementptr inbounds i8, i8* %93, i64 16
%97 = bitcast i8* %96 to <16 x i8>*
%98 = load <16 x i8>, <16 x i8>* %97
%99 = getelementptr inbounds i8, i8* %0, i64 %90
%100 = bitcast i8* %99 to <16 x i8>*
store <16 x i8> %95, <16 x i8>* %100
%101 = getelementptr inbounds i8, i8* %99, i64 16
%102 = bitcast i8* %101 to <16 x i8>*
store <16 x i8> %98, <16 x i8>* %102
%103 = or i64 %90, 32
%104 = add i64 %103, %65
%105 = getelementptr inbounds i8, i8* %0, i64 %104
%106 = bitcast i8* %105 to <16 x i8>*
%107 = load <16 x i8>, <16 x i8>* %106
%108 = getelementptr inbounds i8, i8* %105, i64 16
%109 = bitcast i8* %108 to <16 x i8>*
%110 = load <16 x i8>, <16 x i8>* %109
%111 = getelementptr inbounds i8, i8* %0, i64 %103
%112 = bitcast i8* %111 to <16 x i8>*
store <16 x i8> %107, <16 x i8>* %112
%113 = getelementptr inbounds i8, i8* %111, i64 16
%114 = bitcast i8* %113 to <16 x i8>*
store <16 x i8> %110, <16 x i8>* %114
%115 = or i64 %90, 64
%116 = add i64 %115, %65
%117 = getelementptr inbounds i8, i8* %0, i64 %116
%118 = bitcast i8* %117 to <16 x i8>*
%119 = load <16 x i8>, <16 x i8>* %118
%120 = getelementptr inbounds i8, i8* %117, i64 16
%121 = bitcast i8* %120 to <16 x i8>*
%122 = load <16 x i8>, <16 x i8>* %121
%123 = getelementptr inbounds i8, i8* %0, i64 %115
%124 = bitcast i8* %123 to <16 x i8>*
store <16 x i8> %119, <16 x i8>* %124
%125 = getelementptr inbounds i8, i8* %123, i64 16
%126 = bitcast i8* %125 to <16 x i8>*
store <16 x i8> %122, <16 x i8>* %126
%127 = or i64 %90, 96
%128 = add i64 %127, %65
%129 = getelementptr inbounds i8, i8* %0, i64 %128
%130 = bitcast i8* %129 to <16 x i8>*
%131 = load <16 x i8>, <16 x i8>* %130
%132 = getelementptr inbounds i8, i8* %129, i64 16
%133 = bitcast i8* %132 to <16 x i8>*
%134 = load <16 x i8>, <16 x i8>* %133
%135 = getelementptr inbounds i8, i8* %0, i64 %127
%136 = bitcast i8* %135 to <16 x i8>*
store <16 x i8> %131, <16 x i8>* %136
%137 = getelementptr inbounds i8, i8* %135, i64 16
%138 = bitcast i8* %137 to <16 x i8>*
store <16 x i8> %134, <16 x i8>* %138
%139 = add nuw i64 %90, 128
%140 = add i64 %91, 4
%141 = icmp eq i64 %140, %88
br i1 %141, label %142, label %89
142: ; preds = %89, %80
%143 = phi i64 [ 0, %80 ], [ %139, %89 ]
%144 = icmp eq i64 %85, 0
br i1 %144, label %162, label %145
145: ; preds = %142, %145
%146 = phi i64 [ %159, %145 ], [ %143, %142 ]
%147 = phi i64 [ %160, %145 ], [ 0, %142 ]
%148 = add i64 %146, %65
%149 = getelementptr inbounds i8, i8* %0, i64 %148
%150 = bitcast i8* %149 to <16 x i8>*
%151 = load <16 x i8>, <16 x i8>* %150
%152 = getelementptr inbounds i8, i8* %149, i64 16
%153 = bitcast i8* %152 to <16 x i8>*
%154 = load <16 x i8>, <16 x i8>* %153
%155 = getelementptr inbounds i8, i8* %0, i64 %146
%156 = bitcast i8* %155 to <16 x i8>*
store <16 x i8> %151, <16 x i8>* %156
%157 = getelementptr inbounds i8, i8* %155, i64 16
%158 = bitcast i8* %157 to <16 x i8>*
store <16 x i8> %154, <16 x i8>* %158
%159 = add nuw i64 %146, 32
%160 = add i64 %147, 1
%161 = icmp eq i64 %160, %85
br i1 %161, label %162, label %145
162: ; preds = %145, %142
%163 = icmp eq i64 %81, %68
br i1 %163, label %230, label %164
164: ; preds = %162
%165 = add nsw i64 %81, %65
%166 = and i64 %68, 24
%167 = icmp eq i64 %166, 0
br i1 %167, label %184, label %168
168: ; preds = %78, %164
%169 = phi i64 [ %81, %164 ], [ 0, %78 ]
%170 = and i64 %68, 4294967288
%171 = add nsw i64 %170, %65
br label %172
172: ; preds = %172, %168
%173 = phi i64 [ %169, %168 ], [ %180, %172 ]
%174 = add i64 %173, %65
%175 = getelementptr inbounds i8, i8* %0, i64 %174
%176 = bitcast i8* %175 to <8 x i8>*
%177 = load <8 x i8>, <8 x i8>* %176
%178 = getelementptr inbounds i8, i8* %0, i64 %173
%179 = bitcast i8* %178 to <8 x i8>*
store <8 x i8> %177, <8 x i8>* %179
%180 = add nuw i64 %173, 8
%181 = icmp eq i64 %180, %170
br i1 %181, label %182, label %172
182: ; preds = %172
%183 = icmp eq i64 %170, %68
br i1 %183, label %230, label %184
184: ; preds = %70, %64, %164, %182
%185 = phi i64 [ 0, %64 ], [ 0, %70 ], [ %81, %164 ], [ %170, %182 ]
%186 = phi i64 [ %65, %64 ], [ %65, %70 ], [ %165, %164 ], [ %171, %182 ]
%187 = xor i64 %185, -1
%188 = add nsw i64 %187, %68
%189 = and i64 %68, 3
%190 = icmp eq i64 %189, 0
br i1 %190, label %202, label %191
191: ; preds = %184, %191
%192 = phi i64 [ %198, %191 ], [ %185, %184 ]
%193 = phi i64 [ %199, %191 ], [ %186, %184 ]
%194 = phi i64 [ %200, %191 ], [ 0, %184 ]
%195 = getelementptr inbounds i8, i8* %0, i64 %193
%196 = load i8, i8* %195
%197 = getelementptr inbounds i8, i8* %0, i64 %192
store i8 %196, i8* %197
%198 = add nuw nsw i64 %192, 1
%199 = add nsw i64 %193, 1
%200 = add i64 %194, 1
%201 = icmp eq i64 %200, %189
br i1 %201, label %202, label %191
202: ; preds = %191, %184
%203 = phi i64 [ %185, %184 ], [ %198, %191 ]
%204 = phi i64 [ %186, %184 ], [ %199, %191 ]
%205 = icmp ult i64 %188, 3
br i1 %205, label %230, label %206
206: ; preds = %202, %206
%207 = phi i64 [ %227, %206 ], [ %203, %202 ]
%208 = phi i64 [ %228, %206 ], [ %204, %202 ]
%209 = getelementptr inbounds i8, i8* %0, i64 %208
%210 = load i8, i8* %209
%211 = getelementptr inbounds i8, i8* %0, i64 %207
store i8 %210, i8* %211
%212 = add nuw nsw i64 %207, 1
%213 = add nsw i64 %208, 1
%214 = getelementptr inbounds i8, i8* %0, i64 %213
%215 = load i8, i8* %214
%216 = getelementptr inbounds i8, i8* %0, i64 %212
store i8 %215, i8* %216
%217 = add nuw nsw i64 %207, 2
%218 = add nsw i64 %208, 2
%219 = getelementptr inbounds i8, i8* %0, i64 %218
%220 = load i8, i8* %219
%221 = getelementptr inbounds i8, i8* %0, i64 %217
store i8 %220, i8* %221
%222 = add nuw nsw i64 %207, 3
%223 = add nsw i64 %208, 3
%224 = getelementptr inbounds i8, i8* %0, i64 %223
%225 = load i8, i8* %224
%226 = getelementptr inbounds i8, i8* %0, i64 %222
store i8 %225, i8* %226
%227 = add nuw nsw i64 %207, 4
%228 = add nsw i64 %208, 4
%229 = icmp eq i64 %227, %68
br i1 %229, label %230, label %206
230: ; preds = %202, %206, %182, %162
%231 = zext i32 %67 to i64
br label %232
232: ; preds = %61, %230
%233 = phi i64 [ %231, %230 ], [ 0, %61 ]
%234 = getelementptr inbounds i8, i8* %0, i64 %233
store i8 0, i8* %234
br label %235
235: ; preds = %1, %232, %58
ret void
}