int flash_unlock_block(volatile unsigned char *block, int block_size,
                       int blocks) {
  volatile unsigned short *ROM, *bp;
  unsigned short stat;
  int timeout = 5000000;
  unsigned short is_locked[128];
  int i;
  ROM = (unsigned short *)((
      volatile unsigned char
          *)(((unsigned)((unsigned long)block & 0xFF800000) < 0x1000)
                 ? ((unsigned)((unsigned long)block & 0xFF800000) | 0xd0000000)
                 : (unsigned)((unsigned long)block & 0xFF800000)));
  ROM[0] = 0x50;
  bp = (unsigned short *)((unsigned long)block & 0xFF800000);
  for (i = 0; i < blocks; i++) {
    if (bp == (unsigned short *)block) {
      is_locked[i] = 0;
    } else {
      *(volatile unsigned short *)((
          volatile unsigned char *)(((unsigned)(bp) < 0x1000)
                                        ? ((unsigned)(bp) | 0xd0000000)
                                        : (unsigned)(bp))) = 0x98;
      is_locked[i] = ((volatile unsigned short *)((
          volatile unsigned char *)(((unsigned)(bp) < 0x1000)
                                        ? ((unsigned)(bp) | 0xd0000000)
                                        : (unsigned)(bp))))[2];
    }
    bp += block_size / sizeof(*bp);
  }
  ((volatile unsigned char *)(((unsigned)(block) < 0x1000)
                                  ? ((unsigned)(block) | 0xd0000000)
                                  : (unsigned)(block)))[0] = 0x60;
  ((volatile unsigned char *)(((unsigned)(block) < 0x1000)
                                  ? ((unsigned)(block) | 0xd0000000)
                                  : (unsigned)(block)))[0] = 0xD0;
  timeout = 5000000;
  while (((stat = ROM[0]) & 0x80) != 0x80) {
    if (--timeout == 0)
      goto done;
  }
  bp = (unsigned short *)((unsigned long)block & 0xFF800000);
  for (i = 0; i < blocks; i++) {
    if (is_locked[i]) {
      *((volatile unsigned char *)(((unsigned)(bp) < 0x1000)
                                       ? ((unsigned)(bp) | 0xd0000000)
                                       : (unsigned)(bp))) = 0x60;
      *((volatile unsigned char *)(((unsigned)(bp) < 0x1000)
                                       ? ((unsigned)(bp) | 0xd0000000)
                                       : (unsigned)(bp))) = 0x01;
      timeout = 5000000;
      while (((stat = ROM[0]) & 0x80) != 0x80) {
        if (--timeout == 0)
          goto done;
      }
    }
    bp += block_size / sizeof(*bp);
  }
done:
  ROM[0] = 0xFF;
  return stat;
}


x86 assembly (clang, -O0):
<flash_unlock_block>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movl   $0x4c4b40,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movabs $0xff800000,%rcx
and    %rcx,%rax
cmp    $0x1000,%eax
jae    1159 <flash_unlock_block+0x59>
mov    -0x8(%rbp),%rax
movabs $0xff800000,%rcx
and    %rcx,%rax
or     $0xd0000000,%eax
mov    %eax,-0x138(%rbp)
jmp    1170 <flash_unlock_block+0x70>
mov    -0x8(%rbp),%rax
movabs $0xff800000,%rcx
and    %rcx,%rax
mov    %eax,-0x138(%rbp)
mov    -0x138(%rbp),%eax
mov    %eax,%eax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movw   $0x50,(%rax)
mov    -0x8(%rbp),%rax
movabs $0xff800000,%rcx
and    %rcx,%rax
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1284 <flash_unlock_block+0x184>
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
cmp    %rcx,%rax
jne    11da <flash_unlock_block+0xda>
movslq -0x134(%rbp),%rax
movw   $0x0,-0x130(%rbp,%rax,2)
jmp    125c <flash_unlock_block+0x15c>
mov    -0x20(%rbp),%rax
cmp    $0x1000,%eax
jae    11fd <flash_unlock_block+0xfd>
mov    -0x20(%rbp),%rax
or     $0xd0000000,%eax
mov    %eax,-0x13c(%rbp)
jmp    1207 <flash_unlock_block+0x107>
mov    -0x20(%rbp),%rax
mov    %eax,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
mov    %eax,%eax
movw   $0x98,(%rax)
mov    -0x20(%rbp),%rax
cmp    $0x1000,%eax
jae    1237 <flash_unlock_block+0x137>
mov    -0x20(%rbp),%rax
or     $0xd0000000,%eax
mov    %eax,-0x140(%rbp)
jmp    1241 <flash_unlock_block+0x141>
mov    -0x20(%rbp),%rax
mov    %eax,-0x140(%rbp)
mov    -0x140(%rbp),%eax
mov    %eax,%eax
mov    0x4(%rax),%cx
movslq -0x134(%rbp),%rax
mov    %cx,-0x130(%rbp,%rax,2)
ff
movslq -0xc(%rbp),%rax
shr    $0x1,%rax
shl    $0x1,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    11a4 <flash_unlock_block+0xa4>
mov    -0x8(%rbp),%rax
cmp    $0x1000,%eax
jae    12a7 <flash_unlock_block+0x1a7>
mov    -0x8(%rbp),%rax
or     $0xd0000000,%eax
mov    %eax,-0x144(%rbp)
jmp    12b1 <flash_unlock_block+0x1b1>
mov    -0x8(%rbp),%rax
mov    %eax,-0x144(%rbp)
mov    -0x144(%rbp),%eax
mov    %eax,%eax
movb   $0x60,(%rax)
mov    -0x8(%rbp),%rax
cmp    $0x1000,%eax
jae    12df <flash_unlock_block+0x1df>
mov    -0x8(%rbp),%rax
or     $0xd0000000,%eax
mov    %eax,-0x148(%rbp)
jmp    12e9 <flash_unlock_block+0x1e9>
mov    -0x8(%rbp),%rax
mov    %eax,-0x148(%rbp)
mov    -0x148(%rbp),%eax
mov    %eax,%eax
movb   $0xd0,(%rax)
movl   $0x4c4b40,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%ax
mov    %ax,-0x22(%rbp)
movzwl %ax,%eax
and    $0x80,%eax
cmp    $0x80,%eax
je     1335 <flash_unlock_block+0x235>
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
cmp    $0x0,%eax
jne    1330 <flash_unlock_block+0x230>
jmp    145c <flash_unlock_block+0x35c>
jmp    12fb <flash_unlock_block+0x1fb>
mov    -0x8(%rbp),%rax
movabs $0xff800000,%rcx
and    %rcx,%rax
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1457 <flash_unlock_block+0x357>
movslq -0x134(%rbp),%rax
cmpw   $0x0,-0x130(%rbp,%rax,2)
je     142f <flash_unlock_block+0x32f>
mov    -0x20(%rbp),%rax
cmp    $0x1000,%eax
jae    139c <flash_unlock_block+0x29c>
mov    -0x20(%rbp),%rax
or     $0xd0000000,%eax
mov    %eax,-0x14c(%rbp)
jmp    13a6 <flash_unlock_block+0x2a6>
mov    -0x20(%rbp),%rax
mov    %eax,-0x14c(%rbp)
mov    -0x14c(%rbp),%eax
mov    %eax,%eax
movb   $0x60,(%rax)
mov    -0x20(%rbp),%rax
cmp    $0x1000,%eax
jae    13d4 <flash_unlock_block+0x2d4>
mov    -0x20(%rbp),%rax
or     $0xd0000000,%eax
mov    %eax,-0x150(%rbp)
jmp    13de <flash_unlock_block+0x2de>
mov    -0x20(%rbp),%rax
mov    %eax,-0x150(%rbp)
mov    -0x150(%rbp),%eax
mov    %eax,%eax
movb   $0x1,(%rax)
movl   $0x4c4b40,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%ax
mov    %ax,-0x22(%rbp)
movzwl %ax,%eax
and    $0x80,%eax
cmp    $0x80,%eax
je     142a <flash_unlock_block+0x32a>
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
cmp    $0x0,%eax
jne    1425 <flash_unlock_block+0x325>
jmp    145c <flash_unlock_block+0x35c>
jmp    13f0 <flash_unlock_block+0x2f0>
jmp    142f <flash_unlock_block+0x32f>
movslq -0xc(%rbp),%rax
shr    $0x1,%rax
shl    $0x1,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    1354 <flash_unlock_block+0x254>
jmp    145c <flash_unlock_block+0x35c>
mov    -0x18(%rbp),%rax
movw   $0xff,(%rax)
movzwl -0x22(%rbp),%eax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<flash_unlock_block>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    $0xd0000000,%r9d
mov    %edi,%r11d
and    $0xff800000,%r11d
test   %r11,%r11
mov    %r11,%r13
cmove  %r9,%r13
movw   $0x50,0x0(%r13)
movslq %esi,%r10
mov    %edx,%r8d
test   %edx,%edx
jle    121b <flash_unlock_block+0x11b>
cmp    $0x1,%edx
jne    117e <flash_unlock_block+0x7e>
xor    %esi,%esi
mov    %r11,%rcx
test   $0x1,%r8b
je     121b <flash_unlock_block+0x11b>
cmp    %rdi,%rcx
je     1214 <flash_unlock_block+0x114>
mov    $0xd0000000,%eax
or     %ecx,%eax
test   $0xfffff000,%ecx
cmovne %rcx,%rax
mov    %eax,%eax
movw   $0x98,(%rax)
movzwl 0x4(%rax),%ecx
jmp    1216 <flash_unlock_block+0x116>
mov    %r10,%r15
shr    %r15
mov    %r8d,%r14d
and    $0xfffffffe,%r14d
lea    0x0(,%r15,4),%r12
add    %r15,%r15
xor    %esi,%esi
mov    %r11,%rbx
mov    %r11,%rcx
jmp    11d8 <flash_unlock_block+0xd8>
lea    (%r15,%rbx,1),%rbp
mov    $0xd0000000,%eax
or     %ebp,%eax
test   $0xfffff000,%ebp
cmovne %rbp,%rax
mov    %eax,%eax
movw   $0x98,(%rax)
movzwl 0x4(%rax),%ebp
mov    %bp,-0x7e(%rsp,%rsi,2)
add    $0x2,%rsi
add    %r12,%rcx
add    %r12,%rbx
cmp    %rsi,%r14
je     114a <flash_unlock_block+0x4a>
cmp    %rdi,%rcx
je     1200 <flash_unlock_block+0x100>
mov    $0xd0000000,%ebp
or     %ebx,%ebp
test   $0xfffff000,%ebx
cmovne %rbx,%rbp
mov    %ebp,%ebp
movw   $0x98,0x0(%rbp)
movzwl 0x4(%rbp),%ebp
jmp    1202 <flash_unlock_block+0x102>
nopl   0x0(%rax)
xor    %ebp,%ebp
mov    %bp,-0x80(%rsp,%rsi,2)
lea    (%rcx,%r15,1),%rbp
cmp    %rdi,%rbp
jne    11a0 <flash_unlock_block+0xa0>
xor    %ebp,%ebp
jmp    11c0 <flash_unlock_block+0xc0>
xor    %ecx,%ecx
mov    %cx,-0x80(%rsp,%rsi,2)
or     %edi,%r9d
test   $0xfffff000,%edi
cmovne %rdi,%r9
mov    %r9d,%eax
movb   $0x60,(%rax)
movb   $0xd0,(%rax)
mov    $0xffb3b4c0,%ecx
cs nopw 0x0(%rax,%rax,1)
movzwl 0x0(%r13),%edi
test   $0x80,%dil
jne    1281 <flash_unlock_block+0x181>
movzwl 0x0(%r13),%edi
test   $0x80,%dil
jne    1281 <flash_unlock_block+0x181>
movzwl 0x0(%r13),%edi
test   $0x80,%dil
jne    1281 <flash_unlock_block+0x181>
movzwl 0x0(%r13),%edi
test   $0x80,%dil
jne    1281 <flash_unlock_block+0x181>
movzwl 0x0(%r13),%edi
test   $0x80,%dil
jne    1281 <flash_unlock_block+0x181>
add    $0x5,%ecx
jne    1240 <flash_unlock_block+0x140>
jmp    130c <flash_unlock_block+0x20c>
test   %edx,%edx
jle    130c <flash_unlock_block+0x20c>
shr    %r10
xor    %edx,%edx
jmp    129d <flash_unlock_block+0x19d>
lea    (%r11,%r10,2),%r11
add    $0x1,%rdx
cmp    %r8,%rdx
je     130c <flash_unlock_block+0x20c>
cmpw   $0x0,-0x80(%rsp,%rdx,2)
je     1290 <flash_unlock_block+0x190>
mov    $0xd0000000,%eax
or     %r11d,%eax
test   $0xfffff000,%r11d
cmovne %r11,%rax
mov    %eax,%eax
movb   $0x60,(%rax)
movb   $0x1,(%rax)
mov    $0xffb3b4c0,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movzwl 0x0(%r13),%edi
test   $0x80,%dil
jne    1290 <flash_unlock_block+0x190>
movzwl 0x0(%r13),%edi
test   $0x80,%dil
jne    1290 <flash_unlock_block+0x190>
movzwl 0x0(%r13),%edi
test   $0x80,%dil
jne    1290 <flash_unlock_block+0x190>
movzwl 0x0(%r13),%edi
test   $0x80,%dil
jne    1290 <flash_unlock_block+0x190>
movzwl 0x0(%r13),%edi
test   $0x80,%dil
jne    1290 <flash_unlock_block+0x190>
add    $0x5,%ecx
jne    12d0 <flash_unlock_block+0x1d0>
movw   $0xff,0x0(%r13)
movzwl %di,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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