#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 unsigned char ulong;
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fread(unsigned char *, int, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ free(unsigned char *);
int /*<<< orphan*/ fwrite(unsigned char *, int, int, int /*<<< orphan*/ *);
scalar_t__ malloc(int);
int /*<<< orphan*/ memset(unsigned char *, int /*<<< orphan*/, int);
int /*<<< orphan*/ printf(char *);
void movi_write_bl1(char *fn_uboot, char *fn_bl1ah) {
  int i;
  ulong checksum = 0;
  unsigned char *ptmp1 = NULL;
  unsigned char *ptmp2 = NULL;
  unsigned char *addr = NULL;
  unsigned char *src = NULL;
  FILE *fp_uboot = NULL;
  FILE *fp_bl1ah = NULL;
  if (NULL == fn_uboot)
    fn_uboot = "../u-boot.bin";
  if (NULL == fn_bl1ah)
    fn_bl1ah = "bl1ah";
  fp_uboot = fopen(fn_uboot, "rb");
  if (NULL == fp_uboot) {
    printf("can't open uboot file for read\n");
    return;
  }
  fp_bl1ah = fopen(fn_bl1ah, "wb");
  if (NULL == fp_bl1ah) {
    printf("can't open bl1ah file for write\n");
    goto err;
  }
  src = (unsigned char *)malloc((16 * 1024));
  memset(src, 0, (16 * 1024));
  ptmp1 = src;
  addr = (unsigned char *)malloc((16 * 1024) - 16);
  memset(addr, 0, (16 * 1024) - 16);
  ptmp2 = addr;
  fread(addr, 1, (16 * 1024) - 16, fp_uboot);
  for (i = 0; i < (16 * 1024) - 16; i++) {
    src[i + 16] = *(unsigned char *)addr++;
    checksum += src[i + 16];
  }
  *(ulong *)src = 0x1f;
  *(ulong *)(src + 4) = checksum;
  src[0] ^= 0x53;
  src[1] ^= 0x35;
  src[2] ^= 0x50;
  src[3] ^= 0x43;
  src[4] ^= 0x32;
  src[5] ^= 0x31;
  src[6] ^= 0x30;
  src[7] ^= 0x20;
  src[8] ^= 0x48;
  src[9] ^= 0x45;
  src[10] ^= 0x41;
  src[11] ^= 0x44;
  src[12] ^= 0x45;
  src[13] ^= 0x52;
  src[14] ^= 0x20;
  src[15] ^= 0x20;
  for (i = 1; i < 16; i++) {
    src[i] ^= src[i - 1];
  }
  fwrite(src, 1, (16 * 1024), fp_bl1ah);
  free(ptmp1);
  free(ptmp2);
  fclose(fp_bl1ah);
err:
  fclose(fp_uboot);
}


x86 assembly (clang, -O0):
<movi_write_bl1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movb   $0x0,-0x15(%rbp)
movq   $0x0,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x40(%rbp)
movq   $0x0,-0x48(%rbp)
xor    %eax,%eax
cmp    -0x8(%rbp),%rax
jne    11db <movi_write_bl1+0x5b>
lea    0xe29(%rip),%rax
mov    %rax,-0x8(%rbp)
xor    %eax,%eax
cmp    -0x10(%rbp),%rax
jne    11f2 <movi_write_bl1+0x72>
lea    0xe20(%rip),%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xe17(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x40(%rbp)
xor    %eax,%eax
cmp    -0x40(%rbp),%rax
jne    1223 <movi_write_bl1+0xa3>
lea    0xdfe(%rip),%rdi
call   1060 <printf@plt>
jmp    147f <movi_write_bl1+0x2ff>
mov    -0x10(%rbp),%rdi
lea    0xe09(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x48(%rbp)
xor    %eax,%eax
cmp    -0x48(%rbp),%rax
jne    1254 <movi_write_bl1+0xd4>
lea    0xdf0(%rip),%rdi
call   1060 <printf@plt>
jmp    1476 <movi_write_bl1+0x2f6>
mov    $0x4000,%edi
call   1080 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
xor    %esi,%esi
mov    $0x4000,%edx
call   1070 <memset@plt>
mov    -0x38(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    $0x3ff0,%edi
call   1080 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
xor    %esi,%esi
mov    $0x3ff0,%edx
call   1070 <memset@plt>
mov    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x40(%rbp),%rcx
mov    $0x1,%esi
mov    $0x3ff0,%edx
call   1040 <fread@plt>
movl   $0x0,-0x14(%rbp)
cmpl   $0x3ff0,-0x14(%rbp)
jge    1314 <movi_write_bl1+0x194>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%dl
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x10,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x10,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
movzbl -0x15(%rbp),%eax
add    %ecx,%eax
mov    %al,-0x15(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12be <movi_write_bl1+0x13e>
mov    -0x38(%rbp),%rax
movb   $0x1f,(%rax)
mov    -0x15(%rbp),%cl
mov    -0x38(%rbp),%rax
mov    %cl,0x4(%rax)
mov    -0x38(%rbp),%rax
movzbl (%rax),%ecx
xor    $0x53,%ecx
mov    %cl,(%rax)
mov    -0x38(%rbp),%rax
movzbl 0x1(%rax),%ecx
xor    $0x35,%ecx
mov    %cl,0x1(%rax)
mov    -0x38(%rbp),%rax
movzbl 0x2(%rax),%ecx
xor    $0x50,%ecx
mov    %cl,0x2(%rax)
mov    -0x38(%rbp),%rax
movzbl 0x3(%rax),%ecx
xor    $0x43,%ecx
mov    %cl,0x3(%rax)
mov    -0x38(%rbp),%rax
movzbl 0x4(%rax),%ecx
xor    $0x32,%ecx
mov    %cl,0x4(%rax)
mov    -0x38(%rbp),%rax
movzbl 0x5(%rax),%ecx
xor    $0x31,%ecx
mov    %cl,0x5(%rax)
mov    -0x38(%rbp),%rax
movzbl 0x6(%rax),%ecx
xor    $0x30,%ecx
mov    %cl,0x6(%rax)
mov    -0x38(%rbp),%rax
movzbl 0x7(%rax),%ecx
xor    $0x20,%ecx
mov    %cl,0x7(%rax)
mov    -0x38(%rbp),%rax
movzbl 0x8(%rax),%ecx
xor    $0x48,%ecx
mov    %cl,0x8(%rax)
mov    -0x38(%rbp),%rax
movzbl 0x9(%rax),%ecx
xor    $0x45,%ecx
mov    %cl,0x9(%rax)
mov    -0x38(%rbp),%rax
movzbl 0xa(%rax),%ecx
xor    $0x41,%ecx
mov    %cl,0xa(%rax)
mov    -0x38(%rbp),%rax
movzbl 0xb(%rax),%ecx
xor    $0x44,%ecx
mov    %cl,0xb(%rax)
mov    -0x38(%rbp),%rax
movzbl 0xc(%rax),%ecx
xor    $0x45,%ecx
mov    %cl,0xc(%rax)
mov    -0x38(%rbp),%rax
movzbl 0xd(%rax),%ecx
xor    $0x52,%ecx
mov    %cl,0xd(%rax)
mov    -0x38(%rbp),%rax
movzbl 0xe(%rax),%ecx
xor    $0x20,%ecx
mov    %cl,0xe(%rax)
mov    -0x38(%rbp),%rax
movzbl 0xf(%rax),%ecx
xor    $0x20,%ecx
mov    %cl,0xf(%rax)
movl   $0x1,-0x14(%rbp)
cmpl   $0x10,-0x14(%rbp)
jge    1444 <movi_write_bl1+0x2c4>
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x38(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    140a <movi_write_bl1+0x28a>
mov    -0x38(%rbp),%rdi
mov    -0x48(%rbp),%rcx
mov    $0x1,%esi
mov    $0x4000,%edx
call   10a0 <fwrite@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1050 <fclose@plt>
mov    -0x40(%rbp),%rdi
call   1050 <fclose@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<movi_write_bl1>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rsi,%rbx
test   %rdi,%rdi
lea    0xe6b(%rip),%rax
cmove  %rax,%rdi
lea    0xe74(%rip),%rsi
call   1090 <fopen@plt>
test   %rax,%rax
je     1290 <movi_write_bl1+0x110>
mov    %rax,%r15
test   %rbx,%rbx
lea    0xe53(%rip),%rdi
cmovne %rbx,%rdi
lea    0xe51(%rip),%rsi
call   1090 <fopen@plt>
test   %rax,%rax
je     12a7 <movi_write_bl1+0x127>
mov    %rax,%r14
mov    $0x4000,%edi
call   1080 <malloc@plt>
mov    %rax,%rbx
mov    %rax,%rdi
xor    %esi,%esi
mov    $0x4000,%edx
call   1070 <memset@plt>
mov    $0x3ff0,%edi
call   1080 <malloc@plt>
mov    %rax,%r12
mov    %rax,%rdi
xor    %esi,%esi
mov    $0x3ff0,%edx
call   1070 <memset@plt>
mov    %r12,%rdi
mov    $0x1,%esi
mov    $0x3ff0,%edx
mov    %r15,%rcx
call   1050 <fread@plt>
lea    0x10(%rbx),%rax
lea    0x3ff0(%r12),%rcx
cmp    %rcx,%rax
jae    12b8 <movi_write_bl1+0x138>
mov    %rbx,%rax
add    $0x4000,%rax
cmp    %r12,%rax
jbe    12b8 <movi_write_bl1+0x138>
xor    %eax,%eax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movzbl (%r12,%rax,1),%edx
mov    %dl,0x10(%rbx,%rax,1)
add    %dl,%cl
movzbl 0x1(%r12,%rax,1),%edx
mov    %dl,0x11(%rbx,%rax,1)
add    %dl,%cl
movzbl 0x2(%r12,%rax,1),%edx
mov    %dl,0x12(%rbx,%rax,1)
add    %dl,%cl
movzbl 0x3(%r12,%rax,1),%edx
mov    %dl,0x13(%rbx,%rax,1)
add    %dl,%cl
add    $0x4,%rax
cmp    $0x3ff0,%rax
jne    1250 <movi_write_bl1+0xd0>
jmp    137a <movi_write_bl1+0x1fa>
lea    0xda3(%rip),%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
jmp    1040 <puts@plt>
lea    0xd6c(%rip),%rdi
call   1040 <puts@plt>
jmp    141f <movi_write_bl1+0x29f>
pxor   %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu (%r12,%rax,1),%xmm2
movdqu 0x10(%r12,%rax,1),%xmm3
movdqu %xmm2,0x10(%rbx,%rax,1)
movdqu %xmm3,0x20(%rbx,%rax,1)
paddb  %xmm2,%xmm0
paddb  %xmm3,%xmm1
cmp    $0x3fc0,%rax
je     1321 <movi_write_bl1+0x1a1>
movdqu 0x20(%r12,%rax,1),%xmm2
movdqu 0x30(%r12,%rax,1),%xmm3
movdqu %xmm2,0x30(%rbx,%rax,1)
movdqu %xmm3,0x40(%rbx,%rax,1)
paddb  %xmm2,%xmm0
paddb  %xmm3,%xmm1
add    $0x40,%rax
jmp    12d0 <movi_write_bl1+0x150>
paddb  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddb  %xmm1,%xmm0
pxor   %xmm1,%xmm1
psadbw %xmm1,%xmm0
punpcklbw %xmm1,%xmm0
punpcklwd %xmm1,%xmm0
punpckldq %xmm1,%xmm0
mov    0x3fe0(%r12),%rax
movq   %rax,%xmm2
mov    %rax,0x3ff0(%rbx)
mov    0x3fe8(%r12),%rax
movq   %rax,%xmm3
paddb  %xmm2,%xmm3
paddb  %xmm0,%xmm3
mov    %rax,0x3ff8(%rbx)
psadbw %xmm1,%xmm3
movd   %xmm3,%ecx
movb   $0x4c,(%rbx)
mov    0x1(%rbx),%al
xor    $0x79,%al
mov    %al,0x1(%rbx)
xor    0x2(%rbx),%al
xor    $0x50,%al
mov    %al,0x2(%rbx)
xor    0x3(%rbx),%al
xor    $0x43,%al
mov    %al,0x3(%rbx)
xor    %cl,%al
xor    $0x32,%al
mov    %al,0x4(%rbx)
xor    0x5(%rbx),%al
xor    $0x31,%al
mov    %al,0x5(%rbx)
xor    0x6(%rbx),%al
xor    $0x30,%al
mov    %al,0x6(%rbx)
xor    0x7(%rbx),%al
xor    $0x20,%al
mov    %al,0x7(%rbx)
xor    0x8(%rbx),%al
xor    $0x48,%al
mov    %al,0x8(%rbx)
xor    0x9(%rbx),%al
xor    $0x45,%al
mov    %al,0x9(%rbx)
xor    0xa(%rbx),%al
xor    $0x41,%al
mov    %al,0xa(%rbx)
xor    0xb(%rbx),%al
xor    $0x44,%al
mov    %al,0xb(%rbx)
xor    0xc(%rbx),%al
xor    $0x45,%al
mov    %al,0xc(%rbx)
xor    0xd(%rbx),%al
xor    $0x52,%al
mov    %al,0xd(%rbx)
xor    0xe(%rbx),%al
mov    %eax,%ecx
xor    $0x20,%cl
mov    %cl,0xe(%rbx)
xor    %al,0xf(%rbx)
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x4000,%edx
mov    %r14,%rcx
call   10a0 <fwrite@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1060 <fclose@plt>
mov    %r15,%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
jmp    1060 <fclose@plt>

LLVM IR (-O0):
@.str = [14 x i8] c"../u-boot.bin\00"
@.str.1 = [6 x i8] c"bl1ah\00"
@.str.2 = [3 x i8] c"rb\00"
@.str.3 = [32 x i8] c"can't open uboot file for read\0A\00"
@.str.4 = [3 x i8] c"wb\00"
@.str.5 = [33 x i8] c"can't open bl1ah file for write\0A\00"
define void @movi_write_bl1(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i8
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i8*
%11 = alloca i32*
%12 = alloca i32*
store i8* %0, i8** %3
store i8* %1, i8** %4
store i8 0, i8* %6
store i8* null, i8** %7
store i8* null, i8** %8
store i8* null, i8** %9
store i8* null, i8** %10
store i32* null, i32** %11
store i32* null, i32** %12
%13 = load i8*, i8** %3
%14 = icmp eq i8* null, %13
br i1 %14, label %15, label %16
15: ; preds = %2
store i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), i8** %3
br label %16
16: ; preds = %15, %2
%17 = load i8*, i8** %4
%18 = icmp eq i8* null, %17
br i1 %18, label %19, label %20
19: ; preds = %16
store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), i8** %4
br label %20
20: ; preds = %19, %16
%21 = load i8*, i8** %3
%22 = call i32* @fopen(i8* %21, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
store i32* %22, i32** %11
%23 = load i32*, i32** %11
%24 = icmp eq i32* null, %23
br i1 %24, label %25, label %27
25: ; preds = %20
%26 = call i32 @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.3, i64 0, i64 0))
br label %210
27: ; preds = %20
%28 = load i8*, i8** %4
%29 = call i32* @fopen(i8* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0))
store i32* %29, i32** %12
%30 = load i32*, i32** %12
%31 = icmp eq i32* null, %30
br i1 %31, label %32, label %34
32: ; preds = %27
%33 = call i32 @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.5, i64 0, i64 0))
br label %207
34: ; preds = %27
%35 = call i64 @malloc(i32 16384)
%36 = inttoptr i64 %35 to i8*
store i8* %36, i8** %10
%37 = load i8*, i8** %10
%38 = call i32 @memset(i8* %37, i32 0, i32 16384)
%39 = load i8*, i8** %10
store i8* %39, i8** %7
%40 = call i64 @malloc(i32 16368)
%41 = inttoptr i64 %40 to i8*
store i8* %41, i8** %9
%42 = load i8*, i8** %9
%43 = call i32 @memset(i8* %42, i32 0, i32 16368)
%44 = load i8*, i8** %9
store i8* %44, i8** %8
%45 = load i8*, i8** %9
%46 = load i32*, i32** %11
%47 = call i32 @fread(i8* %45, i32 1, i32 16368, i32* %46)
store i32 0, i32* %5
br label %48
48: ; preds = %71, %34
%49 = load i32, i32* %5
%50 = icmp slt i32 %49, 16368
br i1 %50, label %51, label %74
51: ; preds = %48
%52 = load i8*, i8** %9
%53 = getelementptr inbounds i8, i8* %52, i32 1
store i8* %53, i8** %9
%54 = load i8, i8* %52
%55 = load i8*, i8** %10
%56 = load i32, i32* %5
%57 = add nsw i32 %56, 16
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i8, i8* %55, i64 %58
store i8 %54, i8* %59
%60 = load i8*, i8** %10
%61 = load i32, i32* %5
%62 = add nsw i32 %61, 16
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i8, i8* %60, i64 %63
%65 = load i8, i8* %64
%66 = zext i8 %65 to i32
%67 = load i8, i8* %6
%68 = zext i8 %67 to i32
%69 = add nsw i32 %68, %66
%70 = trunc i32 %69 to i8
store i8 %70, i8* %6
br label %71
71: ; preds = %51
%72 = load i32, i32* %5
%73 = add nsw i32 %72, 1
store i32 %73, i32* %5
br label %48
74: ; preds = %48
%75 = load i8*, i8** %10
store i8 31, i8* %75
%76 = load i8, i8* %6
%77 = load i8*, i8** %10
%78 = getelementptr inbounds i8, i8* %77, i64 4
store i8 %76, i8* %78
%79 = load i8*, i8** %10
%80 = getelementptr inbounds i8, i8* %79, i64 0
%81 = load i8, i8* %80
%82 = zext i8 %81 to i32
%83 = xor i32 %82, 83
%84 = trunc i32 %83 to i8
store i8 %84, i8* %80
%85 = load i8*, i8** %10
%86 = getelementptr inbounds i8, i8* %85, i64 1
%87 = load i8, i8* %86
%88 = zext i8 %87 to i32
%89 = xor i32 %88, 53
%90 = trunc i32 %89 to i8
store i8 %90, i8* %86
%91 = load i8*, i8** %10
%92 = getelementptr inbounds i8, i8* %91, i64 2
%93 = load i8, i8* %92
%94 = zext i8 %93 to i32
%95 = xor i32 %94, 80
%96 = trunc i32 %95 to i8
store i8 %96, i8* %92
%97 = load i8*, i8** %10
%98 = getelementptr inbounds i8, i8* %97, i64 3
%99 = load i8, i8* %98
%100 = zext i8 %99 to i32
%101 = xor i32 %100, 67
%102 = trunc i32 %101 to i8
store i8 %102, i8* %98
%103 = load i8*, i8** %10
%104 = getelementptr inbounds i8, i8* %103, i64 4
%105 = load i8, i8* %104
%106 = zext i8 %105 to i32
%107 = xor i32 %106, 50
%108 = trunc i32 %107 to i8
store i8 %108, i8* %104
%109 = load i8*, i8** %10
%110 = getelementptr inbounds i8, i8* %109, i64 5
%111 = load i8, i8* %110
%112 = zext i8 %111 to i32
%113 = xor i32 %112, 49
%114 = trunc i32 %113 to i8
store i8 %114, i8* %110
%115 = load i8*, i8** %10
%116 = getelementptr inbounds i8, i8* %115, i64 6
%117 = load i8, i8* %116
%118 = zext i8 %117 to i32
%119 = xor i32 %118, 48
%120 = trunc i32 %119 to i8
store i8 %120, i8* %116
%121 = load i8*, i8** %10
%122 = getelementptr inbounds i8, i8* %121, i64 7
%123 = load i8, i8* %122
%124 = zext i8 %123 to i32
%125 = xor i32 %124, 32
%126 = trunc i32 %125 to i8
store i8 %126, i8* %122
%127 = load i8*, i8** %10
%128 = getelementptr inbounds i8, i8* %127, i64 8
%129 = load i8, i8* %128
%130 = zext i8 %129 to i32
%131 = xor i32 %130, 72
%132 = trunc i32 %131 to i8
store i8 %132, i8* %128
%133 = load i8*, i8** %10
%134 = getelementptr inbounds i8, i8* %133, i64 9
%135 = load i8, i8* %134
%136 = zext i8 %135 to i32
%137 = xor i32 %136, 69
%138 = trunc i32 %137 to i8
store i8 %138, i8* %134
%139 = load i8*, i8** %10
%140 = getelementptr inbounds i8, i8* %139, i64 10
%141 = load i8, i8* %140
%142 = zext i8 %141 to i32
%143 = xor i32 %142, 65
%144 = trunc i32 %143 to i8
store i8 %144, i8* %140
%145 = load i8*, i8** %10
%146 = getelementptr inbounds i8, i8* %145, i64 11
%147 = load i8, i8* %146
%148 = zext i8 %147 to i32
%149 = xor i32 %148, 68
%150 = trunc i32 %149 to i8
store i8 %150, i8* %146
%151 = load i8*, i8** %10
%152 = getelementptr inbounds i8, i8* %151, i64 12
%153 = load i8, i8* %152
%154 = zext i8 %153 to i32
%155 = xor i32 %154, 69
%156 = trunc i32 %155 to i8
store i8 %156, i8* %152
%157 = load i8*, i8** %10
%158 = getelementptr inbounds i8, i8* %157, i64 13
%159 = load i8, i8* %158
%160 = zext i8 %159 to i32
%161 = xor i32 %160, 82
%162 = trunc i32 %161 to i8
store i8 %162, i8* %158
%163 = load i8*, i8** %10
%164 = getelementptr inbounds i8, i8* %163, i64 14
%165 = load i8, i8* %164
%166 = zext i8 %165 to i32
%167 = xor i32 %166, 32
%168 = trunc i32 %167 to i8
store i8 %168, i8* %164
%169 = load i8*, i8** %10
%170 = getelementptr inbounds i8, i8* %169, i64 15
%171 = load i8, i8* %170
%172 = zext i8 %171 to i32
%173 = xor i32 %172, 32
%174 = trunc i32 %173 to i8
store i8 %174, i8* %170
store i32 1, i32* %5
br label %175
175: ; preds = %194, %74
%176 = load i32, i32* %5
%177 = icmp slt i32 %176, 16
br i1 %177, label %178, label %197
178: ; preds = %175
%179 = load i8*, i8** %10
%180 = load i32, i32* %5
%181 = sub nsw i32 %180, 1
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds i8, i8* %179, i64 %182
%184 = load i8, i8* %183
%185 = zext i8 %184 to i32
%186 = load i8*, i8** %10
%187 = load i32, i32* %5
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds i8, i8* %186, i64 %188
%190 = load i8, i8* %189
%191 = zext i8 %190 to i32
%192 = xor i32 %191, %185
%193 = trunc i32 %192 to i8
store i8 %193, i8* %189
br label %194
194: ; preds = %178
%195 = load i32, i32* %5
%196 = add nsw i32 %195, 1
store i32 %196, i32* %5
br label %175
197: ; preds = %175
%198 = load i8*, i8** %10
%199 = load i32*, i32** %12
%200 = call i32 @fwrite(i8* %198, i32 1, i32 16384, i32* %199)
%201 = load i8*, i8** %7
%202 = call i32 @free(i8* %201)
%203 = load i8*, i8** %8
%204 = call i32 @free(i8* %203)
%205 = load i32*, i32** %12
%206 = call i32 @fclose(i32* %205)
br label %207
207: ; preds = %197, %32
%208 = load i32*, i32** %11
%209 = call i32 @fclose(i32* %208)
br label %210
210: ; preds = %207, %25
ret void
}

LLVM IR (-O2):
@.str = [14 x i8] c"../u-boot.bin\00"
@.str.1 = [6 x i8] c"bl1ah\00"
@.str.2 = [3 x i8] c"rb\00"
@.str.4 = [3 x i8] c"wb\00"
@str = [32 x i8] c"can't open bl1ah file for write\00"
@str.6 = [31 x i8] c"can't open uboot file for read\00"
define void @movi_write_bl1(i8* %0, i8* %1) {
%3 = icmp eq i8* %0, null
%4 = select i1 %3, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), i8* %0
%5 = tail call i32* @fopen(i8* %4, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%6 = icmp eq i32* %5, null
br i1 %6, label %7, label %9
7: ; preds = %2
%8 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.6, i64 0, i64 0))
br label %172
9: ; preds = %2
%10 = icmp eq i8* %1, null
%11 = select i1 %10, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), i8* %1
%12 = tail call i32* @fopen(i8* %11, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0))
%13 = icmp eq i32* %12, null
br i1 %13, label %14, label %16
14: ; preds = %9
%15 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @str, i64 0, i64 0))
br label %170
16: ; preds = %9
%17 = tail call i64 @malloc(i32 16384)
%18 = inttoptr i64 %17 to i8*
%19 = tail call i32 @memset(i8* %18, i32 0, i32 16384)
%20 = tail call i64 @malloc(i32 16368)
%21 = inttoptr i64 %20 to i8*
%22 = tail call i32 @memset(i8* %21, i32 0, i32 16368)
%23 = tail call i32 @fread(i8* %21, i32 1, i32 16368, i32* %5)
%24 = getelementptr i8, i8* %18, i64 16
%25 = getelementptr i8, i8* %18, i64 16384
%26 = getelementptr i8, i8* %21, i64 16368
%27 = icmp ult i8* %24, %26
%28 = icmp ugt i8* %25, %21
%29 = and i1 %27, %28
br i1 %29, label %81, label %30
30: ; preds = %16, %49
%31 = phi i64 [ %63, %49 ], [ 0, %16 ]
%32 = phi <16 x i8> [ %61, %49 ], [ zeroinitializer, %16 ]
%33 = phi <16 x i8> [ %62, %49 ], [ zeroinitializer, %16 ]
%34 = getelementptr i8, i8* %21, i64 %31
%35 = bitcast i8* %34 to <16 x i8>*
%36 = load <16 x i8>, <16 x i8>* %35
%37 = getelementptr i8, i8* %34, i64 16
%38 = bitcast i8* %37 to <16 x i8>*
%39 = load <16 x i8>, <16 x i8>* %38
%40 = or i64 %31, 16
%41 = getelementptr inbounds i8, i8* %18, i64 %40
%42 = bitcast i8* %41 to <16 x i8>*
store <16 x i8> %36, <16 x i8>* %42
%43 = getelementptr inbounds i8, i8* %41, i64 16
%44 = bitcast i8* %43 to <16 x i8>*
store <16 x i8> %39, <16 x i8>* %44
%45 = add <16 x i8> %36, %32
%46 = add <16 x i8> %39, %33
%47 = or i64 %31, 32
%48 = icmp eq i64 %47, 16352
br i1 %48, label %64, label %49
49: ; preds = %30
%50 = getelementptr i8, i8* %21, i64 %47
%51 = bitcast i8* %50 to <16 x i8>*
%52 = load <16 x i8>, <16 x i8>* %51
%53 = getelementptr i8, i8* %50, i64 16
%54 = bitcast i8* %53 to <16 x i8>*
%55 = load <16 x i8>, <16 x i8>* %54
%56 = or i64 %31, 48
%57 = getelementptr inbounds i8, i8* %18, i64 %56
%58 = bitcast i8* %57 to <16 x i8>*
store <16 x i8> %52, <16 x i8>* %58
%59 = getelementptr inbounds i8, i8* %57, i64 16
%60 = bitcast i8* %59 to <16 x i8>*
store <16 x i8> %55, <16 x i8>* %60
%61 = add <16 x i8> %52, %45
%62 = add <16 x i8> %55, %46
%63 = add nuw nsw i64 %31, 64
br label %30
64: ; preds = %30
%65 = add <16 x i8> %46, %45
%66 = call i8 @llvm.vector.reduce.add.v16i8(<16 x i8> %65)
%67 = insertelement <8 x i8> <i8 poison, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 0>, i8 %66, i64 0
%68 = getelementptr i8, i8* %21, i64 16352
%69 = bitcast i8* %68 to <8 x i8>*
%70 = load <8 x i8>, <8 x i8>* %69
%71 = getelementptr inbounds i8, i8* %18, i64 16368
%72 = bitcast i8* %71 to <8 x i8>*
store <8 x i8> %70, <8 x i8>* %72
%73 = add <8 x i8> %70, %67
%74 = getelementptr i8, i8* %21, i64 16360
%75 = bitcast i8* %74 to <8 x i8>*
%76 = load <8 x i8>, <8 x i8>* %75
%77 = getelementptr inbounds i8, i8* %18, i64 16376
%78 = bitcast i8* %77 to <8 x i8>*
store <8 x i8> %76, <8 x i8>* %78
%79 = add <8 x i8> %76, %73
%80 = call i8 @llvm.vector.reduce.add.v8i8(<8 x i8> %79)
br label %107
81: ; preds = %16, %81
%82 = phi i64 [ %105, %81 ], [ 0, %16 ]
%83 = phi i8* [ %100, %81 ], [ %21, %16 ]
%84 = phi i8 [ %104, %81 ], [ 0, %16 ]
%85 = getelementptr inbounds i8, i8* %83, i64 1
%86 = load i8, i8* %83
%87 = add nuw nsw i64 %82, 16
%88 = getelementptr inbounds i8, i8* %18, i64 %87
store i8 %86, i8* %88
%89 = add i8 %86, %84
%90 = getelementptr inbounds i8, i8* %83, i64 2
%91 = load i8, i8* %85
%92 = add nuw nsw i64 %82, 17
%93 = getelementptr inbounds i8, i8* %18, i64 %92
store i8 %91, i8* %93
%94 = add i8 %91, %89
%95 = getelementptr inbounds i8, i8* %83, i64 3
%96 = load i8, i8* %90
%97 = add nuw nsw i64 %82, 18
%98 = getelementptr inbounds i8, i8* %18, i64 %97
store i8 %96, i8* %98
%99 = add i8 %96, %94
%100 = getelementptr inbounds i8, i8* %83, i64 4
%101 = load i8, i8* %95
%102 = add nuw nsw i64 %82, 19
%103 = getelementptr inbounds i8, i8* %18, i64 %102
store i8 %101, i8* %103
%104 = add i8 %101, %99
%105 = add nuw nsw i64 %82, 4
%106 = icmp eq i64 %105, 16368
br i1 %106, label %107, label %81
107: ; preds = %81, %64
%108 = phi i8 [ %80, %64 ], [ %104, %81 ]
%109 = getelementptr inbounds i8, i8* %18, i64 4
store i8 76, i8* %18
%110 = getelementptr inbounds i8, i8* %18, i64 1
%111 = load i8, i8* %110
%112 = getelementptr inbounds i8, i8* %18, i64 2
%113 = load i8, i8* %112
%114 = getelementptr inbounds i8, i8* %18, i64 3
%115 = load i8, i8* %114
%116 = getelementptr inbounds i8, i8* %18, i64 5
%117 = load i8, i8* %116
%118 = getelementptr inbounds i8, i8* %18, i64 6
%119 = load i8, i8* %118
%120 = getelementptr inbounds i8, i8* %18, i64 7
%121 = load i8, i8* %120
%122 = getelementptr inbounds i8, i8* %18, i64 8
%123 = load i8, i8* %122
%124 = getelementptr inbounds i8, i8* %18, i64 9
%125 = load i8, i8* %124
%126 = getelementptr inbounds i8, i8* %18, i64 10
%127 = load i8, i8* %126
%128 = getelementptr inbounds i8, i8* %18, i64 11
%129 = load i8, i8* %128
%130 = getelementptr inbounds i8, i8* %18, i64 12
%131 = load i8, i8* %130
%132 = getelementptr inbounds i8, i8* %18, i64 13
%133 = load i8, i8* %132
%134 = getelementptr inbounds i8, i8* %18, i64 14
%135 = load i8, i8* %134
%136 = getelementptr inbounds i8, i8* %18, i64 15
%137 = load i8, i8* %136
%138 = xor i8 %111, 121
store i8 %138, i8* %110
%139 = xor i8 %113, %138
%140 = xor i8 %139, 80
store i8 %140, i8* %112
%141 = xor i8 %115, %140
%142 = xor i8 %141, 67
store i8 %142, i8* %114
%143 = xor i8 %108, %142
%144 = xor i8 %143, 50
store i8 %144, i8* %109
%145 = xor i8 %117, %144
%146 = xor i8 %145, 49
store i8 %146, i8* %116
%147 = xor i8 %119, %146
%148 = xor i8 %147, 48
store i8 %148, i8* %118
%149 = xor i8 %121, %148
%150 = xor i8 %149, 32
store i8 %150, i8* %120
%151 = xor i8 %123, %150
%152 = xor i8 %151, 72
store i8 %152, i8* %122
%153 = xor i8 %125, %152
%154 = xor i8 %153, 69
store i8 %154, i8* %124
%155 = xor i8 %127, %154
%156 = xor i8 %155, 65
store i8 %156, i8* %126
%157 = xor i8 %129, %156
%158 = xor i8 %157, 68
store i8 %158, i8* %128
%159 = xor i8 %131, %158
%160 = xor i8 %159, 69
store i8 %160, i8* %130
%161 = xor i8 %133, %160
%162 = xor i8 %161, 82
store i8 %162, i8* %132
%163 = xor i8 %135, %162
%164 = xor i8 %163, 32
store i8 %164, i8* %134
%165 = xor i8 %137, %163
store i8 %165, i8* %136
%166 = tail call i32 @fwrite(i8* %18, i32 1, i32 16384, i32* %12)
%167 = tail call i32 @free(i8* %18)
%168 = tail call i32 @free(i8* %21)
%169 = tail call i32 @fclose(i32* %12)
br label %170
170: ; preds = %107, %14
%171 = tail call i32 @fclose(i32* %5)
br label %172
172: ; preds = %170, %7
ret void
}