#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 /*<<< orphan*/ buf;

/* Variables and functions */
int /*<<< orphan*/ O_RDONLY;
int /*<<< orphan*/ close(int);
int /*<<< orphan*/ memset(char *, int /*<<< orphan*/, int);
int open(char const *, int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *, char, unsigned int);
scalar_t__ read(int, char *, int);
int /*<<< orphan*/ sscanf(char *, char *, unsigned int *, ...);
unsigned int strlen(char *);
int load_flash(const char *path, unsigned char *data, unsigned int *addrmin,
               unsigned int *addrmax) {
  int hfd, linenum = 0;
  char c;
  unsigned int fmin = 0xFFFF, fmax = 0x0000;
  unsigned int memsize = 0;
  if ((hfd = open(path, O_RDONLY)) == -1) {
    return (-1);
  }
  while (read(hfd, &c, 1)) {
    int i, count = 0;
    char buf[256];
    unsigned char checksum = 0;
    unsigned int hdrdata = 0, memhigh = 0, memlow = 0, record = -1, memaddr = 0,
                 memoffs = 0, uichk = 0;
    memset(buf, 0, sizeof(buf));
    if (c == ':') {
      for (i = 0; i < sizeof(buf); i++) {
        if (read(hfd, &c, 1) <= 0 || c == '\n') {
          break;
        }
        buf[i] = c;
      }
      buf[255] = '\0';
      sscanf(buf, "%2x", &hdrdata);
      if ((hdrdata * 2 + 11) != strlen(buf)) {
        printf("line length does not match byte count %i %ld\n",
               ((char)(hdrdata) >> 4) * 2 + 11, strlen(buf));
        close(hfd);
        return -1;
      }
      sscanf(&buf[2], "%2x%2x%2x%n", &memhigh, &memlow, &record, &count);
      if (count != 6) {
        return -1;
      }
      memaddr = (memhigh * 256) + memlow;
      checksum = record + hdrdata + memaddr + (memaddr >> 8);
      if (record == 0) {
        if (fmin > (memaddr + memoffs)) {
          fmin = (memaddr + memoffs);
        }
        for (i = 0; i < hdrdata; i++) {
          unsigned int d = 0;
          sscanf(&buf[8 + (i * 2)], "%2x", &d);
          data[memaddr + memoffs + i] = (unsigned char)(d & 255);
          checksum += data[memaddr + memoffs + i];
          if (fmax < (memaddr + memoffs + i)) {
            fmax = memaddr + memoffs + i;
          }
        }
      } else if (record == 1) {
        memsize = fmax - fmin + 1;
        break;
      } else if (record == 2 || record == 4) {
      }
      checksum = (256 - (checksum & 255));
      sscanf(&buf[8 + (i * 2)], "%2x%n", &uichk, &count);
      if (checksum != uichk) {
        return -1;
      }
    }
    linenum++;
  }
  if (!memsize) {
    memsize = fmax - fmin + 1;
  }
  *addrmin = fmin;
  *addrmax = fmax;
  close(hfd);
  return memsize;
}


x86 assembly (clang, -O0):
<load_flash>:
push   %rbp
mov    %rsp,%rbp
sub    $0x180,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0xffff,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x10(%rbp),%rdi
mov    0x2e36(%rip),%rax
mov    (%rax),%esi
call   1090 <open@plt>
mov    %eax,-0x2c(%rbp)
cmp    $0xffffffff,%eax
jne    11d1 <load_flash+0x61>
movl   $0xffffffff,-0x4(%rbp)
jmp    15e7 <load_flash+0x477>
jmp    11d6 <load_flash+0x66>
mov    -0x2c(%rbp),%edi
lea    -0x31(%rbp),%rsi
mov    $0x1,%edx
call   1070 <read@plt>
cmp    $0x0,%rax
je     15b1 <load_flash+0x441>
movl   $0x0,-0x48(%rbp)
movb   $0x0,-0x151(%rbp)
movl   $0x0,-0x158(%rbp)
movl   $0x0,-0x15c(%rbp)
movl   $0x0,-0x160(%rbp)
movl   $0xffffffff,-0x164(%rbp)
ff ff ff
movl   $0x0,-0x168(%rbp)
movl   $0x0,-0x16c(%rbp)
movl   $0x0,-0x170(%rbp)
lea    -0x150(%rbp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1050 <memset@plt>
movsbl -0x31(%rbp),%eax
cmp    $0x3a,%eax
jne    15a3 <load_flash+0x433>
movl   $0x0,-0x44(%rbp)
movslq -0x44(%rbp),%rax
cmp    $0x100,%rax
jae    12c5 <load_flash+0x155>
mov    -0x2c(%rbp),%edi
lea    -0x31(%rbp),%rsi
mov    $0x1,%edx
call   1070 <read@plt>
cmp    $0x0,%rax
jle    12a4 <load_flash+0x134>
movsbl -0x31(%rbp),%eax
cmp    $0xa,%eax
jne    12a9 <load_flash+0x139>
jmp    12c5 <load_flash+0x155>
mov    -0x31(%rbp),%cl
movslq -0x44(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    126c <load_flash+0xfc>
movb   $0x0,-0x51(%rbp)
lea    -0x150(%rbp),%rdi
lea    0xd29(%rip),%rsi
lea    -0x158(%rbp),%rdx
mov    $0x0,%al
call   1080 <sscanf@plt>
mov    -0x158(%rbp),%eax
shl    $0x1,%eax
add    $0xb,%eax
mov    %eax,-0x178(%rbp)
lea    -0x150(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x178(%rbp),%eax
cmp    %ecx,%eax
je     1362 <load_flash+0x1f2>
mov    -0x158(%rbp),%eax
movsbl %al,%eax
sar    $0x4,%eax
shl    $0x1,%eax
add    $0xb,%eax
mov    %al,-0x179(%rbp)
lea    -0x150(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,%edx
mov    -0x179(%rbp),%al
lea    0xcbe(%rip),%rdi
movsbl %al,%esi
call   1040 <printf@plt>
mov    -0x2c(%rbp),%edi
call   1060 <close@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    15e7 <load_flash+0x477>
lea    -0x150(%rbp),%rdi
add    $0x2,%rdi
lea    0xcbe(%rip),%rsi
lea    -0x15c(%rbp),%rdx
lea    -0x160(%rbp),%rcx
lea    -0x164(%rbp),%r8
lea    -0x48(%rbp),%r9
mov    $0x0,%al
call   1080 <sscanf@plt>
cmpl   $0x6,-0x48(%rbp)
je     13aa <load_flash+0x23a>
movl   $0xffffffff,-0x4(%rbp)
jmp    15e7 <load_flash+0x477>
mov    -0x15c(%rbp),%eax
shl    $0x8,%eax
add    -0x160(%rbp),%eax
mov    %eax,-0x168(%rbp)
mov    -0x164(%rbp),%eax
add    -0x158(%rbp),%eax
add    -0x168(%rbp),%eax
mov    -0x168(%rbp),%ecx
shr    $0x8,%ecx
add    %ecx,%eax
mov    %al,-0x151(%rbp)
cmpl   $0x0,-0x164(%rbp)
jne    14f0 <load_flash+0x380>
mov    -0x38(%rbp),%eax
mov    -0x168(%rbp),%ecx
add    -0x16c(%rbp),%ecx
cmp    %ecx,%eax
jbe    1415 <load_flash+0x2a5>
mov    -0x168(%rbp),%eax
add    -0x16c(%rbp),%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x158(%rbp),%eax
jae    14eb <load_flash+0x37b>
movl   $0x0,-0x174(%rbp)
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x8,%eax
cltq
lea    -0x150(%rbp),%rdi
add    %rax,%rdi
lea    0xbaf(%rip),%rsi
lea    -0x174(%rbp),%rdx
mov    $0x0,%al
call   1080 <sscanf@plt>
mov    -0x174(%rbp),%eax
and    $0xff,%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
mov    -0x168(%rbp),%ecx
add    -0x16c(%rbp),%ecx
add    -0x44(%rbp),%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x168(%rbp),%ecx
add    -0x16c(%rbp),%ecx
add    -0x44(%rbp),%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%ecx
movzbl -0x151(%rbp),%eax
add    %ecx,%eax
mov    %al,-0x151(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x168(%rbp),%ecx
add    -0x16c(%rbp),%ecx
add    -0x44(%rbp),%ecx
cmp    %ecx,%eax
jae    14d8 <load_flash+0x368>
mov    -0x168(%rbp),%eax
add    -0x16c(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    14dd <load_flash+0x36d>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    141c <load_flash+0x2ac>
jmp    1537 <load_flash+0x3c7>
cmpl   $0x1,-0x164(%rbp)
jne    150e <load_flash+0x39e>
mov    -0x3c(%rbp),%eax
sub    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    15b1 <load_flash+0x441>
cmpl   $0x2,-0x164(%rbp)
je     1528 <load_flash+0x3b8>
cmpl   $0x4,-0x164(%rbp)
jne    152d <load_flash+0x3bd>
jmp    152d <load_flash+0x3bd>
jmp    1532 <load_flash+0x3c2>
jmp    1537 <load_flash+0x3c7>
movzbl -0x151(%rbp),%ecx
and    $0xff,%ecx
mov    $0x100,%eax
sub    %ecx,%eax
mov    %al,-0x151(%rbp)
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x8,%eax
cltq
lea    -0x150(%rbp),%rdi
add    %rax,%rdi
lea    0xacb(%rip),%rsi
lea    -0x170(%rbp),%rdx
lea    -0x48(%rbp),%rcx
mov    $0x0,%al
call   1080 <sscanf@plt>
movzbl -0x151(%rbp),%eax
cmp    -0x170(%rbp),%eax
je     159e <load_flash+0x42e>
movl   $0xffffffff,-0x4(%rbp)
jmp    15e7 <load_flash+0x477>
jmp    15a3 <load_flash+0x433>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11d6 <load_flash+0x66>
cmpl   $0x0,-0x40(%rbp)
jne    15c7 <load_flash+0x457>
mov    -0x3c(%rbp),%eax
sub    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x3c(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x2c(%rbp),%edi
call   1060 <close@plt>
mov    -0x40(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x180,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<load_flash>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %rcx,%r14
mov    %rdx,%r15
mov    %rsi,%r12
mov    0x2e57(%rip),%rax
mov    (%rax),%esi
call   1090 <open@plt>
mov    $0xffffffff,%ebx
cmp    $0xffffffff,%eax
je     144d <load_flash+0x2dd>
mov    %eax,%ebp
mov    %r15,0x28(%rsp)
mov    %r14,0x30(%rsp)
lea    0x3(%rsp),%rsi
mov    %eax,%edi
mov    $0x1,%edx
call   1070 <read@plt>
test   %rax,%rax
je     13ed <load_flash+0x27d>
mov    %r12,0x38(%rsp)
mov    $0xffff,%r14d
lea    0x40(%rsp),%r15
lea    0x3(%rsp),%rbx
xor    %r12d,%r12d
mov    %ebp,0x20(%rsp)
jmp    124f <load_flash+0xdf>
nopw   0x0(%rax,%rax,1)
cmp    $0x1,%ecx
je     13f6 <load_flash+0x286>
neg    %bl
lea    0x8(%r13,%r13,1),%eax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xe29(%rip),%rsi
lea    0x10(%rsp),%rdx
lea    0x8(%rsp),%rcx
xor    %eax,%eax
call   1080 <sscanf@plt>
movzbl %bl,%eax
cmp    %eax,0x10(%rsp)
lea    0x40(%rsp),%r15
lea    0x3(%rsp),%rbx
jne    1448 <load_flash+0x2d8>
mov    %ebp,%edi
mov    %rbx,%rsi
mov    $0x1,%edx
call   1070 <read@plt>
test   %rax,%rax
je     13f6 <load_flash+0x286>
movl   $0x0,0x8(%rsp)
movl   $0x0,0x4(%rsp)
movl   $0x0,0x1c(%rsp)
movl   $0x0,0x18(%rsp)
movl   $0xffffffff,0x14(%rsp)
ff
movl   $0x0,0x10(%rsp)
mov    %r15,%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1050 <memset@plt>
cmpb   $0x3a,0x3(%rsp)
jne    1237 <load_flash+0xc7>
xor    %r13d,%r13d
nopl   0x0(%rax,%rax,1)
mov    %ebp,%edi
mov    %rbx,%rsi
mov    $0x1,%edx
call   1070 <read@plt>
test   %rax,%rax
jle    12d5 <load_flash+0x165>
movzbl 0x3(%rsp),%eax
cmp    $0xa,%al
je     12d5 <load_flash+0x165>
mov    %al,0x40(%rsp,%r13,1)
add    $0x1,%r13
cmp    $0x100,%r13
jne    12a0 <load_flash+0x130>
mov    $0x100,%r13d
lea    0xd24(%rip),%rsi
movb   $0x0,0x13f(%rsp)
mov    %r15,%rdi
lea    0x4(%rsp),%rdx
xor    %eax,%eax
call   1080 <sscanf@plt>
mov    0x4(%rsp),%eax
lea    (%rax,%rax,1),%ebx
add    $0xb,%ebx
mov    %r15,%rdi
call   1030 <strlen@plt>
cmp    %eax,%ebx
jne    1418 <load_flash+0x2a8>
lea    0x42(%rsp),%rdi
lea    0xd19(%rip),%rsi
lea    0x1c(%rsp),%rdx
lea    0x18(%rsp),%rcx
lea    0x14(%rsp),%r8
lea    0x8(%rsp),%r9
xor    %eax,%eax
call   1080 <sscanf@plt>
cmpl   $0x6,0x8(%rsp)
jne    1448 <load_flash+0x2d8>
mov    0x1c(%rsp),%r15d
shl    $0x8,%r15d
add    0x18(%rsp),%r15d
mov    0x14(%rsp),%ecx
mov    0x4(%rsp),%eax
mov    %r15d,%edx
shr    $0x8,%edx
lea    (%r15,%rcx,1),%ebx
add    %eax,%ebx
add    %edx,%ebx
test   %ecx,%ecx
jne    11f0 <load_flash+0x80>
cmp    %r15d,%r14d
cmova  %r15d,%r14d
test   %eax,%eax
je     13e5 <load_flash+0x275>
mov    %r14d,0x24(%rsp)
lea    0x48(%rsp),%r14
xor    %r13d,%r13d
mov    0x38(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movl   $0x0,0xc(%rsp)
mov    %r14,%rdi
lea    0xc5e(%rip),%rsi
lea    0xc(%rsp),%rdx
xor    %eax,%eax
call   1080 <sscanf@plt>
movzbl 0xc(%rsp),%eax
lea    (%r15,%r13,1),%rcx
mov    %ecx,%edx
mov    %al,0x0(%rbp,%rdx,1)
add    %al,%bl
cmp    %ecx,%r12d
cmovb  %ecx,%r12d
add    $0x1,%r13
mov    0x4(%rsp),%eax
add    $0x2,%r14
cmp    %rax,%r13
jb     1390 <load_flash+0x220>
mov    0x20(%rsp),%ebp
mov    0x24(%rsp),%r14d
jmp    11f9 <load_flash+0x89>
xor    %r13d,%r13d
jmp    11f9 <load_flash+0x89>
xor    %r12d,%r12d
mov    $0xffff,%r14d
mov    %r12d,%ebx
sub    %r14d,%ebx
add    $0x1,%ebx
mov    0x28(%rsp),%rax
mov    %r14d,(%rax)
mov    0x30(%rsp),%rax
mov    %r12d,(%rax)
mov    %ebp,%edi
call   1060 <close@plt>
jmp    144d <load_flash+0x2dd>
movsbl 0x4(%rsp),%ebx
shr    $0x3,%ebx
and    $0xfe,%bl
add    $0xb,%bl
lea    0x40(%rsp),%rdi
call   1030 <strlen@plt>
movsbl %bl,%esi
lea    0xbca(%rip),%rdi
mov    %eax,%edx
call   1040 <printf@plt>
mov    %ebp,%edi
call   1060 <close@plt>
mov    $0xffffffff,%ebx
mov    %ebx,%eax
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@O_RDONLY = global i32 0
@.str = [4 x i8] c"%2x\00"
@.str.1 = [46 x i8] c"line length does not match byte count %i %ld\0A\00"
@.str.2 = [12 x i8] c"%2x%2x%2x%n\00"
@.str.3 = [6 x i8] c"%2x%n\00"
define i32 @load_flash(i8* %0, i8* %1, i32* %2, i32* %3) {
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i32*
%9 = alloca i32*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i8
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca [256 x i8]
%19 = alloca i8
%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 i8* %0, i8** %6
store i8* %1, i8** %7
store i32* %2, i32** %8
store i32* %3, i32** %9
store i32 0, i32* %11
store i32 65535, i32* %13
store i32 0, i32* %14
store i32 0, i32* %15
%28 = load i8*, i8** %6
%29 = load i32, i32* @O_RDONLY
%30 = call i32 @open(i8* %28, i32 %29)
store i32 %30, i32* %10
%31 = icmp eq i32 %30, -1
br i1 %31, label %32, label %33
32: ; preds = %4
store i32 -1, i32* %5
br label %230
33: ; preds = %4
br label %34
34: ; preds = %211, %33
%35 = load i32, i32* %10
%36 = call i64 @read(i32 %35, i8* %12, i32 1)
%37 = icmp ne i64 %36, 0
br i1 %37, label %38, label %214
38: ; preds = %34
store i32 0, i32* %17
store i8 0, i8* %19
store i32 0, i32* %20
store i32 0, i32* %21
store i32 0, i32* %22
store i32 -1, i32* %23
store i32 0, i32* %24
store i32 0, i32* %25
store i32 0, i32* %26
%39 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 0
%40 = call i32 @memset(i8* %39, i32 0, i32 256)
%41 = load i8, i8* %12
%42 = sext i8 %41 to i32
%43 = icmp eq i32 %42, 58
br i1 %43, label %44, label %211
44: ; preds = %38
store i32 0, i32* %16
br label %45
45: ; preds = %63, %44
%46 = load i32, i32* %16
%47 = sext i32 %46 to i64
%48 = icmp ult i64 %47, 256
br i1 %48, label %49, label %66
49: ; preds = %45
%50 = load i32, i32* %10
%51 = call i64 @read(i32 %50, i8* %12, i32 1)
%52 = icmp sle i64 %51, 0
br i1 %52, label %57, label %53
53: ; preds = %49
%54 = load i8, i8* %12
%55 = sext i8 %54 to i32
%56 = icmp eq i32 %55, 10
br i1 %56, label %57, label %58
57: ; preds = %53, %49
br label %66
58: ; preds = %53
%59 = load i8, i8* %12
%60 = load i32, i32* %16
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 %61
store i8 %59, i8* %62
br label %63
63: ; preds = %58
%64 = load i32, i32* %16
%65 = add nsw i32 %64, 1
store i32 %65, i32* %16
br label %45
66: ; preds = %57, %45
%67 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 255
store i8 0, i8* %67
%68 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 0
%69 = call i32 (i8*, i8*, i32*, ...) @sscanf(i8* %68, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32* %20)
%70 = load i32, i32* %20
%71 = mul i32 %70, 2
%72 = add i32 %71, 11
%73 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 0
%74 = call i32 @strlen(i8* %73)
%75 = icmp ne i32 %72, %74
br i1 %75, label %76, label %89
76: ; preds = %66
%77 = load i32, i32* %20
%78 = trunc i32 %77 to i8
%79 = sext i8 %78 to i32
%80 = ashr i32 %79, 4
%81 = mul nsw i32 %80, 2
%82 = add nsw i32 %81, 11
%83 = trunc i32 %82 to i8
%84 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 0
%85 = call i32 @strlen(i8* %84)
%86 = call i32 @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.1, i64 0, i64 0), i8 signext %83, i32 %85)
%87 = load i32, i32* %10
%88 = call i32 @close(i32 %87)
store i32 -1, i32* %5
br label %230
89: ; preds = %66
%90 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 2
%91 = call i32 (i8*, i8*, i32*, ...) @sscanf(i8* %90, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0), i32* %21, i32* %22, i32* %23, i32* %17)
%92 = load i32, i32* %17
%93 = icmp ne i32 %92, 6
br i1 %93, label %94, label %95
94: ; preds = %89
store i32 -1, i32* %5
br label %230
95: ; preds = %89
%96 = load i32, i32* %21
%97 = mul i32 %96, 256
%98 = load i32, i32* %22
%99 = add i32 %97, %98
store i32 %99, i32* %24
%100 = load i32, i32* %23
%101 = load i32, i32* %20
%102 = add i32 %100, %101
%103 = load i32, i32* %24
%104 = add i32 %102, %103
%105 = load i32, i32* %24
%106 = lshr i32 %105, 8
%107 = add i32 %104, %106
%108 = trunc i32 %107 to i8
store i8 %108, i8* %19
%109 = load i32, i32* %23
%110 = icmp eq i32 %109, 0
br i1 %110, label %111, label %176
111: ; preds = %95
%112 = load i32, i32* %13
%113 = load i32, i32* %24
%114 = load i32, i32* %25
%115 = add i32 %113, %114
%116 = icmp ugt i32 %112, %115
br i1 %116, label %117, label %121
117: ; preds = %111
%118 = load i32, i32* %24
%119 = load i32, i32* %25
%120 = add i32 %118, %119
store i32 %120, i32* %13
br label %121
121: ; preds = %117, %111
store i32 0, i32* %16
br label %122
122: ; preds = %172, %121
%123 = load i32, i32* %16
%124 = load i32, i32* %20
%125 = icmp ult i32 %123, %124
br i1 %125, label %126, label %175
126: ; preds = %122
store i32 0, i32* %27
%127 = load i32, i32* %16
%128 = mul nsw i32 %127, 2
%129 = add nsw i32 8, %128
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 %130
%132 = call i32 (i8*, i8*, i32*, ...) @sscanf(i8* %131, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32* %27)
%133 = load i32, i32* %27
%134 = and i32 %133, 255
%135 = trunc i32 %134 to i8
%136 = load i8*, i8** %7
%137 = load i32, i32* %24
%138 = load i32, i32* %25
%139 = add i32 %137, %138
%140 = load i32, i32* %16
%141 = add i32 %139, %140
%142 = zext i32 %141 to i64
%143 = getelementptr inbounds i8, i8* %136, i64 %142
store i8 %135, i8* %143
%144 = load i8*, i8** %7
%145 = load i32, i32* %24
%146 = load i32, i32* %25
%147 = add i32 %145, %146
%148 = load i32, i32* %16
%149 = add i32 %147, %148
%150 = zext i32 %149 to i64
%151 = getelementptr inbounds i8, i8* %144, i64 %150
%152 = load i8, i8* %151
%153 = zext i8 %152 to i32
%154 = load i8, i8* %19
%155 = zext i8 %154 to i32
%156 = add nsw i32 %155, %153
%157 = trunc i32 %156 to i8
store i8 %157, i8* %19
%158 = load i32, i32* %14
%159 = load i32, i32* %24
%160 = load i32, i32* %25
%161 = add i32 %159, %160
%162 = load i32, i32* %16
%163 = add i32 %161, %162
%164 = icmp ult i32 %158, %163
br i1 %164, label %165, label %171
165: ; preds = %126
%166 = load i32, i32* %24
%167 = load i32, i32* %25
%168 = add i32 %166, %167
%169 = load i32, i32* %16
%170 = add i32 %168, %169
store i32 %170, i32* %14
br label %171
171: ; preds = %165, %126
br label %172
172: ; preds = %171
%173 = load i32, i32* %16
%174 = add nsw i32 %173, 1
store i32 %174, i32* %16
br label %122
175: ; preds = %122
br label %193
176: ; preds = %95
%177 = load i32, i32* %23
%178 = icmp eq i32 %177, 1
br i1 %178, label %179, label %184
179: ; preds = %176
%180 = load i32, i32* %14
%181 = load i32, i32* %13
%182 = sub i32 %180, %181
%183 = add i32 %182, 1
store i32 %183, i32* %15
br label %214
184: ; preds = %176
%185 = load i32, i32* %23
%186 = icmp eq i32 %185, 2
br i1 %186, label %190, label %187
187: ; preds = %184
%188 = load i32, i32* %23
%189 = icmp eq i32 %188, 4
br i1 %189, label %190, label %191
190: ; preds = %187, %184
br label %191
191: ; preds = %190, %187
br label %192
192: ; preds = %191
br label %193
193: ; preds = %192, %175
%194 = load i8, i8* %19
%195 = zext i8 %194 to i32
%196 = and i32 %195, 255
%197 = sub nsw i32 256, %196
%198 = trunc i32 %197 to i8
store i8 %198, i8* %19
%199 = load i32, i32* %16
%200 = mul nsw i32 %199, 2
%201 = add nsw i32 8, %200
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 %202
%204 = call i32 (i8*, i8*, i32*, ...) @sscanf(i8* %203, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i32* %26, i32* %17)
%205 = load i8, i8* %19
%206 = zext i8 %205 to i32
%207 = load i32, i32* %26
%208 = icmp ne i32 %206, %207
br i1 %208, label %209, label %210
209: ; preds = %193
store i32 -1, i32* %5
br label %230
210: ; preds = %193
br label %211
211: ; preds = %210, %38
%212 = load i32, i32* %11
%213 = add nsw i32 %212, 1
store i32 %213, i32* %11
br label %34
214: ; preds = %179, %34
%215 = load i32, i32* %15
%216 = icmp ne i32 %215, 0
br i1 %216, label %222, label %217
217: ; preds = %214
%218 = load i32, i32* %14
%219 = load i32, i32* %13
%220 = sub i32 %218, %219
%221 = add i32 %220, 1
store i32 %221, i32* %15
br label %222
222: ; preds = %217, %214
%223 = load i32, i32* %13
%224 = load i32*, i32** %8
store i32 %223, i32* %224
%225 = load i32, i32* %14
%226 = load i32*, i32** %9
store i32 %225, i32* %226
%227 = load i32, i32* %10
%228 = call i32 @close(i32 %227)
%229 = load i32, i32* %15
store i32 %229, i32* %5
br label %230
230: ; preds = %222, %209, %94, %76, %32
%231 = load i32, i32* %5
ret i32 %231
}

LLVM IR (-O2):
@O_RDONLY = global i32 0
@.str = [4 x i8] c"%2x\00"
@.str.1 = [46 x i8] c"line length does not match byte count %i %ld\0A\00"
@.str.2 = [12 x i8] c"%2x%2x%2x%n\00"
@.str.3 = [6 x i8] c"%2x%n\00"
define i32 @load_flash(i8* nocapture %0, i8* nocapture writeonly %1, i32* nocapture writeonly %2, i32* nocapture writeonly %3) {
%5 = alloca i8
%6 = alloca i32
%7 = alloca [256 x i8]
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = load i32, i32* @O_RDONLY
%15 = tail call i32 @open(i8* %0, i32 %14)
%16 = icmp eq i32 %15, -1
br i1 %16, label %140, label %17
17: ; preds = %4
%18 = call i64 @read(i32 %15, i8* %5, i32 1)
%19 = icmp eq i64 %18, 0
br i1 %19, label %127, label %20
20: ; preds = %17
%21 = bitcast i32* %6 to i8*
%22 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%23 = bitcast i32* %8 to i8*
%24 = bitcast i32* %9 to i8*
%25 = bitcast i32* %10 to i8*
%26 = bitcast i32* %11 to i8*
%27 = bitcast i32* %12 to i8*
%28 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 255
%29 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 2
%30 = bitcast i32* %13 to i8*
br label %31
31: ; preds = %20, %122
%32 = phi i32 [ 0, %20 ], [ %124, %122 ]
%33 = phi i32 [ 65535, %20 ], [ %123, %122 ]
store i32 0, i32* %6
store i32 0, i32* %8
store i32 0, i32* %9
store i32 0, i32* %10
store i32 -1, i32* %11
store i32 0, i32* %12
%34 = call i32 @memset(i8* %22, i32 0, i32 256)
%35 = load i8, i8* %5
%36 = icmp eq i8 %35, 58
br i1 %36, label %37, label %122
37: ; preds = %31, %44
%38 = phi i64 [ %46, %44 ], [ 0, %31 ]
%39 = call i64 @read(i32 %15, i8* %5, i32 1)
%40 = icmp slt i64 %39, 1
%41 = load i8, i8* %5
%42 = icmp eq i8 %41, 10
%43 = select i1 %40, i1 true, i1 %42
br i1 %43, label %48, label %44
44: ; preds = %37
%45 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %38
store i8 %41, i8* %45
%46 = add nuw nsw i64 %38, 1
%47 = icmp eq i64 %46, 256
br i1 %47, label %48, label %37
48: ; preds = %37, %44
%49 = phi i64 [ %38, %37 ], [ 256, %44 ]
store i8 0, i8* %28
%50 = call i32 (i8*, i8*, i32*, ...) @sscanf(i8* %22, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32* %8)
%51 = load i32, i32* %8
%52 = shl i32 %51, 1
%53 = add i32 %52, 11
%54 = call i32 @strlen(i8* %22)
%55 = icmp eq i32 %53, %54
br i1 %55, label %66, label %56
56: ; preds = %48
%57 = load i32, i32* %8
%58 = shl i32 %57, 24
%59 = ashr i32 %58, 27
%60 = trunc i32 %59 to i8
%61 = and i8 %60, -2
%62 = add i8 %61, 11
%63 = call i32 @strlen(i8* %22)
%64 = call i32 @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.1, i64 0, i64 0), i8 signext %62, i32 %63)
%65 = call i32 @close(i32 %15)
br label %121
66: ; preds = %48
%67 = call i32 (i8*, i8*, i32*, ...) @sscanf(i8* %29, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0), i32* %9, i32* %10, i32* %11, i32* %6)
%68 = load i32, i32* %6
%69 = icmp eq i32 %68, 6
br i1 %69, label %70, label %121
70: ; preds = %66
%71 = load i32, i32* %9
%72 = shl i32 %71, 8
%73 = load i32, i32* %10
%74 = add i32 %72, %73
%75 = load i32, i32* %11
%76 = load i32, i32* %8
%77 = lshr i32 %74, 8
%78 = add i32 %74, %75
%79 = add i32 %78, %76
%80 = add i32 %79, %77
%81 = trunc i32 %80 to i8
switch i32 %75, label %107 [
i32 0, label %82
i32 1, label %132
]
82: ; preds = %70
%83 = icmp ugt i32 %33, %74
%84 = select i1 %83, i32 %74, i32 %33
%85 = icmp eq i32 %76, 0
br i1 %85, label %107, label %86
86: ; preds = %82, %86
%87 = phi i64 [ %103, %86 ], [ 0, %82 ]
%88 = phi i8 [ %100, %86 ], [ %81, %82 ]
%89 = phi i32 [ %102, %86 ], [ %32, %82 ]
store i32 0, i32* %13
%90 = shl nuw nsw i64 %87, 1
%91 = add nuw nsw i64 %90, 8
%92 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %91
%93 = call i32 (i8*, i8*, i32*, ...) @sscanf(i8* %92, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32* %13)
%94 = load i32, i32* %13
%95 = trunc i32 %94 to i8
%96 = trunc i64 %87 to i32
%97 = add i32 %74, %96
%98 = zext i32 %97 to i64
%99 = getelementptr inbounds i8, i8* %1, i64 %98
store i8 %95, i8* %99
%100 = add i8 %88, %95
%101 = icmp ult i32 %89, %97
%102 = select i1 %101, i32 %97, i32 %89
%103 = add nuw nsw i64 %87, 1
%104 = load i32, i32* %8
%105 = zext i32 %104 to i64
%106 = icmp ult i64 %103, %105
br i1 %106, label %86, label %107
107: ; preds = %86, %82, %70
%108 = phi i32 [ %33, %70 ], [ %84, %82 ], [ %84, %86 ]
%109 = phi i32 [ %32, %70 ], [ %32, %82 ], [ %102, %86 ]
%110 = phi i64 [ %49, %70 ], [ 0, %82 ], [ %103, %86 ]
%111 = phi i8 [ %81, %70 ], [ %81, %82 ], [ %100, %86 ]
%112 = sub i8 0, %111
%113 = shl i64 %110, 1
%114 = add i64 %113, 8
%115 = and i64 %114, 4294967294
%116 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %115
%117 = call i32 (i8*, i8*, i32*, ...) @sscanf(i8* %116, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i32* %12, i32* %6)
%118 = zext i8 %112 to i32
%119 = load i32, i32* %12
%120 = icmp eq i32 %119, %118
br i1 %120, label %122, label %121
121: ; preds = %66, %107, %56
br label %140
122: ; preds = %31, %107
%123 = phi i32 [ %108, %107 ], [ %33, %31 ]
%124 = phi i32 [ %109, %107 ], [ %32, %31 ]
%125 = call i64 @read(i32 %15, i8* %5, i32 1)
%126 = icmp eq i64 %125, 0
br i1 %126, label %127, label %31
127: ; preds = %122, %17
%128 = phi i32 [ 65535, %17 ], [ %123, %122 ]
%129 = phi i32 [ 0, %17 ], [ %124, %122 ]
%130 = sub i32 1, %128
%131 = add i32 %130, %129
br label %135
132: ; preds = %70
%133 = sub i32 1, %33
%134 = add i32 %133, %32
br label %135
135: ; preds = %132, %127
%136 = phi i32 [ %129, %127 ], [ %32, %132 ]
%137 = phi i32 [ %128, %127 ], [ %33, %132 ]
%138 = phi i32 [ %131, %127 ], [ %134, %132 ]
store i32 %137, i32* %2
store i32 %136, i32* %3
%139 = call i32 @close(i32 %15)
br label %140
140: ; preds = %121, %4, %135
%141 = phi i32 [ %138, %135 ], [ -1, %4 ], [ -1, %121 ]
ret i32 %141
}