#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*/ free_ivector(int *, int, int);
int *ivector(int, int);
void trnspt(int iorder[], int ncity, int n[]) {
  int m1, m2, m3, nn, j, jj, *jorder;
  jorder = ivector(1, ncity);
  m1 = 1 + ((n[2] - n[1] + ncity) % ncity);
  m2 = 1 + ((n[5] - n[4] + ncity) % ncity);
  m3 = 1 + ((n[3] - n[6] + ncity) % ncity);
  nn = 1;
  for (j = 1; j <= m1; j++) {
    jj = 1 + ((j + n[1] - 2) % ncity);
    jorder[nn++] = iorder[jj];
  }
  for (j = 1; j <= m2; j++) {
    jj = 1 + ((j + n[4] - 2) % ncity);
    jorder[nn++] = iorder[jj];
  }
  for (j = 1; j <= m3; j++) {
    jj = 1 + ((j + n[6] - 2) % ncity);
    jorder[nn++] = iorder[jj];
  }
  for (j = 1; j <= ncity; j++)
    iorder[j] = jorder[j];
  free_ivector(jorder, 1, ncity);
}


x86 assembly (clang, -O0):
<trnspt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
call   1040 <ivector@plt>
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%eax
mov    -0x18(%rbp),%rcx
sub    0x4(%rcx),%eax
add    -0xc(%rbp),%eax
cltd
idivl  -0xc(%rbp)
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
mov    0x14(%rax),%eax
mov    -0x18(%rbp),%rcx
sub    0x10(%rcx),%eax
add    -0xc(%rbp),%eax
cltd
idivl  -0xc(%rbp)
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    0xc(%rax),%eax
mov    -0x18(%rbp),%rcx
sub    0x18(%rcx),%eax
add    -0xc(%rbp),%eax
cltd
idivl  -0xc(%rbp)
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
movl   $0x1,-0x28(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     11f4 <trnspt+0xd4>
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%rcx
add    0x4(%rcx),%eax
sub    $0x2,%eax
cltd
idivl  -0xc(%rbp)
add    $0x1,%edx
mov    %edx,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11a3 <trnspt+0x83>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     124c <trnspt+0x12c>
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%rcx
add    0x10(%rcx),%eax
sub    $0x2,%eax
cltd
idivl  -0xc(%rbp)
add    $0x1,%edx
mov    %edx,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11fb <trnspt+0xdb>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     12a4 <trnspt+0x184>
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%rcx
add    0x18(%rcx),%eax
sub    $0x2,%eax
cltd
idivl  -0xc(%rbp)
add    $0x1,%edx
mov    %edx,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1253 <trnspt+0x133>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     12db <trnspt+0x1bb>
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12ab <trnspt+0x18b>
mov    -0x38(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1030 <free_ivector@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<trnspt>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %rdx,%r15
mov    %esi,%r14d
mov    %rdi,%rbx
mov    $0x1,%ebp
mov    $0x1,%edi
call   1040 <ivector@plt>
mov    %rax,%rdi
mov    0x4(%r15),%r8d
mov    0x8(%r15),%eax
add    %r14d,%eax
sub    %r8d,%eax
cltd
idiv   %r14d
mov    %edx,%r9d
mov    0x14(%r15),%eax
add    %r14d,%eax
sub    0x10(%r15),%eax
cltd
idiv   %r14d
mov    %edx,%esi
mov    0xc(%r15),%eax
add    %r14d,%eax
sub    0x18(%r15),%eax
cltd
idiv   %r14d
mov    %edx,%r10d
test   %r9d,%r9d
js     1217 <trnspt+0xf7>
lea    0x2(%r9),%ebp
add    $0xffffffff,%r8d
mov    %r8d,%eax
cltd
idiv   %r14d
movslq %edx,%rax
mov    0x4(%rbx,%rax,4),%eax
mov    %eax,0x4(%rdi)
test   %r9d,%r9d
je     1217 <trnspt+0xf7>
mov    $0x2,%ecx
cmp    $0x3,%ebp
je     11fa <trnspt+0xda>
lea    -0x2(%rbp),%r8
and    $0xfffffffffffffffe,%r8
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x4(%r15),%eax
add    %ecx,%eax
cltd
idiv   %r14d
movslq %edx,%rax
mov    0x4(%rbx,%rax,4),%eax
mov    %eax,0x8(%rdi,%rcx,4)
mov    0x4(%r15),%eax
add    %ecx,%eax
add    $0x1,%eax
cltd
idiv   %r14d
movslq %edx,%rax
mov    0x4(%rbx,%rax,4),%eax
mov    %eax,0xc(%rdi,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r8
jne    11c0 <trnspt+0xa0>
add    $0x2,%rcx
test   $0x1,%bpl
je     1217 <trnspt+0xf7>
mov    0x4(%r15),%eax
add    %ecx,%eax
add    $0xfffffffe,%eax
cltd
idiv   %r14d
movslq %edx,%rax
mov    0x4(%rbx,%rax,4),%eax
mov    %eax,(%rdi,%rcx,4)
test   %esi,%esi
js     124f <trnspt+0x12f>
mov    %ebp,%ebp
mov    $0xffffffff,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x10(%r15),%eax
add    %ecx,%eax
cltd
idiv   %r14d
movslq %edx,%rax
mov    0x4(%rbx,%rax,4),%eax
mov    %eax,(%rdi,%rbp,4)
add    $0x1,%rbp
add    $0x1,%ecx
cmp    %ecx,%esi
jne    1230 <trnspt+0x110>
test   %r10d,%r10d
js     127f <trnspt+0x15f>
mov    %ebp,%eax
lea    (%rdi,%rax,4),%rcx
mov    $0xffffffff,%esi
nop
mov    0x18(%r15),%eax
add    %esi,%eax
cltd
idiv   %r14d
movslq %edx,%rax
mov    0x4(%rbx,%rax,4),%eax
mov    %eax,(%rcx)
add    $0x4,%rcx
add    $0x1,%esi
cmp    %esi,%r10d
jne    1260 <trnspt+0x140>
test   %r14d,%r14d
jle    13e7 <trnspt+0x2c7>
mov    %r14d,%r8d
lea    0x1(%r8),%rax
mov    $0x1,%ecx
cmp    $0x8,%r14d
jb     1381 <trnspt+0x261>
lea    0x4(%rbx),%rdx
lea    (%rdi,%rax,4),%rsi
cmp    %rsi,%rdx
jae    12bf <trnspt+0x19f>
lea    (%rbx,%rax,4),%rdx
mov    %rdi,%rsi
add    $0x4,%rsi
cmp    %rdx,%rsi
jb     1381 <trnspt+0x261>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rbp
mov    %rbp,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rbp
jae    12e3 <trnspt+0x1c3>
xor    %ebp,%ebp
jmp    134a <trnspt+0x22a>
and    $0xfffffffffffffffc,%rsi
xor    %ebp,%ebp
nopl   0x0(%rax)
movups 0x4(%rdi,%rbp,4),%xmm0
movups 0x14(%rdi,%rbp,4),%xmm1
movups %xmm0,0x4(%rbx,%rbp,4)
movups %xmm1,0x14(%rbx,%rbp,4)
movups 0x24(%rdi,%rbp,4),%xmm0
movups 0x34(%rdi,%rbp,4),%xmm1
movups %xmm0,0x24(%rbx,%rbp,4)
movups %xmm1,0x34(%rbx,%rbp,4)
movups 0x44(%rdi,%rbp,4),%xmm0
movups 0x54(%rdi,%rbp,4),%xmm1
movups %xmm0,0x44(%rbx,%rbp,4)
movups %xmm1,0x54(%rbx,%rbp,4)
movups 0x64(%rdi,%rbp,4),%xmm0
movups 0x74(%rdi,%rbp,4),%xmm1
movups %xmm0,0x64(%rbx,%rbp,4)
movups %xmm1,0x74(%rbx,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rsi
jne    12f0 <trnspt+0x1d0>
test   %rdx,%rdx
je     1378 <trnspt+0x258>
nop
lea    0x0(,%rbp,4),%rsi
or     $0x4,%rsi
movups (%rdi,%rsi,1),%xmm0
movups 0x10(%rdi,%rsi,1),%xmm1
movups %xmm0,(%rbx,%rsi,1)
movups %xmm1,0x10(%rbx,%rsi,1)
add    $0x8,%rbp
add    $0xffffffffffffffff,%rdx
jne    1350 <trnspt+0x230>
cmp    %rcx,%r8
je     13e7 <trnspt+0x2c7>
or     $0x1,%rcx
mov    %eax,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
and    $0x3,%rsi
je     13b0 <trnspt+0x290>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rdi,%rcx,4),%ebp
mov    %ebp,(%rbx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    13a0 <trnspt+0x280>
cmp    $0x3,%rdx
jb     13e7 <trnspt+0x2c7>
cs nopw 0x0(%rax,%rax,1)
mov    (%rdi,%rcx,4),%edx
mov    %edx,(%rbx,%rcx,4)
mov    0x4(%rdi,%rcx,4),%edx
mov    %edx,0x4(%rbx,%rcx,4)
mov    0x8(%rdi,%rcx,4),%edx
mov    %edx,0x8(%rbx,%rcx,4)
mov    0xc(%rdi,%rcx,4),%edx
mov    %edx,0xc(%rbx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    13c0 <trnspt+0x2a0>
mov    $0x1,%esi
mov    %r14d,%edx
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free_ivector@plt>

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

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