#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 */
scalar_t__ calloc(int, int);
void translate(int *image, int *width, int *height, int *depth, int *x_start,
               int *y_start, int *x_end, int *y_end, int *t_width,
               int *t_height) {
  int *tmp_block;
  int i, j, k, tmp, src, dst;
  if (*x_start + *t_width > *width || *x_end + *t_width > *width) {
    *t_width = (*width - *x_start) >= (*width - *x_end) ? (*width - *x_end)
                                                        : (*width - *x_start);
  }
  if (*y_start + *t_height > *height || *y_end + *t_height > *height) {
    *t_height = (*height - *y_start) >= (*height - *y_end)
                    ? (*height - *y_end)
                    : (*height - *y_start);
  }
  tmp_block = (int *)calloc(*t_width * *t_height * *depth, sizeof(int));
  tmp = 0;
  for (i = 0; i < *t_width; i++) {
    for (j = 0; j < *t_height; j++) {
      for (k = 0; k < *depth; k++) {
        src = ((*height) * (*x_start + i) + (*y_start + j) +
               (*width) * (*height) * (k));
        tmp_block[tmp] = image[src];
        tmp++;
      }
    }
  }
  tmp = 0;
  for (i = 0; i < *t_width; i++) {
    for (j = 0; j < *t_height; j++) {
      for (k = 0; k < *depth; k++) {
        dst = ((*height) * (*x_end + i) + (*y_end + j) +
               (*width) * (*height) * (k));
        image[dst] = tmp_block[tmp];
        tmp++;
      }
    }
  }
  return;
}


x86 assembly (clang, -O0):
<translate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
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)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    0x20(%rbp),%rcx
add    (%rcx),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jg     1170 <translate+0x60>
mov    0x10(%rbp),%rax
mov    (%rax),%eax
mov    0x20(%rbp),%rcx
add    (%rcx),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jle    11bc <translate+0xac>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    -0x28(%rbp),%rcx
sub    (%rcx),%eax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
mov    0x10(%rbp),%rdx
sub    (%rdx),%ecx
cmp    %ecx,%eax
jl     11a4 <translate+0x94>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    0x10(%rbp),%rcx
sub    (%rcx),%eax
mov    %eax,-0x54(%rbp)
jmp    11b3 <translate+0xa3>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    -0x28(%rbp),%rcx
sub    (%rcx),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%ecx
mov    0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    0x28(%rbp),%rcx
add    (%rcx),%eax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%eax
jg     11ec <translate+0xdc>
mov    0x18(%rbp),%rax
mov    (%rax),%eax
mov    0x28(%rbp),%rcx
add    (%rcx),%eax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%eax
jle    1238 <translate+0x128>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    -0x30(%rbp),%rcx
sub    (%rcx),%eax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%ecx
mov    0x18(%rbp),%rdx
sub    (%rdx),%ecx
cmp    %ecx,%eax
jl     1220 <translate+0x110>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    0x18(%rbp),%rcx
sub    (%rcx),%eax
mov    %eax,-0x58(%rbp)
jmp    122f <translate+0x11f>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    -0x30(%rbp),%rcx
sub    (%rcx),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%ecx
mov    0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    0x20(%rbp),%rax
mov    (%rax),%edi
mov    0x28(%rbp),%rax
imul   (%rax),%edi
mov    -0x20(%rbp),%rax
imul   (%rax),%edi
mov    $0x4,%esi
call   1030 <calloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x20(%rbp),%rcx
cmp    (%rcx),%eax
jge    1329 <translate+0x219>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    0x28(%rbp),%rcx
cmp    (%rcx),%eax
jge    1316 <translate+0x206>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jge    1303 <translate+0x1f3>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    -0x28(%rbp),%rcx
mov    (%rcx),%ecx
add    -0x3c(%rbp),%ecx
imul   %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    (%rcx),%ecx
add    -0x40(%rbp),%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x18(%rbp),%rdx
imul   (%rdx),%ecx
imul   -0x44(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1294 <translate+0x184>
jmp    1308 <translate+0x1f8>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    127e <translate+0x16e>
jmp    131b <translate+0x20b>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1268 <translate+0x158>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x20(%rbp),%rcx
cmp    (%rcx),%eax
jge    13f8 <translate+0x2e8>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    0x28(%rbp),%rcx
cmp    (%rcx),%eax
jge    13e5 <translate+0x2d5>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jge    13d2 <translate+0x2c2>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
add    -0x3c(%rbp),%ecx
imul   %ecx,%eax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
add    -0x40(%rbp),%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x18(%rbp),%rdx
imul   (%rdx),%ecx
imul   -0x44(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1363 <translate+0x253>
jmp    13d7 <translate+0x2c7>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    134d <translate+0x23d>
jmp    13ea <translate+0x2da>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1337 <translate+0x227>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<translate>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rcx,%r14
mov    %rdx,%r15
mov    %rsi,%r12
mov    %rdi,%r13
mov    0x68(%rsp),%rbx
mov    0x60(%rsp),%r11
mov    0x58(%rsp),%r10
mov    0x50(%rsp),%rsi
mov    (%r8),%ecx
mov    (%r11),%eax
lea    (%rax,%rcx,1),%edi
mov    (%r12),%edx
mov    (%rsi),%esi
cmp    %edx,%edi
jg     1158 <translate+0x48>
lea    (%rsi,%rax,1),%edi
cmp    %edx,%edi
jle    1164 <translate+0x54>
cmp    %ecx,%esi
cmovl  %ecx,%esi
sub    %esi,%edx
mov    %edx,(%r11)
mov    %edx,%eax
mov    %r8,0x10(%rsp)
mov    %r9,0x8(%rsp)
mov    (%r9),%edx
mov    (%rbx),%edi
lea    (%rdi,%rdx,1),%ebp
mov    (%r15),%ecx
mov    (%r10),%esi
cmp    %ecx,%ebp
jg     1187 <translate+0x77>
lea    (%rsi,%rdi,1),%ebp
cmp    %ecx,%ebp
jle    1195 <translate+0x85>
cmp    %edx,%esi
cmovl  %edx,%esi
sub    %esi,%ecx
mov    %ecx,(%rbx)
mov    (%r11),%eax
mov    %ecx,%edi
imul   %eax,%edi
imul   (%r14),%edi
mov    $0x4,%esi
mov    %r11,%rbp
call   1030 <calloc@plt>
mov    0x0(%rbp),%esi
test   %esi,%esi
jle    12d7 <translate+0x1c7>
mov    %rbx,%r9
mov    (%rbx),%edi
xor    %r11d,%r11d
xor    %r8d,%r8d
mov    0x8(%rsp),%rcx
mov    0x10(%rsp),%r10
jmp    11e0 <translate+0xd0>
nopl   0x0(%rax,%rax,1)
mov    0x60(%rsp),%rdx
mov    (%rdx),%esi
add    $0x1,%r11d
cmp    %esi,%r11d
jge    1248 <translate+0x138>
test   %edi,%edi
jle    11d7 <translate+0xc7>
mov    (%r14),%edx
xor    %esi,%esi
jmp    11f7 <translate+0xe7>
nopl   0x0(%rax,%rax,1)
add    $0x1,%esi
cmp    %edi,%esi
jge    11d0 <translate+0xc0>
test   %edx,%edx
jle    11f0 <translate+0xe0>
movslq %r8d,%rdx
lea    (%rax,%rdx,4),%rbp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r10),%edx
add    %r11d,%edx
mov    (%r12),%ebx
imul   %edi,%ebx
add    %edx,%ebx
imul   (%r15),%ebx
mov    (%rcx),%edx
add    %esi,%edx
add    %ebx,%edx
movslq %edx,%rdx
mov    0x0(%r13,%rdx,4),%edx
mov    %edx,0x0(%rbp,%rdi,4)
mov    (%r14),%edx
add    $0x1,%rdi
cmp    %edx,%edi
jl     1210 <translate+0x100>
add    %edi,%r8d
mov    (%r9),%edi
jmp    11f0 <translate+0xe0>
test   %esi,%esi
jle    12d7 <translate+0x1c7>
mov    (%r9),%edi
xor    %ecx,%ecx
xor    %r8d,%r8d
jmp    126e <translate+0x15e>
nopw   0x0(%rax,%rax,1)
mov    0x60(%rsp),%rdx
mov    (%rdx),%esi
add    $0x1,%ecx
cmp    %esi,%ecx
jge    12d7 <translate+0x1c7>
test   %edi,%edi
jle    1267 <translate+0x157>
mov    (%r14),%ebp
xor    %esi,%esi
mov    0x58(%rsp),%r11
jmp    1287 <translate+0x177>
xchg   %ax,%ax
add    $0x1,%esi
cmp    %edi,%esi
jge    1260 <translate+0x150>
test   %ebp,%ebp
jle    1280 <translate+0x170>
movslq %r8d,%rdx
lea    (%rax,%rdx,4),%rdx
xor    %edi,%edi
mov    0x50(%rsp),%r10
nopl   0x0(%rax)
mov    (%r10),%ebp
add    %ecx,%ebp
mov    (%r12),%ebx
imul   %edi,%ebx
add    %ebp,%ebx
imul   (%r15),%ebx
mov    (%r11),%ebp
add    %esi,%ebp
add    %ebx,%ebp
mov    (%rdx,%rdi,4),%ebx
movslq %ebp,%rbp
mov    %ebx,0x0(%r13,%rbp,4)
mov    (%r14),%ebp
add    $0x1,%rdi
cmp    %ebp,%edi
jl     12a0 <translate+0x190>
add    %edi,%r8d
mov    (%r9),%edi
jmp    1280 <translate+0x170>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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