#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 */
struct iaddr {
  unsigned char *bytes;
  unsigned long word;
};

/* Variables and functions */
int /*<<< orphan*/ EINVAL;
unsigned long INADDR_NONE;
int /*<<< orphan*/ errno;
unsigned long htonl(unsigned long);
unsigned long inet_addr2(const char *cp) {
  static const unsigned long max[4] = {0xFFFFFFFF, 0xFFFFFF, 0xFFFF, 0xFF};
  unsigned long val;
  char c;
  union iaddr {
    unsigned char bytes[4];
    unsigned long word;
  } res;
  unsigned char *pp = res.bytes;
  int digit;
  int base;
  res.word = 0;
  c = *cp;
  for (;;) {
    if (c < '0' || c > '9') {
      errno = EINVAL;
      return INADDR_NONE;
    }
    val = 0;
    base = 10;
    digit = 0;
    if (c == '0') {
      c = *++cp;
      if (c == 'x' || c == 'X')
        base = 16, c = *++cp;
      else {
        base = 8;
        digit = 1;
      }
    }
    for (;;) {
      if (c >= '0' && c <= '9') {
        if (base == 8 && (c == '8' || c == '9')) {
          errno = EINVAL;
          return INADDR_NONE;
        }
        val = (val * base) + (c - '0');
        c = *++cp;
        digit = 1;
      } else if (base == 16 && c >= 'a' && c <= 'f') {
        val = (val << 4) | (c + 10 - 'a');
        c = *++cp;
        digit = 1;
      } else if (base == 16 && c >= 'A' && c <= 'F') {
        val = (val << 4) | (c + 10 - 'A');
        c = *++cp;
        digit = 1;
      } else
        break;
    }
    if (c == '.') {
      if (pp > res.bytes + 2 || val > 0xFF) {
        errno = EINVAL;
        return INADDR_NONE;
      }
      *pp++ = (unsigned char)val;
      c = *++cp;
    } else
      break;
  }
  if (c > ' ') {
    errno = EINVAL;
    return INADDR_NONE;
  }
  if (!digit) {
    errno = EINVAL;
    return INADDR_NONE;
  }
  if (val > max[pp - res.bytes]) {
    errno = EINVAL;
    return INADDR_NONE;
  }
  return res.word | htonl(val);
}


x86 assembly (clang, -O0):
<inet_addr2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
lea    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x19(%rbp)
movsbl -0x19(%rbp),%eax
cmp    $0x30,%eax
jl     114f <inet_addr2+0x3f>
movsbl -0x19(%rbp),%eax
cmp    $0x39,%eax
jle    1174 <inet_addr2+0x64>
mov    0x2e7a(%rip),%rax
mov    (%rax),%ecx
mov    0x2e79(%rip),%rax
mov    %ecx,(%rax)
mov    0x2e80(%rip),%rax
mov    (%rax),%rax
mov    %rax,-0x8(%rbp)
jmp    14cb <inet_addr2+0x3bb>
movq   $0x0,-0x18(%rbp)
movl   $0xa,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
movsbl -0x19(%rbp),%eax
cmp    $0x30,%eax
jne    11fa <inet_addr2+0xea>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    0x1(%rax),%al
mov    %al,-0x19(%rbp)
movsbl -0x19(%rbp),%eax
cmp    $0x78,%eax
je     11c6 <inet_addr2+0xb6>
movsbl -0x19(%rbp),%eax
cmp    $0x58,%eax
jne    11e7 <inet_addr2+0xd7>
movl   $0x10,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    0x1(%rax),%al
mov    %al,-0x19(%rbp)
jmp    11f5 <inet_addr2+0xe5>
movl   $0x8,-0x38(%rbp)
movl   $0x1,-0x34(%rbp)
jmp    11fa <inet_addr2+0xea>
jmp    11ff <inet_addr2+0xef>
movsbl -0x19(%rbp),%eax
cmp    $0x30,%eax
jl     12a0 <inet_addr2+0x190>
movsbl -0x19(%rbp),%eax
cmp    $0x39,%eax
jg     12a0 <inet_addr2+0x190>
cmpl   $0x8,-0x38(%rbp)
jne    1262 <inet_addr2+0x152>
movsbl -0x19(%rbp),%eax
cmp    $0x38,%eax
je     123d <inet_addr2+0x12d>
movsbl -0x19(%rbp),%eax
cmp    $0x39,%eax
jne    1262 <inet_addr2+0x152>
mov    0x2d8c(%rip),%rax
mov    (%rax),%ecx
mov    0x2d8b(%rip),%rax
mov    %ecx,(%rax)
mov    0x2d92(%rip),%rax
mov    (%rax),%rax
mov    %rax,-0x8(%rbp)
jmp    14cb <inet_addr2+0x3bb>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
imul   %rcx,%rax
movsbl -0x19(%rbp),%ecx
sub    $0x30,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    0x1(%rax),%al
mov    %al,-0x19(%rbp)
movl   $0x1,-0x34(%rbp)
jmp    1371 <inet_addr2+0x261>
cmpl   $0x10,-0x38(%rbp)
jne    1301 <inet_addr2+0x1f1>
movsbl -0x19(%rbp),%eax
cmp    $0x61,%eax
jl     1301 <inet_addr2+0x1f1>
movsbl -0x19(%rbp),%eax
cmp    $0x66,%eax
jg     1301 <inet_addr2+0x1f1>
mov    -0x18(%rbp),%rax
shl    $0x4,%rax
movsbl -0x19(%rbp),%ecx
add    $0xa,%ecx
sub    $0x61,%ecx
movslq %ecx,%rcx
or     %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    0x1(%rax),%al
mov    %al,-0x19(%rbp)
movl   $0x1,-0x34(%rbp)
jmp    136c <inet_addr2+0x25c>
cmpl   $0x10,-0x38(%rbp)
jne    1362 <inet_addr2+0x252>
movsbl -0x19(%rbp),%eax
cmp    $0x41,%eax
jl     1362 <inet_addr2+0x252>
movsbl -0x19(%rbp),%eax
cmp    $0x46,%eax
jg     1362 <inet_addr2+0x252>
mov    -0x18(%rbp),%rax
shl    $0x4,%rax
movsbl -0x19(%rbp),%ecx
add    $0xa,%ecx
sub    $0x41,%ecx
movslq %ecx,%rcx
or     %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    0x1(%rax),%al
mov    %al,-0x19(%rbp)
movl   $0x1,-0x34(%rbp)
jmp    1367 <inet_addr2+0x257>
jmp    1376 <inet_addr2+0x266>
jmp    136c <inet_addr2+0x25c>
jmp    1371 <inet_addr2+0x261>
jmp    11ff <inet_addr2+0xef>
movsbl -0x19(%rbp),%eax
cmp    $0x2e,%eax
jne    13fc <inet_addr2+0x2ec>
mov    -0x30(%rbp),%rax
lea    -0x28(%rbp),%rcx
add    $0x2,%rcx
cmp    %rcx,%rax
ja     13a6 <inet_addr2+0x296>
cmpq   $0xff,-0x18(%rbp)
jbe    13cb <inet_addr2+0x2bb>
mov    0x2c23(%rip),%rax
mov    (%rax),%ecx
mov    0x2c22(%rip),%rax
mov    %ecx,(%rax)
mov    0x2c29(%rip),%rax
mov    (%rax),%rax
mov    %rax,-0x8(%rbp)
jmp    14cb <inet_addr2+0x3bb>
mov    -0x18(%rbp),%rax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    0x1(%rax),%al
mov    %al,-0x19(%rbp)
jmp    1401 <inet_addr2+0x2f1>
jmp    1406 <inet_addr2+0x2f6>
jmp    1135 <inet_addr2+0x25>
movsbl -0x19(%rbp),%eax
cmp    $0x20,%eax
jle    1438 <inet_addr2+0x328>
mov    0x2bb6(%rip),%rax
mov    (%rax),%ecx
mov    0x2bb5(%rip),%rax
mov    %ecx,(%rax)
mov    0x2bbc(%rip),%rax
mov    (%rax),%rax
mov    %rax,-0x8(%rbp)
jmp    14cb <inet_addr2+0x3bb>
cmpl   $0x0,-0x34(%rbp)
jne    1467 <inet_addr2+0x357>
mov    0x2b87(%rip),%rax
mov    (%rax),%ecx
mov    0x2b86(%rip),%rax
mov    %ecx,(%rax)
mov    0x2b8d(%rip),%rax
mov    (%rax),%rax
mov    %rax,-0x8(%rbp)
jmp    14cb <inet_addr2+0x3bb>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rdx
lea    -0x28(%rbp),%rcx
sub    %rcx,%rdx
lea    0xb83(%rip),%rcx
cmp    (%rcx,%rdx,8),%rax
jbe    14ac <inet_addr2+0x39c>
mov    0x2b42(%rip),%rax
mov    (%rax),%ecx
mov    0x2b41(%rip),%rax
mov    %ecx,(%rax)
mov    0x2b48(%rip),%rax
mov    (%rax),%rax
mov    %rax,-0x8(%rbp)
jmp    14cb <inet_addr2+0x3bb>
mov    -0x28(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rdi
call   1030 <htonl@plt>
mov    %rax,%rcx
mov    -0x40(%rbp),%rax
or     %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<inet_addr2>:
push   %rbp
push   %r14
push   %rbx
sub    $0x10,%rsp
movq   $0x0,0x8(%rsp)
mov    (%rdi),%sil
lea    -0x3a(%rsi),%eax
cmp    $0xf6,%al
jae    1150 <inet_addr2+0x40>
mov    0x2e9e(%rip),%rax
mov    (%rax),%eax
mov    0x2e9d(%rip),%rcx
mov    %eax,(%rcx)
mov    0x2ea4(%rip),%rax
mov    (%rax),%rax
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret
lea    0x8(%rsp),%r8
xor    %r9d,%r9d
cmp    $0x30,%sil
jne    1180 <inet_addr2+0x70>
mov    0x1(%rdi),%sil
mov    %esi,%eax
and    $0xdf,%al
xor    %ecx,%ecx
cmp    $0x58,%al
jne    1190 <inet_addr2+0x80>
mov    0x2(%rdi),%sil
add    $0x2,%rdi
mov    $0x10,%r10d
mov    $0x1,%r14b
jmp    118b <inet_addr2+0x7b>
nop
mov    $0xa,%r10d
xor    %ecx,%ecx
xor    %r14d,%r14d
xor    %r11d,%r11d
jmp    11a5 <inet_addr2+0x95>
add    $0x1,%rdi
mov    $0x8,%r10d
mov    $0x1,%r11b
mov    $0x1,%ecx
xor    %r14d,%r14d
add    $0x1,%rdi
xor    %eax,%eax
jmp    11c6 <inet_addr2+0xb6>
nopl   (%rax)
shl    $0x4,%rax
add    $0xffffffa9,%ebx
or     %rbx,%rax
movzbl (%rdi),%esi
add    $0x1,%rdi
mov    $0x1,%ecx
movsbl %sil,%ebx
lea    -0x30(%rbx),%ebp
cmp    $0x9,%bpl
ja     1200 <inet_addr2+0xf0>
and    $0xfe,%sil
cmp    $0x38,%sil
sete   %cl
and    %r11b,%cl
cmp    $0x1,%cl
je     112b <inet_addr2+0x1b>
imul   %r10,%rax
add    $0xffffffd0,%ebx
add    %rbx,%rax
jmp    11ba <inet_addr2+0xaa>
cs nopw 0x0(%rax,%rax,1)
cmp    $0x61,%sil
setge  %dl
and    %r14b,%dl
cmp    $0x1,%dl
jne    1215 <inet_addr2+0x105>
cmp    $0x66,%sil
jle    11b0 <inet_addr2+0xa0>
cmp    $0x41,%sil
setge  %dl
and    %r14b,%dl
cmp    $0x1,%dl
jne    1240 <inet_addr2+0x130>
cmp    $0x46,%sil
jg     1240 <inet_addr2+0x130>
shl    $0x4,%rax
add    $0xffffffc9,%ebx
jmp    11b7 <inet_addr2+0xa7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0x2e,%sil
jne    127e <inet_addr2+0x16e>
cmp    $0x2,%r9
ja     112b <inet_addr2+0x1b>
cmp    $0x100,%rax
jae    112b <inet_addr2+0x1b>
mov    %al,(%r8)
lea    (%rsp,%r9,1),%r8
add    $0x9,%r8
add    $0x1,%r9
mov    (%rdi),%sil
lea    -0x3a(%rsi),%eax
cmp    $0xf6,%al
jae    1158 <inet_addr2+0x48>
jmp    112b <inet_addr2+0x1b>
cmp    $0x21,%sil
jge    112b <inet_addr2+0x1b>
test   %ecx,%ecx
je     112b <inet_addr2+0x1b>
lea    0x8(%rsp),%rcx
sub    %rcx,%r8
lea    0xd61(%rip),%rcx
cmp    (%rcx,%r8,8),%rax
ja     112b <inet_addr2+0x1b>
mov    0x8(%rsp),%rbx
mov    %rax,%rdi
call   1030 <htonl@plt>
or     %rbx,%rax
jmp    1147 <inet_addr2+0x37>

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

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