#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ loadComponent(int, unsigned char *, unsigned short);
int loadAlu(unsigned char *alu) {
  unsigned short offset = 8;
  unsigned short seglen = 0;
  seglen = alu[offset] * 256 + alu[offset + 1];
  offset = offset + 2;
  if (seglen > 0)
    if (!loadComponent(36, alu + offset, seglen))
      return (0);
  offset = offset + seglen;
  seglen = alu[offset] * 256 + alu[offset + 1];
  offset = offset + 2;
  if (seglen > 0)
    if (!loadComponent(38, alu + offset, seglen))
      return (0);
  offset = offset + seglen;
  seglen = alu[offset] * 256 + alu[offset + 1];
  offset = offset + 2;
  if (seglen > 0)
    if (!loadComponent(32, alu + offset, seglen))
      return (0);
  offset = offset + seglen;
  seglen = alu[offset] * 256 + alu[offset + 1];
  offset = offset + 2;
  if (seglen > 0)
    if (!loadComponent(34, alu + offset, seglen))
      return (0);
  offset = offset + seglen;
  seglen = alu[offset] * 256 + alu[offset + 1];
  offset = offset + 2;
  if (seglen > 0)
    if (!loadComponent(40, alu + offset, seglen))
      return (0);
  offset = offset + seglen;
  seglen = alu[offset] * 256 + alu[offset + 1];
  offset = offset + 2;
  if (seglen > 0)
    if (!loadComponent(42, alu + offset, seglen))
      return (0);
  offset = offset + seglen;
  return (1);
}


x86 assembly (clang, -O0):
<loadAlu>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x10(%rbp)
movw   $0x8,-0x12(%rbp)
movw   $0x0,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movzwl -0x12(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
mov    -0x10(%rbp),%rcx
movzwl -0x12(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    %ax,-0x14(%rbp)
movzwl -0x12(%rbp),%eax
add    $0x2,%eax
mov    %ax,-0x12(%rbp)
movzwl -0x14(%rbp),%eax
cmp    $0x0,%eax
jle    119c <loadAlu+0x8c>
mov    -0x10(%rbp),%rsi
movzwl -0x12(%rbp),%eax
cltq
add    %rax,%rsi
mov    $0x24,%edi
movzwl -0x14(%rbp),%edx
call   1030 <loadComponent@plt>
cmp    $0x0,%eax
jne    1197 <loadAlu+0x87>
movl   $0x0,-0x4(%rbp)
jmp    143b <loadAlu+0x32b>
jmp    119c <loadAlu+0x8c>
movzwl -0x12(%rbp),%eax
movzwl -0x14(%rbp),%ecx
add    %ecx,%eax
mov    %ax,-0x12(%rbp)
mov    -0x10(%rbp),%rax
movzwl -0x12(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
mov    -0x10(%rbp),%rcx
movzwl -0x12(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    %ax,-0x14(%rbp)
movzwl -0x12(%rbp),%eax
add    $0x2,%eax
mov    %ax,-0x12(%rbp)
movzwl -0x14(%rbp),%eax
cmp    $0x0,%eax
jle    121e <loadAlu+0x10e>
mov    -0x10(%rbp),%rsi
movzwl -0x12(%rbp),%eax
cltq
add    %rax,%rsi
mov    $0x26,%edi
movzwl -0x14(%rbp),%edx
call   1030 <loadComponent@plt>
cmp    $0x0,%eax
jne    1219 <loadAlu+0x109>
movl   $0x0,-0x4(%rbp)
jmp    143b <loadAlu+0x32b>
jmp    121e <loadAlu+0x10e>
movzwl -0x12(%rbp),%eax
movzwl -0x14(%rbp),%ecx
add    %ecx,%eax
mov    %ax,-0x12(%rbp)
mov    -0x10(%rbp),%rax
movzwl -0x12(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
mov    -0x10(%rbp),%rcx
movzwl -0x12(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    %ax,-0x14(%rbp)
movzwl -0x12(%rbp),%eax
add    $0x2,%eax
mov    %ax,-0x12(%rbp)
movzwl -0x14(%rbp),%eax
cmp    $0x0,%eax
jle    12a0 <loadAlu+0x190>
mov    -0x10(%rbp),%rsi
movzwl -0x12(%rbp),%eax
cltq
add    %rax,%rsi
mov    $0x20,%edi
movzwl -0x14(%rbp),%edx
call   1030 <loadComponent@plt>
cmp    $0x0,%eax
jne    129b <loadAlu+0x18b>
movl   $0x0,-0x4(%rbp)
jmp    143b <loadAlu+0x32b>
jmp    12a0 <loadAlu+0x190>
movzwl -0x12(%rbp),%eax
movzwl -0x14(%rbp),%ecx
add    %ecx,%eax
mov    %ax,-0x12(%rbp)
mov    -0x10(%rbp),%rax
movzwl -0x12(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
mov    -0x10(%rbp),%rcx
movzwl -0x12(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    %ax,-0x14(%rbp)
movzwl -0x12(%rbp),%eax
add    $0x2,%eax
mov    %ax,-0x12(%rbp)
movzwl -0x14(%rbp),%eax
cmp    $0x0,%eax
jle    1322 <loadAlu+0x212>
mov    -0x10(%rbp),%rsi
movzwl -0x12(%rbp),%eax
cltq
add    %rax,%rsi
mov    $0x22,%edi
movzwl -0x14(%rbp),%edx
call   1030 <loadComponent@plt>
cmp    $0x0,%eax
jne    131d <loadAlu+0x20d>
movl   $0x0,-0x4(%rbp)
jmp    143b <loadAlu+0x32b>
jmp    1322 <loadAlu+0x212>
movzwl -0x12(%rbp),%eax
movzwl -0x14(%rbp),%ecx
add    %ecx,%eax
mov    %ax,-0x12(%rbp)
mov    -0x10(%rbp),%rax
movzwl -0x12(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
mov    -0x10(%rbp),%rcx
movzwl -0x12(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    %ax,-0x14(%rbp)
movzwl -0x12(%rbp),%eax
add    $0x2,%eax
mov    %ax,-0x12(%rbp)
movzwl -0x14(%rbp),%eax
cmp    $0x0,%eax
jle    13a4 <loadAlu+0x294>
mov    -0x10(%rbp),%rsi
movzwl -0x12(%rbp),%eax
cltq
add    %rax,%rsi
mov    $0x28,%edi
movzwl -0x14(%rbp),%edx
call   1030 <loadComponent@plt>
cmp    $0x0,%eax
jne    139f <loadAlu+0x28f>
movl   $0x0,-0x4(%rbp)
jmp    143b <loadAlu+0x32b>
jmp    13a4 <loadAlu+0x294>
movzwl -0x12(%rbp),%eax
movzwl -0x14(%rbp),%ecx
add    %ecx,%eax
mov    %ax,-0x12(%rbp)
mov    -0x10(%rbp),%rax
movzwl -0x12(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
mov    -0x10(%rbp),%rcx
movzwl -0x12(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    %ax,-0x14(%rbp)
movzwl -0x12(%rbp),%eax
add    $0x2,%eax
mov    %ax,-0x12(%rbp)
movzwl -0x14(%rbp),%eax
cmp    $0x0,%eax
jle    1426 <loadAlu+0x316>
mov    -0x10(%rbp),%rsi
movzwl -0x12(%rbp),%eax
cltq
add    %rax,%rsi
mov    $0x2a,%edi
movzwl -0x14(%rbp),%edx
call   1030 <loadComponent@plt>
cmp    $0x0,%eax
jne    1421 <loadAlu+0x311>
movl   $0x0,-0x4(%rbp)
jmp    143b <loadAlu+0x32b>
jmp    1426 <loadAlu+0x316>
movzwl -0x12(%rbp),%eax
movzwl -0x14(%rbp),%ecx
add    %ecx,%eax
mov    %ax,-0x12(%rbp)
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<loadAlu>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rdi,%r14
movzwl 0x8(%rdi),%ebx
rol    $0x8,%bx
test   %bx,%bx
je     1141 <loadAlu+0x31>
lea    0xa(%r14),%rsi
movzwl %bx,%edx
mov    $0x24,%edi
call   1030 <loadComponent@plt>
test   %eax,%eax
je     1255 <loadAlu+0x145>
lea    0xa(%rbx),%eax
movzwl %ax,%eax
movzwl (%r14,%rax,1),%r12d
rol    $0x8,%r12w
add    $0xc,%ebx
test   %r12w,%r12w
je     1176 <loadAlu+0x66>
movzwl %bx,%esi
add    %r14,%rsi
movzwl %r12w,%edx
mov    $0x26,%edi
call   1030 <loadComponent@plt>
test   %eax,%eax
je     1255 <loadAlu+0x145>
lea    (%r12,%rbx,1),%eax
movzwl %ax,%eax
movzwl (%r14,%rax,1),%r15d
rol    $0x8,%r15w
add    %ebx,%r12d
add    $0x2,%r12d
test   %r15w,%r15w
je     11b1 <loadAlu+0xa1>
movzwl %r12w,%esi
add    %r14,%rsi
movzwl %r15w,%edx
mov    $0x20,%edi
call   1030 <loadComponent@plt>
test   %eax,%eax
je     1255 <loadAlu+0x145>
lea    (%r15,%r12,1),%eax
movzwl %ax,%eax
movzwl (%r14,%rax,1),%ebx
rol    $0x8,%bx
add    %r15d,%r12d
add    $0x2,%r12d
test   %bx,%bx
je     11e5 <loadAlu+0xd5>
movzwl %r12w,%esi
add    %r14,%rsi
movzwl %bx,%edx
mov    $0x22,%edi
call   1030 <loadComponent@plt>
test   %eax,%eax
je     1255 <loadAlu+0x145>
lea    (%rbx,%r12,1),%eax
movzwl %ax,%eax
movzwl (%r14,%rax,1),%r15d
rol    $0x8,%r15w
add    %r12d,%ebx
add    $0x2,%ebx
test   %r15w,%r15w
je     121a <loadAlu+0x10a>
movzwl %bx,%esi
add    %r14,%rsi
movzwl %r15w,%edx
mov    $0x28,%edi
call   1030 <loadComponent@plt>
test   %eax,%eax
je     1255 <loadAlu+0x145>
add    %ebx,%r15d
movzwl %r15w,%eax
movzwl (%r14,%rax,1),%eax
rol    $0x8,%ax
test   %ax,%ax
je     124e <loadAlu+0x13e>
add    $0x2,%r15d
movzwl %r15w,%ecx
add    %rcx,%r14
movzwl %ax,%edx
mov    $0x2a,%edi
mov    %r14,%rsi
call   1030 <loadComponent@plt>
test   %eax,%eax
je     1255 <loadAlu+0x145>
mov    $0x1,%eax
jmp    1257 <loadAlu+0x147>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define i32 @loadAlu(i8* %0) {
%2 = getelementptr inbounds i8, i8* %0, i64 8
%3 = load i8, i8* %2
%4 = zext i8 %3 to i16
%5 = shl nuw i16 %4, 8
%6 = getelementptr inbounds i8, i8* %0, i64 9
%7 = load i8, i8* %6
%8 = zext i8 %7 to i16
%9 = or i16 %5, %8
%10 = icmp eq i16 %9, 0
br i1 %10, label %15, label %11
11: ; preds = %1
%12 = getelementptr inbounds i8, i8* %0, i64 10
%13 = tail call i32 @loadComponent(i32 36, i8* %12, i16 zeroext %9)
%14 = icmp eq i32 %13, 0
br i1 %14, label %111, label %15
15: ; preds = %11, %1
%16 = add i16 %9, 10
%17 = zext i16 %16 to i64
%18 = getelementptr inbounds i8, i8* %0, i64 %17
%19 = load i8, i8* %18
%20 = zext i8 %19 to i16
%21 = shl nuw i16 %20, 8
%22 = add nuw nsw i64 %17, 1
%23 = getelementptr inbounds i8, i8* %0, i64 %22
%24 = load i8, i8* %23
%25 = zext i8 %24 to i16
%26 = or i16 %21, %25
%27 = add i16 %9, 12
%28 = icmp eq i16 %26, 0
br i1 %28, label %34, label %29
29: ; preds = %15
%30 = zext i16 %27 to i64
%31 = getelementptr inbounds i8, i8* %0, i64 %30
%32 = tail call i32 @loadComponent(i32 38, i8* %31, i16 zeroext %26)
%33 = icmp eq i32 %32, 0
br i1 %33, label %111, label %34
34: ; preds = %29, %15
%35 = add i16 %26, %27
%36 = zext i16 %35 to i64
%37 = getelementptr inbounds i8, i8* %0, i64 %36
%38 = load i8, i8* %37
%39 = zext i8 %38 to i16
%40 = shl nuw i16 %39, 8
%41 = add nuw nsw i64 %36, 1
%42 = getelementptr inbounds i8, i8* %0, i64 %41
%43 = load i8, i8* %42
%44 = zext i8 %43 to i16
%45 = or i16 %40, %44
%46 = add i16 %35, 2
%47 = icmp eq i16 %45, 0
br i1 %47, label %53, label %48
48: ; preds = %34
%49 = zext i16 %46 to i64
%50 = getelementptr inbounds i8, i8* %0, i64 %49
%51 = tail call i32 @loadComponent(i32 32, i8* %50, i16 zeroext %45)
%52 = icmp eq i32 %51, 0
br i1 %52, label %111, label %53
53: ; preds = %48, %34
%54 = add i16 %45, %46
%55 = zext i16 %54 to i64
%56 = getelementptr inbounds i8, i8* %0, i64 %55
%57 = load i8, i8* %56
%58 = zext i8 %57 to i16
%59 = shl nuw i16 %58, 8
%60 = add nuw nsw i64 %55, 1
%61 = getelementptr inbounds i8, i8* %0, i64 %60
%62 = load i8, i8* %61
%63 = zext i8 %62 to i16
%64 = or i16 %59, %63
%65 = add i16 %54, 2
%66 = icmp eq i16 %64, 0
br i1 %66, label %72, label %67
67: ; preds = %53
%68 = zext i16 %65 to i64
%69 = getelementptr inbounds i8, i8* %0, i64 %68
%70 = tail call i32 @loadComponent(i32 34, i8* %69, i16 zeroext %64)
%71 = icmp eq i32 %70, 0
br i1 %71, label %111, label %72
72: ; preds = %67, %53
%73 = add i16 %64, %65
%74 = zext i16 %73 to i64
%75 = getelementptr inbounds i8, i8* %0, i64 %74
%76 = load i8, i8* %75
%77 = zext i8 %76 to i16
%78 = shl nuw i16 %77, 8
%79 = add nuw nsw i64 %74, 1
%80 = getelementptr inbounds i8, i8* %0, i64 %79
%81 = load i8, i8* %80
%82 = zext i8 %81 to i16
%83 = or i16 %78, %82
%84 = add i16 %73, 2
%85 = icmp eq i16 %83, 0
br i1 %85, label %91, label %86
86: ; preds = %72
%87 = zext i16 %84 to i64
%88 = getelementptr inbounds i8, i8* %0, i64 %87
%89 = tail call i32 @loadComponent(i32 40, i8* %88, i16 zeroext %83)
%90 = icmp eq i32 %89, 0
br i1 %90, label %111, label %91
91: ; preds = %86, %72
%92 = add i16 %83, %84
%93 = zext i16 %92 to i64
%94 = getelementptr inbounds i8, i8* %0, i64 %93
%95 = load i8, i8* %94
%96 = zext i8 %95 to i16
%97 = shl nuw i16 %96, 8
%98 = add nuw nsw i64 %93, 1
%99 = getelementptr inbounds i8, i8* %0, i64 %98
%100 = load i8, i8* %99
%101 = zext i8 %100 to i16
%102 = or i16 %97, %101
%103 = icmp eq i16 %102, 0
br i1 %103, label %110, label %104
104: ; preds = %91
%105 = add i16 %92, 2
%106 = zext i16 %105 to i64
%107 = getelementptr inbounds i8, i8* %0, i64 %106
%108 = tail call i32 @loadComponent(i32 42, i8* %107, i16 zeroext %102)
%109 = icmp eq i32 %108, 0
br i1 %109, label %111, label %110
110: ; preds = %104, %91
br label %111
111: ; preds = %104, %86, %67, %48, %29, %11, %110
%112 = phi i32 [ 1, %110 ], [ 0, %11 ], [ 0, %29 ], [ 0, %48 ], [ 0, %67 ], [ 0, %86 ], [ 0, %104 ]
ret i32 %112
}