#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 */
typedef int uint8_t;

/* Variables and functions */
int /*<<< orphan*/ O_RDWR;
int *calloc(unsigned long, int);
int /*<<< orphan*/ close(int);
int /*<<< orphan*/ memset(int *, int, unsigned long);
int open(char const *, int /*<<< orphan*/);
int /*<<< orphan*/ pabort(char *);
int /*<<< orphan*/ print_buffer(int *, unsigned long);
int /*<<< orphan*/ printf(char *, int, int);
int /*<<< orphan*/ psx_spi_do_msg(int, int *, int *, unsigned long);
int /*<<< orphan*/ psx_spi_setup(int);
int /*<<< orphan*/ spi_dump_stat(int);
int psx_read(const char *spi_device, unsigned long addr,
             unsigned long read_len) {
  unsigned long len = read_len + 12;
  uint8_t LSB = 0xFF & addr;
  uint8_t MSB = 0xFF & (addr >> 8);
  uint8_t *cmd = calloc(len, sizeof(uint8_t));
  uint8_t *dat = calloc(len, sizeof(uint8_t));
  cmd[0] = 0x81;
  cmd[1] = 0x52;
  cmd[2] = 0x00;
  cmd[3] = 0x00;
  cmd[4] = MSB;
  cmd[5] = LSB;
  int ret = 0;
  int fd;
  memset(dat, 0xff, len);
  fd = open(spi_device, O_RDWR);
  if (fd < 0)
    pabort("psx_get_id() can't open device");
  psx_spi_setup(fd);
  spi_dump_stat(fd);
  psx_spi_do_msg(fd, cmd, dat, len);
  close(fd);
  printf("psx_read() at 0x%lx, len %ld\n", addr, read_len);
  print_buffer(dat, len);
  uint8_t chk = MSB ^ LSB;
  int i;
  for (i = 0; i < read_len; ++i) {
    chk ^= dat[10 + i];
  }
  printf("checksum %x, returned %x\n", chk, dat[len - 2]);
  return ret;
}


x86 assembly (clang, -O0):
<psx_read>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x18(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
and    $0xff,%rax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
shr    $0x8,%rax
and    $0xff,%rax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%rdi
mov    $0x4,%esi
call   1080 <calloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rdi
mov    $0x4,%esi
call   1080 <calloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
movl   $0x81,(%rax)
mov    -0x30(%rbp),%rax
movl   $0x52,0x4(%rax)
mov    -0x30(%rbp),%rax
movl   $0x0,0x8(%rax)
mov    -0x30(%rbp),%rax
movl   $0x0,0xc(%rax)
mov    -0x28(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x24(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0x14(%rax)
movl   $0x0,-0x3c(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x20(%rbp),%rdx
mov    $0xff,%esi
call   1060 <memset@plt>
mov    -0x8(%rbp),%rdi
mov    0x2d83(%rip),%rax
mov    (%rax),%esi
call   10a0 <open@plt>
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jge    1285 <psx_read+0xe5>
lea    0xd80(%rip),%rdi
call   10b0 <pabort@plt>
mov    -0x40(%rbp),%edi
call   1090 <psx_spi_setup@plt>
mov    -0x40(%rbp),%edi
call   1030 <spi_dump_stat@plt>
mov    -0x40(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    -0x20(%rbp),%rcx
call   1040 <psx_spi_do_msg@plt>
mov    -0x40(%rbp),%edi
call   1070 <close@plt>
mov    -0x10(%rbp),%rax
mov    %eax,%esi
mov    -0x18(%rbp),%rax
mov    %eax,%edx
lea    0xd5b(%rip),%rdi
call   1050 <printf@plt>
mov    -0x38(%rbp),%rdi
mov    -0x20(%rbp),%rsi
call   10c0 <print_buffer@plt>
mov    -0x28(%rbp),%eax
xor    -0x24(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
movslq -0x48(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1318 <psx_read+0x178>
mov    -0x38(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0xa,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
xor    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    12e6 <psx_read+0x146>
mov    -0x44(%rbp),%esi
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x2,%rcx
mov    (%rax,%rcx,4),%edx
lea    0xd0c(%rip),%rdi
call   1050 <printf@plt>
mov    -0x3c(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<psx_read>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdx,%r14
mov    %rsi,%rax
mov    %rdi,0x8(%rsp)
lea    0xc(%rdx),%r15
movzbl %al,%r13d
mov    %rsi,0x10(%rsp)
movzbl %ah,%ebp
mov    %r15,%rdi
mov    $0x4,%esi
call   1080 <calloc@plt>
mov    %rax,%r12
mov    %r15,%rdi
mov    $0x4,%esi
call   1080 <calloc@plt>
mov    %rax,%rbx
movdqa 0xe0f(%rip),%xmm0
movdqu %xmm0,(%r12)
mov    %ebp,0x10(%r12)
mov    %r13d,0x4(%rsp)
mov    %r13d,0x14(%r12)
mov    %rax,%rdi
mov    $0xff,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
mov    0x2dcb(%rip),%rax
mov    (%rax),%esi
mov    0x8(%rsp),%rdi
call   10a0 <open@plt>
mov    %eax,%r13d
test   %eax,%eax
jns    123c <psx_read+0x9c>
lea    0xdd9(%rip),%rdi
call   10b0 <pabort@plt>
mov    %r13d,%edi
call   1090 <psx_spi_setup@plt>
mov    %r13d,%edi
call   1030 <spi_dump_stat@plt>
mov    %r13d,%edi
mov    %r12,%rsi
mov    %rbx,%rdx
mov    %r15,%rcx
call   1040 <psx_spi_do_msg@plt>
mov    %r13d,%edi
call   1070 <close@plt>
lea    0xdc3(%rip),%rdi
mov    0x10(%rsp),%rsi
mov    %r14d,%edx
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    %r15,%rsi
call   10c0 <print_buffer@plt>
xor    0x4(%rsp),%ebp
test   %r14,%r14
je     13ad <psx_read+0x20d>
cmp    $0x8,%r14
jae    129e <psx_read+0xfe>
xor    %eax,%eax
jmp    13a0 <psx_read+0x200>
mov    %r14,%rax
and    $0xfffffffffffffff8,%rax
movd   %ebp,%xmm0
lea    -0x8(%rax),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0x18,%rdx
jae    12cb <psx_read+0x12b>
pxor   %xmm1,%xmm1
xor    %edx,%edx
jmp    1340 <psx_read+0x1a0>
and    $0xfffffffffffffffc,%rsi
pxor   %xmm1,%xmm1
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movdqu 0x28(%rbx,%rdx,4),%xmm2
pxor   %xmm0,%xmm2
movdqu 0x38(%rbx,%rdx,4),%xmm0
pxor   %xmm1,%xmm0
movdqu 0x48(%rbx,%rdx,4),%xmm1
movdqu 0x58(%rbx,%rdx,4),%xmm3
movdqu 0x68(%rbx,%rdx,4),%xmm4
pxor   %xmm1,%xmm4
pxor   %xmm2,%xmm4
movdqu 0x78(%rbx,%rdx,4),%xmm2
pxor   %xmm3,%xmm2
pxor   %xmm0,%xmm2
movdqu 0x88(%rbx,%rdx,4),%xmm0
pxor   %xmm4,%xmm0
movdqu 0x98(%rbx,%rdx,4),%xmm1
pxor   %xmm2,%xmm1
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rsi
jne    12e0 <psx_read+0x140>
test   %rcx,%rcx
je     137c <psx_read+0x1dc>
lea    (%rbx,%rdx,4),%rdx
add    $0x38,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu -0x10(%rdx,%rsi,1),%xmm2
pxor   %xmm2,%xmm0
movdqu (%rdx,%rsi,1),%xmm2
pxor   %xmm2,%xmm1
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    1360 <psx_read+0x1c0>
pxor   %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
pxor   %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
pxor   %xmm1,%xmm0
movd   %xmm0,%ebp
cmp    %r14,%rax
je     13ad <psx_read+0x20d>
nopl   0x0(%rax,%rax,1)
xor    0x28(%rbx,%rax,4),%ebp
add    $0x1,%rax
cmp    %rax,%r14
jne    13a0 <psx_read+0x200>
mov    0x28(%rbx,%r14,4),%edx
lea    0xc94(%rip),%rdi
mov    %ebp,%esi
call   1050 <printf@plt>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@O_RDWR = global i32 0
@.str = [31 x i8] c"psx_get_id() can't open device\00"
@.str.1 = [30 x i8] c"psx_read() at 0x%lx, len %ld\0A\00"
@.str.2 = [26 x i8] c"checksum %x, returned %x\0A\00"
define i32 @psx_read(i8* %0, i64 %1, i64 %2) {
%4 = alloca i8*
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32*
%11 = alloca i32*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
store i8* %0, i8** %4
store i64 %1, i64* %5
store i64 %2, i64* %6
%16 = load i64, i64* %6
%17 = add i64 %16, 12
store i64 %17, i64* %7
%18 = load i64, i64* %5
%19 = and i64 255, %18
%20 = trunc i64 %19 to i32
store i32 %20, i32* %8
%21 = load i64, i64* %5
%22 = lshr i64 %21, 8
%23 = and i64 255, %22
%24 = trunc i64 %23 to i32
store i32 %24, i32* %9
%25 = load i64, i64* %7
%26 = call i32* @calloc(i64 %25, i32 4)
store i32* %26, i32** %10
%27 = load i64, i64* %7
%28 = call i32* @calloc(i64 %27, i32 4)
store i32* %28, i32** %11
%29 = load i32*, i32** %10
%30 = getelementptr inbounds i32, i32* %29, i64 0
store i32 129, i32* %30
%31 = load i32*, i32** %10
%32 = getelementptr inbounds i32, i32* %31, i64 1
store i32 82, i32* %32
%33 = load i32*, i32** %10
%34 = getelementptr inbounds i32, i32* %33, i64 2
store i32 0, i32* %34
%35 = load i32*, i32** %10
%36 = getelementptr inbounds i32, i32* %35, i64 3
store i32 0, i32* %36
%37 = load i32, i32* %9
%38 = load i32*, i32** %10
%39 = getelementptr inbounds i32, i32* %38, i64 4
store i32 %37, i32* %39
%40 = load i32, i32* %8
%41 = load i32*, i32** %10
%42 = getelementptr inbounds i32, i32* %41, i64 5
store i32 %40, i32* %42
store i32 0, i32* %12
%43 = load i32*, i32** %11
%44 = load i64, i64* %7
%45 = call i32 @memset(i32* %43, i32 255, i64 %44)
%46 = load i8*, i8** %4
%47 = load i32, i32* @O_RDWR
%48 = call i32 @open(i8* %46, i32 %47)
store i32 %48, i32* %13
%49 = load i32, i32* %13
%50 = icmp slt i32 %49, 0
br i1 %50, label %51, label %53
51: ; preds = %3
%52 = call i32 @pabort(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0))
br label %53
53: ; preds = %51, %3
%54 = load i32, i32* %13
%55 = call i32 @psx_spi_setup(i32 %54)
%56 = load i32, i32* %13
%57 = call i32 @spi_dump_stat(i32 %56)
%58 = load i32, i32* %13
%59 = load i32*, i32** %10
%60 = load i32*, i32** %11
%61 = load i64, i64* %7
%62 = call i32 @psx_spi_do_msg(i32 %58, i32* %59, i32* %60, i64 %61)
%63 = load i32, i32* %13
%64 = call i32 @close(i32 %63)
%65 = load i64, i64* %5
%66 = trunc i64 %65 to i32
%67 = load i64, i64* %6
%68 = trunc i64 %67 to i32
%69 = call i32 @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.1, i64 0, i64 0), i32 %66, i32 %68)
%70 = load i32*, i32** %11
%71 = load i64, i64* %7
%72 = call i32 @print_buffer(i32* %70, i64 %71)
%73 = load i32, i32* %9
%74 = load i32, i32* %8
%75 = xor i32 %73, %74
store i32 %75, i32* %14
store i32 0, i32* %15
br label %76
76: ; preds = %90, %53
%77 = load i32, i32* %15
%78 = sext i32 %77 to i64
%79 = load i64, i64* %6
%80 = icmp ult i64 %78, %79
br i1 %80, label %81, label %93
81: ; preds = %76
%82 = load i32*, i32** %11
%83 = load i32, i32* %15
%84 = add nsw i32 10, %83
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i32, i32* %82, i64 %85
%87 = load i32, i32* %86
%88 = load i32, i32* %14
%89 = xor i32 %88, %87
store i32 %89, i32* %14
br label %90
90: ; preds = %81
%91 = load i32, i32* %15
%92 = add nsw i32 %91, 1
store i32 %92, i32* %15
br label %76
93: ; preds = %76
%94 = load i32, i32* %14
%95 = load i32*, i32** %11
%96 = load i64, i64* %7
%97 = sub i64 %96, 2
%98 = getelementptr inbounds i32, i32* %95, i64 %97
%99 = load i32, i32* %98
%100 = call i32 @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0), i32 %94, i32 %99)
%101 = load i32, i32* %12
ret i32 %101
}

LLVM IR (-O2):
@O_RDWR = global i32 0
@.str = [31 x i8] c"psx_get_id() can't open device\00"
@.str.1 = [30 x i8] c"psx_read() at 0x%lx, len %ld\0A\00"
@.str.2 = [26 x i8] c"checksum %x, returned %x\0A\00"
define i32 @psx_read(i8* nocapture %0, i64 %1, i64 %2) {
%4 = add i64 %2, 12
%5 = trunc i64 %1 to i32
%6 = and i32 %5, 255
%7 = lshr i32 %5, 8
%8 = and i32 %7, 255
%9 = tail call i32* @calloc(i64 %4, i32 4)
%10 = tail call i32* @calloc(i64 %4, i32 4)
%11 = bitcast i32* %9 to <4 x i32>*
store <4 x i32> <i32 129, i32 82, i32 0, i32 0>, <4 x i32>* %11
%12 = getelementptr inbounds i32, i32* %9, i64 4
store i32 %8, i32* %12
%13 = getelementptr inbounds i32, i32* %9, i64 5
store i32 %6, i32* %13
%14 = tail call i32 @memset(i32* %10, i32 255, i64 %4)
%15 = load i32, i32* @O_RDWR
%16 = tail call i32 @open(i8* %0, i32 %15)
%17 = icmp slt i32 %16, 0
br i1 %17, label %18, label %20
18: ; preds = %3
%19 = tail call i32 @pabort(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0))
br label %20
20: ; preds = %18, %3
%21 = tail call i32 @psx_spi_setup(i32 %16)
%22 = tail call i32 @spi_dump_stat(i32 %16)
%23 = tail call i32 @psx_spi_do_msg(i32 %16, i32* %9, i32* %10, i64 %4)
%24 = tail call i32 @close(i32 %16)
%25 = trunc i64 %2 to i32
%26 = tail call i32 @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.1, i64 0, i64 0), i32 %5, i32 %25)
%27 = tail call i32 @print_buffer(i32* %10, i64 %4)
%28 = xor i32 %8, %6
%29 = icmp eq i64 %2, 0
br i1 %29, label %128, label %30
30: ; preds = %20
%31 = icmp ult i64 %2, 8
br i1 %31, label %116, label %32
32: ; preds = %30
%33 = and i64 %2, -8
%34 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %28, i64 0
%35 = add i64 %33, -8
%36 = lshr exact i64 %35, 3
%37 = add nuw nsw i64 %36, 1
%38 = and i64 %37, 3
%39 = icmp ult i64 %35, 24
br i1 %39, label %86, label %40
40: ; preds = %32
%41 = and i64 %37, 4611686018427387900
br label %42
42: ; preds = %42, %40
%43 = phi i64 [ 0, %40 ], [ %83, %42 ]
%44 = phi <4 x i32> [ %34, %40 ], [ %81, %42 ]
%45 = phi <4 x i32> [ zeroinitializer, %40 ], [ %82, %42 ]
%46 = phi i64 [ 0, %40 ], [ %84, %42 ]
%47 = or i64 %43, 10
%48 = getelementptr inbounds i32, i32* %10, i64 %47
%49 = bitcast i32* %48 to <4 x i32>*
%50 = load <4 x i32>, <4 x i32>* %49
%51 = getelementptr inbounds i32, i32* %48, i64 4
%52 = bitcast i32* %51 to <4 x i32>*
%53 = load <4 x i32>, <4 x i32>* %52
%54 = xor <4 x i32> %50, %44
%55 = xor <4 x i32> %53, %45
%56 = or i64 %43, 18
%57 = getelementptr inbounds i32, i32* %10, i64 %56
%58 = bitcast i32* %57 to <4 x i32>*
%59 = load <4 x i32>, <4 x i32>* %58
%60 = getelementptr inbounds i32, i32* %57, i64 4
%61 = bitcast i32* %60 to <4 x i32>*
%62 = load <4 x i32>, <4 x i32>* %61
%63 = xor <4 x i32> %59, %54
%64 = xor <4 x i32> %62, %55
%65 = or i64 %43, 26
%66 = getelementptr inbounds i32, i32* %10, i64 %65
%67 = bitcast i32* %66 to <4 x i32>*
%68 = load <4 x i32>, <4 x i32>* %67
%69 = getelementptr inbounds i32, i32* %66, i64 4
%70 = bitcast i32* %69 to <4 x i32>*
%71 = load <4 x i32>, <4 x i32>* %70
%72 = xor <4 x i32> %68, %63
%73 = xor <4 x i32> %71, %64
%74 = add nuw nsw i64 %43, 34
%75 = getelementptr inbounds i32, i32* %10, i64 %74
%76 = bitcast i32* %75 to <4 x i32>*
%77 = load <4 x i32>, <4 x i32>* %76
%78 = getelementptr inbounds i32, i32* %75, i64 4
%79 = bitcast i32* %78 to <4 x i32>*
%80 = load <4 x i32>, <4 x i32>* %79
%81 = xor <4 x i32> %77, %72
%82 = xor <4 x i32> %80, %73
%83 = add nuw i64 %43, 32
%84 = add i64 %46, 4
%85 = icmp eq i64 %84, %41
br i1 %85, label %86, label %42
86: ; preds = %42, %32
%87 = phi <4 x i32> [ undef, %32 ], [ %81, %42 ]
%88 = phi <4 x i32> [ undef, %32 ], [ %82, %42 ]
%89 = phi i64 [ 0, %32 ], [ %83, %42 ]
%90 = phi <4 x i32> [ %34, %32 ], [ %81, %42 ]
%91 = phi <4 x i32> [ zeroinitializer, %32 ], [ %82, %42 ]
%92 = icmp eq i64 %38, 0
br i1 %92, label %110, label %93
93: ; preds = %86, %93
%94 = phi i64 [ %107, %93 ], [ %89, %86 ]
%95 = phi <4 x i32> [ %105, %93 ], [ %90, %86 ]
%96 = phi <4 x i32> [ %106, %93 ], [ %91, %86 ]
%97 = phi i64 [ %108, %93 ], [ 0, %86 ]
%98 = add nuw nsw i64 %94, 10
%99 = getelementptr inbounds i32, i32* %10, i64 %98
%100 = bitcast i32* %99 to <4 x i32>*
%101 = load <4 x i32>, <4 x i32>* %100
%102 = getelementptr inbounds i32, i32* %99, i64 4
%103 = bitcast i32* %102 to <4 x i32>*
%104 = load <4 x i32>, <4 x i32>* %103
%105 = xor <4 x i32> %101, %95
%106 = xor <4 x i32> %104, %96
%107 = add nuw i64 %94, 8
%108 = add i64 %97, 1
%109 = icmp eq i64 %108, %38
br i1 %109, label %110, label %93
110: ; preds = %93, %86
%111 = phi <4 x i32> [ %87, %86 ], [ %105, %93 ]
%112 = phi <4 x i32> [ %88, %86 ], [ %106, %93 ]
%113 = xor <4 x i32> %112, %111
%114 = call i32 @llvm.vector.reduce.xor.v4i32(<4 x i32> %113)
%115 = icmp eq i64 %33, %2
br i1 %115, label %128, label %116
116: ; preds = %30, %110
%117 = phi i64 [ 0, %30 ], [ %33, %110 ]
%118 = phi i32 [ %28, %30 ], [ %114, %110 ]
br label %119
119: ; preds = %116, %119
%120 = phi i64 [ %126, %119 ], [ %117, %116 ]
%121 = phi i32 [ %125, %119 ], [ %118, %116 ]
%122 = add nuw nsw i64 %120, 10
%123 = getelementptr inbounds i32, i32* %10, i64 %122
%124 = load i32, i32* %123
%125 = xor i32 %124, %121
%126 = add nuw nsw i64 %120, 1
%127 = icmp eq i64 %126, %2
br i1 %127, label %128, label %119
128: ; preds = %119, %110, %20
%129 = phi i32 [ %28, %20 ], [ %114, %110 ], [ %125, %119 ]
%130 = add i64 %2, 10
%131 = getelementptr inbounds i32, i32* %10, i64 %130
%132 = load i32, i32* %131
%133 = tail call i32 @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0), i32 %129, i32 %132)
ret i32 0
}