#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 */
char *malloc(int);
size_t strlen(char *);
int getCommands(char *string, char **commands) {
  int i = 0, j = 0, k = 0, count = 0, whitespaceCount = 0;
  size_t len;
  commands[0] = malloc(sizeof(char) * 128);
  for (i = 0; string[i] != '\0'; i++) {
    if (string[i] != '|') {
      commands[j][k] = string[i];
      k++;
    } else {
      commands[j][k] = '\0';
      j++;
      commands[j] = malloc(sizeof(char) * 128);
      k = 0;
    }
  }
  commands[j][k] = '\0';
  for (i = 0; commands[i] != NULL; i++) {
    count++;
    len = strlen(commands[i]);
    j = 0;
    whitespaceCount = 0;
    while (commands[i][j] == ' ') {
      whitespaceCount++;
      j++;
    }
    for (j = 0; j < len; j++) {
      commands[i][j] = commands[i][j + whitespaceCount];
    }
    len = strlen(commands[i]);
    j = (int)len - 1;
    while (commands[i][j] == ' ') {
      commands[i][j] = '\0';
      j--;
    }
  }
  return count - 1;
}


x86 assembly (clang, -O0):
<getCommands>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    $0x80,%edi
call   1040 <malloc@plt>
mov    %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1214 <getCommands+0xf4>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7c,%eax
je     11c4 <getCommands+0xa4>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1201 <getCommands+0xe1>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    $0x80,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x1c(%rbp)
jmp    1206 <getCommands+0xe6>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    116e <getCommands+0x4e>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movl   $0x0,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
je     1361 <getCommands+0x241>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    12a2 <getCommands+0x182>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    126e <getCommands+0x14e>
movl   $0x0,-0x18(%rbp)
movslq -0x18(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    12f0 <getCommands+0x1d0>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    12a9 <getCommands+0x189>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    134e <getCommands+0x22e>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    130f <getCommands+0x1ef>
jmp    1353 <getCommands+0x233>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    122f <getCommands+0x10f>
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getCommands>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %rsi,%r15
mov    %rdi,%rbx
mov    $0x80,%edi
call   1040 <malloc@plt>
mov    %rax,(%r15)
xor    %r14d,%r14d
jmp    1164 <getCommands+0x44>
movslq %r14d,%rbp
mov    (%r15,%rbp,8),%rcx
cltq
movb   $0x0,(%rcx,%rax,1)
lea    0x1(%rbp),%r14d
mov    $0x80,%edi
call   1040 <malloc@plt>
mov    %rax,0x8(%r15,%rbp,8)
add    $0x1,%rbx
xor    %eax,%eax
movzbl (%rbx),%ecx
cmp    $0x7c,%cl
je     1140 <getCommands+0x20>
test   %cl,%cl
je     1188 <getCommands+0x68>
movslq %r14d,%rdx
mov    (%r15,%rdx,8),%rdx
movslq %eax,%rsi
mov    %cl,(%rdx,%rsi,1)
add    $0x1,%eax
add    $0x1,%rbx
jmp    1166 <getCommands+0x46>
movslq %r14d,%rcx
mov    (%r15,%rcx,8),%rcx
cltq
movb   $0x0,(%rcx,%rax,1)
mov    (%r15),%rbx
test   %rbx,%rbx
je     12e0 <getCommands+0x1c0>
xor    %r14d,%r14d
mov    %r15,%r12
jmp    11c1 <getCommands+0xa1>
nopl   0x0(%rax)
lea    (%r15,%r14,8),%r12
mov    (%r15,%r14,8),%rbx
test   %rbx,%rbx
je     12da <getCommands+0x1ba>
mov    %rbx,%rdi
call   1030 <strlen@plt>
cmpb   $0x20,(%rbx)
jne    11f0 <getCommands+0xd0>
xor    %edx,%edx
lea    0x1(%rdx),%rcx
cmpb   $0x20,0x1(%rbx,%rdx,1)
mov    %rcx,%rdx
je     11d0 <getCommands+0xb0>
test   %rax,%rax
jne    11fb <getCommands+0xdb>
jmp    1299 <getCommands+0x179>
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
test   %rax,%rax
je     1299 <getCommands+0x179>
mov    %ecx,%ebp
lea    -0x1(%rax),%rsi
mov    %eax,%edx
and    $0x3,%edx
cmp    $0x3,%rsi
jae    1210 <getCommands+0xf0>
xor    %esi,%esi
jmp    1271 <getCommands+0x151>
and    $0xfffffffffffffffc,%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
lea    (%rbx,%rbp,1),%rdi
movzbl (%rsi,%rdi,1),%ecx
mov    %cl,(%rbx,%rsi,1)
mov    (%r12),%rcx
lea    (%rcx,%rbp,1),%rdi
add    $0x1,%rdi
movzbl (%rsi,%rdi,1),%ebx
mov    %bl,0x1(%rcx,%rsi,1)
mov    (%r12),%rcx
lea    0x2(%rcx,%rbp,1),%rdi
movzbl (%rsi,%rdi,1),%ebx
mov    %bl,0x2(%rcx,%rsi,1)
mov    (%r12),%rcx
lea    (%rcx,%rbp,1),%rdi
add    $0x3,%rdi
movzbl (%rsi,%rdi,1),%ebx
mov    %bl,0x3(%rcx,%rsi,1)
add    $0x4,%rsi
mov    (%r12),%rbx
cmp    %rsi,%rax
jne    1220 <getCommands+0x100>
test   %rdx,%rdx
je     1299 <getCommands+0x179>
cs nopw 0x0(%rax,%rax,1)
lea    (%rbx,%rbp,1),%rax
movzbl (%rsi,%rax,1),%eax
mov    %al,(%rbx,%rsi,1)
add    $0x1,%rsi
mov    (%r12),%rbx
add    $0xffffffffffffffff,%rdx
jne    1280 <getCommands+0x160>
add    $0x1,%r14
mov    %rbx,%rdi
call   1030 <strlen@plt>
lea    -0x1(%rax),%ecx
movslq %ecx,%rcx
cmpb   $0x20,(%rbx,%rcx,1)
jne    11b0 <getCommands+0x90>
add    %rcx,%rbx
cltq
add    $0xfffffffffffffffe,%rax
xchg   %ax,%ax
movb   $0x0,(%rbx)
mov    (%r12),%rcx
lea    (%rcx,%rax,1),%rbx
cmpb   $0x20,(%rcx,%rax,1)
lea    -0x1(%rax),%rax
je     12c0 <getCommands+0x1a0>
jmp    11b0 <getCommands+0x90>
add    $0xffffffff,%r14d
jmp    12e6 <getCommands+0x1c6>
mov    $0xffffffff,%r14d
mov    %r14d,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @getCommands(i8* %0, i8** %1) {
%3 = alloca i8*
%4 = alloca i8**
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i64
store i8* %0, i8** %3
store i8** %1, i8*** %4
store i32 0, i32* %5
store i32 0, i32* %6
store i32 0, i32* %7
store i32 0, i32* %8
store i32 0, i32* %9
%11 = call i8* @malloc(i32 128)
%12 = load i8**, i8*** %4
%13 = getelementptr inbounds i8*, i8** %12, i64 0
store i8* %11, i8** %13
store i32 0, i32* %5
br label %14
14: ; preds = %63, %2
%15 = load i8*, i8** %3
%16 = load i32, i32* %5
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds i8, i8* %15, i64 %17
%19 = load i8, i8* %18
%20 = sext i8 %19 to i32
%21 = icmp ne i32 %20, 0
br i1 %21, label %22, label %66
22: ; preds = %14
%23 = load i8*, i8** %3
%24 = load i32, i32* %5
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds i8, i8* %23, i64 %25
%27 = load i8, i8* %26
%28 = sext i8 %27 to i32
%29 = icmp ne i32 %28, 124
br i1 %29, label %30, label %46
30: ; preds = %22
%31 = load i8*, i8** %3
%32 = load i32, i32* %5
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i8, i8* %31, i64 %33
%35 = load i8, i8* %34
%36 = load i8**, i8*** %4
%37 = load i32, i32* %6
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds i8*, i8** %36, i64 %38
%40 = load i8*, i8** %39
%41 = load i32, i32* %7
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds i8, i8* %40, i64 %42
store i8 %35, i8* %43
%44 = load i32, i32* %7
%45 = add nsw i32 %44, 1
store i32 %45, i32* %7
br label %62
46: ; preds = %22
%47 = load i8**, i8*** %4
%48 = load i32, i32* %6
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8*, i8** %47, i64 %49
%51 = load i8*, i8** %50
%52 = load i32, i32* %7
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i8, i8* %51, i64 %53
store i8 0, i8* %54
%55 = load i32, i32* %6
%56 = add nsw i32 %55, 1
store i32 %56, i32* %6
%57 = call i8* @malloc(i32 128)
%58 = load i8**, i8*** %4
%59 = load i32, i32* %6
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i8*, i8** %58, i64 %60
store i8* %57, i8** %61
store i32 0, i32* %7
br label %62
62: ; preds = %46, %30
br label %63
63: ; preds = %62
%64 = load i32, i32* %5
%65 = add nsw i32 %64, 1
store i32 %65, i32* %5
br label %14
66: ; preds = %14
%67 = load i8**, i8*** %4
%68 = load i32, i32* %6
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i8*, i8** %67, i64 %69
%71 = load i8*, i8** %70
%72 = load i32, i32* %7
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i8, i8* %71, i64 %73
store i8 0, i8* %74
store i32 0, i32* %5
br label %75
75: ; preds = %171, %66
%76 = load i8**, i8*** %4
%77 = load i32, i32* %5
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds i8*, i8** %76, i64 %78
%80 = load i8*, i8** %79
%81 = icmp ne i8* %80, null
br i1 %81, label %82, label %174
82: ; preds = %75
%83 = load i32, i32* %8
%84 = add nsw i32 %83, 1
store i32 %84, i32* %8
%85 = load i8**, i8*** %4
%86 = load i32, i32* %5
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds i8*, i8** %85, i64 %87
%89 = load i8*, i8** %88
%90 = call i64 @strlen(i8* %89)
store i64 %90, i64* %10
store i32 0, i32* %6
store i32 0, i32* %9
br label %91
91: ; preds = %103, %82
%92 = load i8**, i8*** %4
%93 = load i32, i32* %5
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i8*, i8** %92, i64 %94
%96 = load i8*, i8** %95
%97 = load i32, i32* %6
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds i8, i8* %96, i64 %98
%100 = load i8, i8* %99
%101 = sext i8 %100 to i32
%102 = icmp eq i32 %101, 32
br i1 %102, label %103, label %108
103: ; preds = %91
%104 = load i32, i32* %9
%105 = add nsw i32 %104, 1
store i32 %105, i32* %9
%106 = load i32, i32* %6
%107 = add nsw i32 %106, 1
store i32 %107, i32* %6
br label %91
108: ; preds = %91
store i32 0, i32* %6
br label %109
109: ; preds = %134, %108
%110 = load i32, i32* %6
%111 = sext i32 %110 to i64
%112 = load i64, i64* %10
%113 = icmp ult i64 %111, %112
br i1 %113, label %114, label %137
114: ; preds = %109
%115 = load i8**, i8*** %4
%116 = load i32, i32* %5
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i8*, i8** %115, i64 %117
%119 = load i8*, i8** %118
%120 = load i32, i32* %6
%121 = load i32, i32* %9
%122 = add nsw i32 %120, %121
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds i8, i8* %119, i64 %123
%125 = load i8, i8* %124
%126 = load i8**, i8*** %4
%127 = load i32, i32* %5
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i8*, i8** %126, i64 %128
%130 = load i8*, i8** %129
%131 = load i32, i32* %6
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds i8, i8* %130, i64 %132
store i8 %125, i8* %133
br label %134
134: ; preds = %114
%135 = load i32, i32* %6
%136 = add nsw i32 %135, 1
store i32 %136, i32* %6
br label %109
137: ; preds = %109
%138 = load i8**, i8*** %4
%139 = load i32, i32* %5
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds i8*, i8** %138, i64 %140
%142 = load i8*, i8** %141
%143 = call i64 @strlen(i8* %142)
store i64 %143, i64* %10
%144 = load i64, i64* %10
%145 = trunc i64 %144 to i32
%146 = sub nsw i32 %145, 1
store i32 %146, i32* %6
br label %147
147: ; preds = %159, %137
%148 = load i8**, i8*** %4
%149 = load i32, i32* %5
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i8*, i8** %148, i64 %150
%152 = load i8*, i8** %151
%153 = load i32, i32* %6
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds i8, i8* %152, i64 %154
%156 = load i8, i8* %155
%157 = sext i8 %156 to i32
%158 = icmp eq i32 %157, 32
br i1 %158, label %159, label %170
159: ; preds = %147
%160 = load i8**, i8*** %4
%161 = load i32, i32* %5
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds i8*, i8** %160, i64 %162
%164 = load i8*, i8** %163
%165 = load i32, i32* %6
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds i8, i8* %164, i64 %166
store i8 0, i8* %167
%168 = load i32, i32* %6
%169 = add nsw i32 %168, -1
store i32 %169, i32* %6
br label %147
170: ; preds = %147
br label %171
171: ; preds = %170
%172 = load i32, i32* %5
%173 = add nsw i32 %172, 1
store i32 %173, i32* %5
br label %75
174: ; preds = %75
%175 = load i32, i32* %8
%176 = sub nsw i32 %175, 1
ret i32 %176
}

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