#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 u_long;

/* Variables and functions */
scalar_t__ isdigit(char);
scalar_t__ islower(char);
int /*<<< orphan*/ isspace(char);
scalar_t__ isxdigit(char);
u_long inet_network(register char *cp) {
  register u_long val, base, n;
  register char c;
  u_long parts[4], *pp = parts;
  register int i;
again:
  val = 0;
  base = 10;
  if (*cp == '0')
    base = 8, cp++;
  if (*cp == 'x' || *cp == 'X')
    base = 16, cp++;
  while ((c = *cp) != '\0') {
    if (isdigit(c)) {
      val = (val * base) + ((u_long)c - '0');
      cp++;
      continue;
    }
    if (base == 16 && isxdigit(c)) {
      val = (val << 4) + ((u_long)c + 10 - (islower(c) ? 'a' : 'A'));
      cp++;
      continue;
    }
    break;
  }
  if (*cp == '.') {
    if (pp >= parts + 4)
      return (-1);
    *pp++ = val, cp++;
    goto again;
  }
  if (*cp && !isspace(*cp))
    return (-1);
  *pp++ = val;
  n = pp - parts;
  if (n > 4)
    return (-1);
  for (val = 0, i = 0; i < n; i++) {
    val <<= 8;
    val |= parts[i] & 0xff;
  }
  return (val);
}


x86 assembly (clang, -O0):
<inet_network>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
lea    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0xa,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jne    1185 <inet_network+0x45>
movl   $0x8,-0x18(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x78,%eax
je     11a5 <inet_network+0x65>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x58,%eax
jne    11b8 <inet_network+0x78>
movl   $0x10,-0x18(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    11bd <inet_network+0x7d>
mov    -0x10(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x1d(%rbp)
movsbl %al,%eax
cmp    $0x0,%eax
je     1279 <inet_network+0x139>
movsbl -0x1d(%rbp),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     1209 <inet_network+0xc9>
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
movsbl -0x1d(%rbp),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    11bd <inet_network+0x7d>
cmpl   $0x10,-0x18(%rbp)
jne    1274 <inet_network+0x134>
movsbl -0x1d(%rbp),%edi
call   1060 <isxdigit@plt>
cmp    $0x0,%rax
je     1274 <inet_network+0x134>
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
mov    %eax,-0x40(%rbp)
movsbl -0x1d(%rbp),%eax
add    $0xa,%eax
mov    %eax,-0x44(%rbp)
movsbl -0x1d(%rbp),%edi
call   1040 <islower@plt>
mov    -0x44(%rbp),%ecx
mov    %rax,%rdi
mov    -0x40(%rbp),%eax
mov    $0x41,%edx
mov    $0x61,%esi
cmp    $0x0,%rdi
cmovne %esi,%edx
sub    %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    11bd <inet_network+0x7d>
jmp    1279 <inet_network+0x139>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    12cf <inet_network+0x18f>
mov    -0x38(%rbp),%rax
lea    -0x30(%rbp),%rcx
add    $0x10,%rcx
cmp    %rcx,%rax
jb     12aa <inet_network+0x16a>
movl   $0xffffffff,-0x4(%rbp)
jmp    1386 <inet_network+0x246>
mov    -0x14(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x38(%rbp)
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1154 <inet_network+0x14>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1300 <inet_network+0x1c0>
mov    -0x10(%rbp),%rax
movsbl (%rax),%edi
call   1050 <isspace@plt>
cmp    $0x0,%eax
jne    1300 <inet_network+0x1c0>
movl   $0xffffffff,-0x4(%rbp)
jmp    1386 <inet_network+0x246>
mov    -0x14(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x38(%rbp)
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
lea    -0x30(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,-0x1c(%rbp)
cmpl   $0x4,-0x1c(%rbp)
jle    133c <inet_network+0x1fc>
movl   $0xffffffff,-0x4(%rbp)
jmp    1386 <inet_network+0x246>
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1380 <inet_network+0x240>
mov    -0x14(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x14(%rbp)
movslq -0x3c(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
and    $0xff,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    134a <inet_network+0x20a>
mov    -0x14(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<inet_network>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdi,%r14
mov    %rsp,%r12
mov    $0x1,%r15d
xor    %eax,%eax
xor    %edx,%edx
cmpb   $0x30,(%r14)
sete   %al
setne  %sil
lea    (%r14,%rax,1),%rcx
mov    (%r14,%rax,1),%bl
mov    %ebx,%eax
or     $0x20,%al
cmp    $0x78,%al
jne    1190 <inet_network+0x50>
mov    0x1(%rcx),%bl
add    $0x1,%rcx
mov    $0x10,%r13d
test   %bl,%bl
jne    11a3 <inet_network+0x63>
jmp    1237 <inet_network+0xf7>
nop
mov    %sil,%dl
lea    (%rdx,%rdx,1),%r13d
add    $0x8,%r13d
test   %bl,%bl
je     1237 <inet_network+0xf7>
add    $0x1,%rcx
xor    %ebp,%ebp
mov    %rcx,%r14
jmp    11c9 <inet_network+0x89>
xchg   %ax,%ax
imul   %r13d,%ebp
add    %ebx,%ebp
add    $0xffffffd0,%ebp
movzbl (%r14),%ebx
add    $0x1,%r14
test   %bl,%bl
je     124f <inet_network+0x10f>
movsbl %bl,%ebx
mov    %ebx,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
jne    11b0 <inet_network+0x70>
cmp    $0x10,%r13d
jne    1210 <inet_network+0xd0>
mov    %ebx,%edi
call   1060 <isxdigit@plt>
test   %rax,%rax
je     1210 <inet_network+0xd0>
shl    $0x4,%ebp
mov    %ebx,%edi
call   1040 <islower@plt>
xor    %ecx,%ecx
test   %rax,%rax
sete   %cl
shl    $0x5,%ecx
add    %ebx,%ebp
add    %ecx,%ebp
add    $0xffffffa9,%ebp
jmp    11b9 <inet_network+0x79>
nopl   0x0(%rax,%rax,1)
mov    -0x1(%r14),%al
cmp    $0x2e,%al
jne    123b <inet_network+0xfb>
lea    0x10(%rsp),%rax
cmp    %rax,%r12
jae    1301 <inet_network+0x1c1>
mov    %ebp,(%r12)
add    $0x4,%r12
add    $0x1,%r15
jmp    115a <inet_network+0x1a>
xor    %ebp,%ebp
jmp    124f <inet_network+0x10f>
test   %al,%al
je     124f <inet_network+0x10f>
movsbl %al,%edi
call   1050 <isspace@plt>
test   %eax,%eax
je     1301 <inet_network+0x1c1>
mov    %ebp,(%r12)
mov    %rsp,%rax
neg    %rax
lea    (%r12,%rax,1),%rdx
add    $0x4,%rdx
shr    $0x2,%rdx
mov    $0xffffffff,%eax
cmp    $0x4,%edx
jg     12f2 <inet_network+0x1b2>
test   %edx,%edx
jle    1292 <inet_network+0x152>
mov    %edx,%eax
add    $0xffffffffffffffff,%rax
movzbl %r15b,%ecx
cmp    $0x3,%rax
jae    1296 <inet_network+0x156>
xor    %esi,%esi
xor    %eax,%eax
test   $0x3,%dl
jne    12d5 <inet_network+0x195>
jmp    12f2 <inet_network+0x1b2>
xor    %eax,%eax
jmp    12f2 <inet_network+0x1b2>
mov    %ecx,%eax
and    $0x3,%eax
sub    %rax,%r15
xor    %esi,%esi
add    $0x4,%rsi
cmp    %rsi,%r15
jne    12a0 <inet_network+0x160>
mov    -0x10(%rsp,%rsi,4),%eax
mov    -0xc(%rsp,%rsi,4),%edi
mov    -0x8(%rsp,%rsi,4),%ebp
shl    $0x18,%eax
movzbl %dil,%edi
shl    $0x10,%edi
or     %eax,%edi
shl    $0x8,%ebp
movzwl %bp,%ebp
or     %edi,%ebp
movzbl -0x4(%rsp,%rsi,4),%eax
or     %ebp,%eax
test   $0x3,%dl
je     12f2 <inet_network+0x1b2>
lea    (%rsp,%rsi,4),%rdx
and    $0x3,%ecx
xor    %esi,%esi
xchg   %ax,%ax
shl    $0x8,%eax
movzbl (%rdx,%rsi,4),%edi
or     %edi,%eax
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    12e0 <inet_network+0x1a0>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0xffffffff,%eax
jmp    12f2 <inet_network+0x1b2>

LLVM IR (-O0):
define i32 @inet_network(i8* %0) {
%2 = alloca i32
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i8
%8 = alloca [4 x i32]
%9 = alloca i32*
%10 = alloca i32
store i8* %0, i8** %3
%11 = getelementptr inbounds [4 x i32], [4 x i32]* %8, i64 0, i64 0
store i32* %11, i32** %9
br label %12
12: ; preds = %87, %1
store i32 0, i32* %4
store i32 10, i32* %5
%13 = load i8*, i8** %3
%14 = load i8, i8* %13
%15 = sext i8 %14 to i32
%16 = icmp eq i32 %15, 48
br i1 %16, label %17, label %20
17: ; preds = %12
store i32 8, i32* %5
%18 = load i8*, i8** %3
%19 = getelementptr inbounds i8, i8* %18, i32 1
store i8* %19, i8** %3
br label %20
20: ; preds = %17, %12
%21 = load i8*, i8** %3
%22 = load i8, i8* %21
%23 = sext i8 %22 to i32
%24 = icmp eq i32 %23, 120
br i1 %24, label %30, label %25
25: ; preds = %20
%26 = load i8*, i8** %3
%27 = load i8, i8* %26
%28 = sext i8 %27 to i32
%29 = icmp eq i32 %28, 88
br i1 %29, label %30, label %33
30: ; preds = %25, %20
store i32 16, i32* %5
%31 = load i8*, i8** %3
%32 = getelementptr inbounds i8, i8* %31, i32 1
store i8* %32, i8** %3
br label %33
33: ; preds = %30, %25
br label %34
34: ; preds = %60, %43, %33
%35 = load i8*, i8** %3
%36 = load i8, i8* %35
store i8 %36, i8* %7
%37 = sext i8 %36 to i32
%38 = icmp ne i32 %37, 0
br i1 %38, label %39, label %76
39: ; preds = %34
%40 = load i8, i8* %7
%41 = call i64 @isdigit(i8 signext %40)
%42 = icmp ne i64 %41, 0
br i1 %42, label %43, label %53
43: ; preds = %39
%44 = load i32, i32* %4
%45 = load i32, i32* %5
%46 = mul nsw i32 %44, %45
%47 = load i8, i8* %7
%48 = sext i8 %47 to i32
%49 = sub nsw i32 %48, 48
%50 = add nsw i32 %46, %49
store i32 %50, i32* %4
%51 = load i8*, i8** %3
%52 = getelementptr inbounds i8, i8* %51, i32 1
store i8* %52, i8** %3
br label %34
53: ; preds = %39
%54 = load i32, i32* %5
%55 = icmp eq i32 %54, 16
br i1 %55, label %56, label %75
56: ; preds = %53
%57 = load i8, i8* %7
%58 = call i64 @isxdigit(i8 signext %57)
%59 = icmp ne i64 %58, 0
br i1 %59, label %60, label %75
60: ; preds = %56
%61 = load i32, i32* %4
%62 = shl i32 %61, 4
%63 = load i8, i8* %7
%64 = sext i8 %63 to i32
%65 = add nsw i32 %64, 10
%66 = load i8, i8* %7
%67 = call i64 @islower(i8 signext %66)
%68 = icmp ne i64 %67, 0
%69 = zext i1 %68 to i64
%70 = select i1 %68, i32 97, i32 65
%71 = sub nsw i32 %65, %70
%72 = add nsw i32 %62, %71
store i32 %72, i32* %4
%73 = load i8*, i8** %3
%74 = getelementptr inbounds i8, i8* %73, i32 1
store i8* %74, i8** %3
br label %34
75: ; preds = %56, %53
br label %76
76: ; preds = %75, %34
%77 = load i8*, i8** %3
%78 = load i8, i8* %77
%79 = sext i8 %78 to i32
%80 = icmp eq i32 %79, 46
br i1 %80, label %81, label %93
81: ; preds = %76
%82 = load i32*, i32** %9
%83 = getelementptr inbounds [4 x i32], [4 x i32]* %8, i64 0, i64 0
%84 = getelementptr inbounds i32, i32* %83, i64 4
%85 = icmp uge i32* %82, %84
br i1 %85, label %86, label %87
86: ; preds = %81
store i32 -1, i32* %2
br label %138
87: ; preds = %81
%88 = load i32, i32* %4
%89 = load i32*, i32** %9
%90 = getelementptr inbounds i32, i32* %89, i32 1
store i32* %90, i32** %9
store i32 %88, i32* %89
%91 = load i8*, i8** %3
%92 = getelementptr inbounds i8, i8* %91, i32 1
store i8* %92, i8** %3
br label %12
93: ; preds = %76
%94 = load i8*, i8** %3
%95 = load i8, i8* %94
%96 = sext i8 %95 to i32
%97 = icmp ne i32 %96, 0
br i1 %97, label %98, label %104
98: ; preds = %93
%99 = load i8*, i8** %3
%100 = load i8, i8* %99
%101 = call i32 @isspace(i8 signext %100)
%102 = icmp ne i32 %101, 0
br i1 %102, label %104, label %103
103: ; preds = %98
store i32 -1, i32* %2
br label %138
104: ; preds = %98, %93
%105 = load i32, i32* %4
%106 = load i32*, i32** %9
%107 = getelementptr inbounds i32, i32* %106, i32 1
store i32* %107, i32** %9
store i32 %105, i32* %106
%108 = load i32*, i32** %9
%109 = getelementptr inbounds [4 x i32], [4 x i32]* %8, i64 0, i64 0
%110 = ptrtoint i32* %108 to i64
%111 = ptrtoint i32* %109 to i64
%112 = sub i64 %110, %111
%113 = sdiv exact i64 %112, 4
%114 = trunc i64 %113 to i32
store i32 %114, i32* %6
%115 = load i32, i32* %6
%116 = icmp sgt i32 %115, 4
br i1 %116, label %117, label %118
117: ; preds = %104
store i32 -1, i32* %2
br label %138
118: ; preds = %104
store i32 0, i32* %4
store i32 0, i32* %10
br label %119
119: ; preds = %133, %118
%120 = load i32, i32* %10
%121 = load i32, i32* %6
%122 = icmp slt i32 %120, %121
br i1 %122, label %123, label %136
123: ; preds = %119
%124 = load i32, i32* %4
%125 = shl i32 %124, 8
store i32 %125, i32* %4
%126 = load i32, i32* %10
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [4 x i32], [4 x i32]* %8, i64 0, i64 %127
%129 = load i32, i32* %128
%130 = and i32 %129, 255
%131 = load i32, i32* %4
%132 = or i32 %131, %130
store i32 %132, i32* %4
br label %133
133: ; preds = %123
%134 = load i32, i32* %10
%135 = add nsw i32 %134, 1
store i32 %135, i32* %10
br label %119
136: ; preds = %119
%137 = load i32, i32* %4
store i32 %137, i32* %2
br label %138
138: ; preds = %136, %117, %103, %86
%139 = load i32, i32* %2
ret i32 %139
}

LLVM IR (-O2):
define i32 @inet_network(i8* nocapture %0) {
%2 = alloca [4 x i32]
%3 = bitcast [4 x i32]* %2 to i8*
%4 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 0, i64 0
%5 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 0, i64 4
br label %6
6: ; preds = %57, %1
%7 = phi i8* [ %0, %1 ], [ %59, %57 ]
%8 = phi i32* [ %4, %1 ], [ %58, %57 ]
%9 = load i8, i8* %7
%10 = icmp eq i8 %9, 48
%11 = select i1 %10, i32 8, i32 10
%12 = zext i1 %10 to i64
%13 = getelementptr i8, i8* %7, i64 %12
%14 = load i8, i8* %13
switch i8 %14, label %18 [
i8 120, label %15
i8 88, label %15
]
15: ; preds = %6, %6
%16 = getelementptr inbounds i8, i8* %13, i64 1
%17 = load i8, i8* %16
br label %18
18: ; preds = %6, %15
%19 = phi i8 [ %17, %15 ], [ %14, %6 ]
%20 = phi i32 [ 16, %15 ], [ %11, %6 ]
%21 = phi i8* [ %16, %15 ], [ %13, %6 ]
%22 = icmp eq i8 %19, 0
br i1 %22, label %63, label %23
23: ; preds = %18
%24 = icmp eq i32 %20, 16
br label %25
25: ; preds = %23, %36
%26 = phi i8 [ %19, %23 ], [ %39, %36 ]
%27 = phi i8* [ %21, %23 ], [ %38, %36 ]
%28 = phi i32 [ 0, %23 ], [ %37, %36 ]
%29 = sext i8 %26 to i32
%30 = call i64 @isdigit(i8 signext %26)
%31 = icmp eq i64 %30, 0
br i1 %31, label %41, label %32
32: ; preds = %25
%33 = mul nsw i32 %28, %20
%34 = add i32 %33, -48
%35 = add i32 %34, %29
br label %36
36: ; preds = %32, %45
%37 = phi i32 [ %35, %32 ], [ %52, %45 ]
%38 = getelementptr inbounds i8, i8* %27, i64 1
%39 = load i8, i8* %38
%40 = icmp eq i8 %39, 0
br i1 %40, label %63, label %25
41: ; preds = %25
br i1 %24, label %42, label %53
42: ; preds = %41
%43 = call i64 @isxdigit(i8 signext %26)
%44 = icmp eq i64 %43, 0
br i1 %44, label %53, label %45
45: ; preds = %42
%46 = shl i32 %28, 4
%47 = call i64 @islower(i8 signext %26)
%48 = icmp eq i64 %47, 0
%49 = select i1 %48, i32 -65, i32 -97
%50 = or i32 %46, 10
%51 = add i32 %50, %29
%52 = add i32 %51, %49
br label %36
53: ; preds = %41, %42
%54 = load i8, i8* %27
switch i8 %54, label %60 [
i8 46, label %55
i8 0, label %63
]
55: ; preds = %53
%56 = icmp ult i32* %8, %5
br i1 %56, label %57, label %125
57: ; preds = %55
%58 = getelementptr inbounds i32, i32* %8, i64 1
store i32 %28, i32* %8
%59 = getelementptr inbounds i8, i8* %27, i64 1
br label %6
60: ; preds = %53
%61 = call i32 @isspace(i8 signext %54)
%62 = icmp eq i32 %61, 0
br i1 %62, label %125, label %63
63: ; preds = %53, %18, %36, %60
%64 = phi i32 [ %28, %60 ], [ %37, %36 ], [ 0, %18 ], [ %28, %53 ]
%65 = getelementptr inbounds i32, i32* %8, i64 1
store i32 %64, i32* %8
%66 = ptrtoint i32* %65 to i64
%67 = ptrtoint [4 x i32]* %2 to i64
%68 = sub i64 %66, %67
%69 = lshr exact i64 %68, 2
%70 = trunc i64 %69 to i32
%71 = icmp sgt i32 %70, 4
br i1 %71, label %125, label %72
72: ; preds = %63
%73 = icmp sgt i32 %70, 0
br i1 %73, label %74, label %125
74: ; preds = %72
%75 = and i64 %69, 4294967295
%76 = add nsw i64 %75, -1
%77 = and i64 %69, 3
%78 = icmp ult i64 %76, 3
br i1 %78, label %108, label %79
79: ; preds = %74
%80 = sub nsw i64 %75, %77
br label %81
81: ; preds = %81, %79
%82 = phi i64 [ 0, %79 ], [ %84, %81 ]
%83 = phi i64 [ 0, %79 ], [ %85, %81 ]
%84 = add nuw nsw i64 %82, 4
%85 = add i64 %83, 4
%86 = icmp eq i64 %85, %80
br i1 %86, label %87, label %81
87: ; preds = %81
%88 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 0, i64 %82
%89 = load i32, i32* %88
%90 = or i64 %82, 1
%91 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 0, i64 %90
%92 = load i32, i32* %91
%93 = or i64 %82, 2
%94 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 0, i64 %93
%95 = load i32, i32* %94
%96 = or i64 %82, 3
%97 = shl i32 %89, 24
%98 = shl i32 %92, 16
%99 = and i32 %98, 16711680
%100 = or i32 %97, %99
%101 = shl i32 %95, 8
%102 = and i32 %101, 65280
%103 = or i32 %100, %102
%104 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 0, i64 %96
%105 = load i32, i32* %104
%106 = and i32 %105, 255
%107 = or i32 %106, %103
br label %108
108: ; preds = %87, %74
%109 = phi i32 [ undef, %74 ], [ %107, %87 ]
%110 = phi i64 [ 0, %74 ], [ %84, %87 ]
%111 = phi i32 [ 0, %74 ], [ %107, %87 ]
%112 = icmp eq i64 %77, 0
br i1 %112, label %125, label %113
113: ; preds = %108, %113
%114 = phi i64 [ %122, %113 ], [ %110, %108 ]
%115 = phi i32 [ %121, %113 ], [ %111, %108 ]
%116 = phi i64 [ %123, %113 ], [ 0, %108 ]
%117 = shl i32 %115, 8
%118 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 0, i64 %114
%119 = load i32, i32* %118
%120 = and i32 %119, 255
%121 = or i32 %120, %117
%122 = add nuw nsw i64 %114, 1
%123 = add i64 %116, 1
%124 = icmp eq i64 %123, %77
br i1 %124, label %125, label %113
125: ; preds = %55, %108, %113, %72, %63, %60
%126 = phi i32 [ -1, %60 ], [ -1, %63 ], [ 0, %72 ], [ %109, %108 ], [ %121, %113 ], [ -1, %55 ]
ret i32 %126
}