#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 */
void sort(char *sorted_one[], char *sorted_two[], int dash_positions[],
          int word_positions[], char *words[], char dash[], size_t size) {
  int buckets[100];
  int i;
  for (i = 0; i < 100; i++) {
    buckets[i] = 0;
  }
  for (i = 0; i < size; i++) {
    buckets[dash_positions[i]]++;
    buckets[word_positions[i]]++;
  }
  for (i = 1; i < 100; i++) {
    buckets[i] += buckets[i - 1];
  }
  for (i = size - 1; i >= 0; i--) {
    if (--buckets[word_positions[i]] >= size) {
      sorted_two[buckets[word_positions[i]] - size] = words[i];
    } else {
      sorted_one[buckets[word_positions[i]]] = words[i];
    }
  }
  for (i = size - 1; i >= 0; i--) {
    if (--buckets[dash_positions[i]] >= size) {
      sorted_two[buckets[dash_positions[i]] - size] = dash;
    } else {
      sorted_one[buckets[dash_positions[i]]] = dash;
    }
  }
}


x86 assembly (clang, -O0):
<sort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x1c4(%rbp)
cmpl   $0x64,-0x1c4(%rbp)
jge    1164 <sort+0x64>
movslq -0x1c4(%rbp),%rax
movl   $0x0,-0x1c0(%rbp,%rax,4)
mov    -0x1c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c4(%rbp)
jmp    1131 <sort+0x31>
movl   $0x0,-0x1c4(%rbp)
movslq -0x1c4(%rbp),%rax
cmp    0x10(%rbp),%rax
jae    11d3 <sort+0xd3>
mov    -0x18(%rbp),%rax
movslq -0x1c4(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
mov    -0x1c0(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x1c0(%rbp,%rax,4)
mov    -0x20(%rbp),%rax
movslq -0x1c4(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
mov    -0x1c0(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x1c0(%rbp,%rax,4)
mov    -0x1c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c4(%rbp)
jmp    116e <sort+0x6e>
movl   $0x1,-0x1c4(%rbp)
cmpl   $0x64,-0x1c4(%rbp)
jge    1225 <sort+0x125>
mov    -0x1c4(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x1c0(%rbp,%rax,4),%ecx
movslq -0x1c4(%rbp),%rax
add    -0x1c0(%rbp,%rax,4),%ecx
mov    %ecx,-0x1c0(%rbp,%rax,4)
mov    -0x1c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c4(%rbp)
jmp    11dd <sort+0xdd>
mov    0x10(%rbp),%rax
sub    $0x1,%rax
mov    %eax,-0x1c4(%rbp)
cmpl   $0x0,-0x1c4(%rbp)
jl     12ea <sort+0x1ea>
mov    -0x20(%rbp),%rax
movslq -0x1c4(%rbp),%rcx
movslq (%rax,%rcx,4),%rcx
mov    -0x1c0(%rbp,%rcx,4),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c0(%rbp,%rcx,4)
cltq
cmp    0x10(%rbp),%rax
jb     12a3 <sort+0x1a3>
mov    -0x28(%rbp),%rax
movslq -0x1c4(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x1c4(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
movslq -0x1c0(%rbp,%rcx,4),%rcx
ff
sub    0x10(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    12d1 <sort+0x1d1>
mov    -0x28(%rbp),%rax
movslq -0x1c4(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x1c4(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
movslq -0x1c0(%rbp,%rcx,4),%rcx
ff
mov    %rdx,(%rax,%rcx,8)
jmp    12d6 <sort+0x1d6>
mov    -0x1c4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c4(%rbp)
jmp    1233 <sort+0x133>
mov    0x10(%rbp),%rax
sub    $0x1,%rax
mov    %eax,-0x1c4(%rbp)
cmpl   $0x0,-0x1c4(%rbp)
jl     1399 <sort+0x299>
mov    -0x18(%rbp),%rax
movslq -0x1c4(%rbp),%rcx
movslq (%rax,%rcx,4),%rcx
mov    -0x1c0(%rbp,%rcx,4),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c0(%rbp,%rcx,4)
cltq
cmp    0x10(%rbp),%rax
jb     135d <sort+0x25d>
mov    -0x30(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x1c4(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
movslq -0x1c0(%rbp,%rcx,4),%rcx
ff
sub    0x10(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1380 <sort+0x280>
mov    -0x30(%rbp),%rdx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x1c4(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
movslq -0x1c0(%rbp,%rcx,4),%rcx
ff
mov    %rdx,(%rax,%rcx,8)
jmp    1385 <sort+0x285>
mov    -0x1c4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c4(%rbp)
jmp    12f8 <sort+0x1f8>
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1a8,%rsp
mov    %r9,0x8(%rsp)
mov    %r8,%r13
mov    %rcx,%rbp
mov    %rdx,%r15
mov    %rsi,%r12
mov    %rdi,%rbx
lea    0x10(%rsp),%rdi
xor    %r14d,%r14d
mov    $0x190,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x1e0(%rsp),%r11
test   %r11,%r11
je     11be <sort+0xae>
cmp    $0x1,%r11
jne    1160 <sort+0x50>
xor    %eax,%eax
jmp    11a0 <sort+0x90>
mov    %r11,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movslq (%r15,%rax,4),%rdx
addl   $0x1,0x10(%rsp,%rdx,4)
movslq 0x0(%rbp,%rax,4),%rdx
addl   $0x1,0x10(%rsp,%rdx,4)
movslq 0x4(%r15,%rax,4),%rdx
addl   $0x1,0x10(%rsp,%rdx,4)
movslq 0x4(%rbp,%rax,4),%rdx
addl   $0x1,0x10(%rsp,%rdx,4)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1170 <sort+0x60>
test   $0x1,%r11b
je     11b9 <sort+0xa9>
movslq (%r15,%rax,4),%rcx
addl   $0x1,0x10(%rsp,%rcx,4)
movslq 0x0(%rbp,%rax,4),%rax
addl   $0x1,0x10(%rsp,%rax,4)
mov    0x10(%rsp),%r14d
mov    $0x3,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    0x8(%rsp,%rax,4),%r14d
mov    %r14d,0x8(%rsp,%rax,4)
add    0xc(%rsp,%rax,4),%r14d
mov    %r14d,0xc(%rsp,%rax,4)
add    0x10(%rsp,%rax,4),%r14d
mov    %r14d,0x10(%rsp,%rax,4)
add    $0x3,%rax
cmp    $0x66,%rax
jne    11d0 <sort+0xc0>
mov    %r11d,%r9d
add    $0xffffffff,%r9d
mov    0x8(%rsp),%r10
js     1354 <sort+0x244>
mov    %r9d,%eax
lea    0x1(%rax),%r8
test   $0x1,%r8b
jne    1224 <sort+0x114>
mov    %rax,%rsi
test   %r9d,%r9d
jne    1257 <sort+0x147>
jmp    12be <sort+0x1ae>
movslq 0x0(%rbp,%rax,4),%rsi
movslq 0x10(%rsp,%rsi,4),%rdi
lea    -0x1(%rdi),%rdx
mov    %edx,0x10(%rsp,%rsi,4)
sub    %r11,%rdx
mov    0x0(%r13,%rax,8),%rsi
lea    (%r12,%rdx,8),%rdx
lea    -0x8(%rbx,%rdi,8),%rdi
cmovae %rdx,%rdi
mov    %rsi,(%rdi)
lea    -0x1(%rax),%rsi
test   %r9d,%r9d
je     12be <sort+0x1ae>
add    $0x2,%rsi
nopl   0x0(%rax,%rax,1)
movslq -0x8(%rbp,%rsi,4),%rdx
movslq 0x10(%rsp,%rdx,4),%rdi
lea    -0x1(%rdi),%rcx
mov    %ecx,0x10(%rsp,%rdx,4)
sub    %r11,%rcx
mov    -0x10(%r13,%rsi,8),%rdx
lea    (%r12,%rcx,8),%rcx
lea    -0x8(%rbx,%rdi,8),%rdi
cmovae %rcx,%rdi
mov    %rdx,(%rdi)
movslq -0xc(%rbp,%rsi,4),%rcx
movslq 0x10(%rsp,%rcx,4),%rdx
lea    -0x1(%rdx),%rdi
mov    %edi,0x10(%rsp,%rcx,4)
sub    %r11,%rdi
lea    (%r12,%rdi,8),%rcx
lea    -0x8(%rbx,%rdx,8),%rdx
cmovae %rcx,%rdx
mov    -0x18(%r13,%rsi,8),%rcx
mov    %rcx,(%rdx)
add    $0xfffffffffffffffe,%rsi
cmp    $0x1,%rsi
jg     1260 <sort+0x150>
test   %r9d,%r9d
js     1354 <sort+0x244>
test   $0x1,%r8b
je     12f5 <sort+0x1e5>
movslq (%r15,%rax,4),%rdx
movslq 0x10(%rsp,%rdx,4),%rsi
lea    -0x1(%rsi),%rdi
mov    %edi,0x10(%rsp,%rdx,4)
sub    %r11,%rdi
lea    (%r12,%rdi,8),%rdx
lea    -0x8(%rbx,%rsi,8),%rsi
cmovae %rdx,%rsi
mov    %r10,(%rsi)
add    $0xffffffffffffffff,%rax
test   %r9d,%r9d
je     1354 <sort+0x244>
add    $0x2,%rax
xchg   %ax,%ax
movslq -0x8(%r15,%rax,4),%rcx
movslq 0x10(%rsp,%rcx,4),%rdx
lea    -0x1(%rdx),%rsi
mov    %esi,0x10(%rsp,%rcx,4)
sub    %r11,%rsi
lea    (%r12,%rsi,8),%rcx
lea    -0x8(%rbx,%rdx,8),%rdx
cmovae %rcx,%rdx
mov    %r10,(%rdx)
movslq -0xc(%r15,%rax,4),%rcx
movslq 0x10(%rsp,%rcx,4),%rdx
lea    -0x1(%rdx),%rsi
mov    %esi,0x10(%rsp,%rcx,4)
sub    %r11,%rsi
lea    (%r12,%rsi,8),%rcx
lea    -0x8(%rbx,%rdx,8),%rdx
cmovae %rcx,%rdx
mov    %r10,(%rdx)
add    $0xfffffffffffffffe,%rax
cmp    $0x1,%rax
jg     1300 <sort+0x1f0>
add    $0x1a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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