#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 char u_long;
typedef char in_addr_t;

/* Variables and functions */
char INADDR_NONE;
scalar_t__ isdigit(unsigned char);
scalar_t__ islower(unsigned char);
int /*<<< orphan*/ isspace(unsigned char);
scalar_t__ isxdigit(unsigned char);
in_addr_t inet_network(const char *cp) {
  register u_long val, base, n, i;
  register char c;
  u_long parts[4], *pp = parts;
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((unsigned char)c)) {
      val = (val * base) + (c - '0');
      cp++;
      continue;
    }
    if (base == 16 && isxdigit((unsigned char)c)) {
      val = (val << 4) + (c + 10 - (islower((unsigned char)c) ? 'a' : 'A'));
      cp++;
      continue;
    }
    break;
  }
  if (*cp == '.') {
    if (pp >= parts + 3)
      return (INADDR_NONE);
    *pp++ = val, cp++;
    goto again;
  }
  if (*cp && !isspace((unsigned char)*cp))
    return (INADDR_NONE);
  *pp++ = val;
  n = pp - parts;
  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    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
lea    -0x19(%rbp),%rax
mov    %rax,-0x28(%rbp)
movb   $0x0,-0x11(%rbp)
movb   $0xa,-0x12(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jne    117c <inet_network+0x3c>
movb   $0x8,-0x12(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x78,%eax
je     119c <inet_network+0x5c>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x58,%eax
jne    11ac <inet_network+0x6c>
movb   $0x10,-0x12(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    11b1 <inet_network+0x71>
mov    -0x10(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x15(%rbp)
movsbl %al,%eax
cmp    $0x0,%eax
je     1275 <inet_network+0x135>
movzbl -0x15(%rbp),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     1201 <inet_network+0xc1>
movsbl -0x11(%rbp),%eax
movsbl -0x12(%rbp),%ecx
imul   %ecx,%eax
movsbl -0x15(%rbp),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %al,-0x11(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    11b1 <inet_network+0x71>
movsbl -0x12(%rbp),%eax
cmp    $0x10,%eax
jne    1270 <inet_network+0x130>
movzbl -0x15(%rbp),%edi
call   1060 <isxdigit@plt>
cmp    $0x0,%rax
je     1270 <inet_network+0x130>
movsbl -0x11(%rbp),%eax
shl    $0x4,%eax
mov    %eax,-0x2c(%rbp)
movsbl -0x15(%rbp),%eax
add    $0xa,%eax
mov    %eax,-0x30(%rbp)
movzbl -0x15(%rbp),%edi
call   1040 <islower@plt>
mov    -0x30(%rbp),%ecx
mov    %rax,%rdi
mov    -0x2c(%rbp),%eax
mov    $0x41,%edx
mov    $0x61,%esi
cmp    $0x0,%rdi
cmovne %esi,%edx
sub    %edx,%ecx
add    %ecx,%eax
mov    %al,-0x11(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    11b1 <inet_network+0x71>
jmp    1275 <inet_network+0x135>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    12d0 <inet_network+0x190>
mov    -0x28(%rbp),%rax
lea    -0x19(%rbp),%rcx
add    $0x3,%rcx
cmp    %rcx,%rax
jb     12ab <inet_network+0x16b>
mov    0x2d47(%rip),%rax
mov    (%rax),%al
mov    %al,-0x1(%rbp)
jmp    1376 <inet_network+0x236>
mov    -0x11(%rbp),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%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     1306 <inet_network+0x1c6>
mov    -0x10(%rbp),%rax
movzbl (%rax),%edi
call   1050 <isspace@plt>
cmp    $0x0,%eax
jne    1306 <inet_network+0x1c6>
mov    0x2cec(%rip),%rax
mov    (%rax),%al
mov    %al,-0x1(%rbp)
jmp    1376 <inet_network+0x236>
mov    -0x11(%rbp),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
lea    -0x19(%rbp),%rcx
sub    %rcx,%rax
mov    %al,-0x13(%rbp)
movb   $0x0,-0x11(%rbp)
movb   $0x0,-0x14(%rbp)
movsbl -0x14(%rbp),%eax
movsbl -0x13(%rbp),%ecx
cmp    %ecx,%eax
jge    1370 <inet_network+0x230>
movsbl -0x11(%rbp),%eax
shl    $0x8,%eax
mov    %al,-0x11(%rbp)
movsbq -0x14(%rbp),%rax
movsbl -0x19(%rbp,%rax,1),%ecx
and    $0xff,%ecx
movsbl -0x11(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x11(%rbp)
mov    -0x14(%rbp),%al
add    $0x1,%al
mov    %al,-0x14(%rbp)
jmp    1330 <inet_network+0x1f0>
mov    -0x11(%rbp),%al
mov    %al,-0x1(%rbp)
movsbl -0x1(%rbp),%eax
add    $0x30,%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,%rbx
lea    0xc(%rsp),%r15
mov    0x2e8b(%rip),%rax
mov    %rax,0x10(%rsp)
xor    %ecx,%ecx
cmpb   $0x30,(%rbx)
sete   %cl
setne  %r13b
lea    (%rbx,%rcx,1),%rax
mov    (%rbx,%rcx,1),%r12b
mov    %r12d,%ecx
or     $0x20,%cl
cmp    $0x78,%cl
jne    11a0 <inet_network+0x60>
mov    0x1(%rax),%r12b
add    $0x1,%rax
mov    $0x10,%r13b
test   %r12b,%r12b
jne    11b0 <inet_network+0x70>
jmp    124d <inet_network+0x10d>
cs nopw 0x0(%rax,%rax,1)
add    %r13b,%r13b
or     $0x8,%r13b
test   %r12b,%r12b
je     124d <inet_network+0x10d>
add    $0x1,%rax
xor    %r14d,%r14d
mov    %rax,%rbx
jmp    11e1 <inet_network+0xa1>
nopl   0x0(%rax)
mov    %r14d,%eax
mul    %r13b
mov    %eax,%r14d
add    %r12b,%r14b
add    $0xd0,%r14b
movzbl (%rbx),%r12d
add    $0x1,%rbx
test   %r12b,%r12b
je     1262 <inet_network+0x122>
movzbl %r12b,%ebp
mov    %ebp,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
jne    11c0 <inet_network+0x80>
cmp    $0x10,%r13b
jne    1230 <inet_network+0xf0>
mov    %ebp,%edi
call   1060 <isxdigit@plt>
test   %rax,%rax
je     1230 <inet_network+0xf0>
shl    $0x4,%r14b
mov    %ebp,%edi
call   1040 <islower@plt>
test   %rax,%rax
sete   %al
shl    $0x5,%al
add    %r14b,%r12b
add    %al,%r12b
add    $0xa9,%r12b
mov    %r12d,%r14d
jmp    11d0 <inet_network+0x90>
cs nopw 0x0(%rax,%rax,1)
mov    -0x1(%rbx),%al
cmp    $0x2e,%al
jne    1252 <inet_network+0x112>
lea    0xf(%rsp),%rax
cmp    %rax,%r15
jae    12ac <inet_network+0x16c>
mov    %r14b,(%r15)
add    $0x1,%r15
jmp    1162 <inet_network+0x22>
xor    %r14d,%r14d
jmp    1262 <inet_network+0x122>
test   %al,%al
je     1262 <inet_network+0x122>
movzbl %al,%edi
call   1050 <isspace@plt>
test   %eax,%eax
je     12ac <inet_network+0x16c>
mov    %r14b,(%r15)
lea    0xc(%rsp),%rax
sub    %eax,%r15d
add    $0x1,%r15d
mov    %r15d,%eax
shl    $0x18,%eax
test   %eax,%eax
jle    12b5 <inet_network+0x175>
movsbl %r15b,%ecx
mov    $0xff,%al
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x2(%rax),%edx
movsbl %dl,%edx
add    $0x1,%al
cmp    %edx,%ecx
jg     1290 <inet_network+0x150>
movsbq %al,%rax
add    %rsp,%rax
add    $0xc,%rax
mov    %rax,0x10(%rsp)
mov    0x10(%rsp),%rax
mov    (%rax),%al
jmp    12b7 <inet_network+0x177>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@INADDR_NONE = global i8 0
define signext i8 @inet_network(i8* nocapture %0) {
%2 = alloca [4 x i8]
%3 = getelementptr inbounds [4 x i8], [4 x i8]* %2, i64 0, i64 0
%4 = getelementptr inbounds [4 x i8], [4 x i8]* %2, i64 0, i64 3
br label %5
5: ; preds = %55, %1
%6 = phi i8* [ %0, %1 ], [ %57, %55 ]
%7 = phi i8* [ %3, %1 ], [ %56, %55 ]
%8 = load i8, i8* %6
%9 = icmp eq i8 %8, 48
%10 = select i1 %9, i8 8, i8 10
%11 = zext i1 %9 to i64
%12 = getelementptr i8, i8* %6, i64 %11
%13 = load i8, i8* %12
switch i8 %13, label %17 [
i8 120, label %14
i8 88, label %14
]
14: ; preds = %5, %5
%15 = getelementptr inbounds i8, i8* %12, i64 1
%16 = load i8, i8* %15
br label %17
17: ; preds = %5, %14
%18 = phi i8 [ %16, %14 ], [ %13, %5 ]
%19 = phi i8 [ 16, %14 ], [ %10, %5 ]
%20 = phi i8* [ %15, %14 ], [ %12, %5 ]
%21 = icmp eq i8 %18, 0
br i1 %21, label %61, label %22
22: ; preds = %17
%23 = icmp eq i8 %19, 16
br label %24
24: ; preds = %22, %34
%25 = phi i8 [ %18, %22 ], [ %37, %34 ]
%26 = phi i8* [ %20, %22 ], [ %36, %34 ]
%27 = phi i8 [ 0, %22 ], [ %35, %34 ]
%28 = call i64 @isdigit(i8 zeroext %25)
%29 = icmp eq i64 %28, 0
br i1 %29, label %39, label %30
30: ; preds = %24
%31 = mul i8 %27, %19
%32 = add i8 %31, -48
%33 = add i8 %32, %25
br label %34
34: ; preds = %30, %43
%35 = phi i8 [ %33, %30 ], [ %50, %43 ]
%36 = getelementptr inbounds i8, i8* %26, i64 1
%37 = load i8, i8* %36
%38 = icmp eq i8 %37, 0
br i1 %38, label %61, label %24
39: ; preds = %24
br i1 %23, label %40, label %51
40: ; preds = %39
%41 = call i64 @isxdigit(i8 zeroext %25)
%42 = icmp eq i64 %41, 0
br i1 %42, label %51, label %43
43: ; preds = %40
%44 = shl i8 %27, 4
%45 = call i64 @islower(i8 zeroext %25)
%46 = icmp eq i64 %45, 0
%47 = select i1 %46, i8 -65, i8 -97
%48 = or i8 %44, 10
%49 = add i8 %48, %25
%50 = add i8 %49, %47
br label %34
51: ; preds = %39, %40
%52 = load i8, i8* %26
switch i8 %52, label %58 [
i8 46, label %53
i8 0, label %61
]
53: ; preds = %51
%54 = icmp ult i8* %7, %4
br i1 %54, label %55, label %79
55: ; preds = %53
%56 = getelementptr inbounds i8, i8* %7, i64 1
store i8 %27, i8* %7
%57 = getelementptr inbounds i8, i8* %26, i64 1
br label %5
58: ; preds = %51
%59 = call i32 @isspace(i8 zeroext %52)
%60 = icmp eq i32 %59, 0
br i1 %60, label %79, label %61
61: ; preds = %51, %17, %34, %58
%62 = phi i8 [ %27, %58 ], [ %35, %34 ], [ 0, %17 ], [ %27, %51 ]
%63 = getelementptr inbounds i8, i8* %7, i64 1
store i8 %62, i8* %7
%64 = ptrtoint i8* %63 to i64
%65 = ptrtoint [4 x i8]* %2 to i64
%66 = sub i64 %64, %65
%67 = trunc i64 %66 to i32
%68 = shl i32 %67, 24
%69 = ashr exact i32 %68, 24
%70 = icmp sgt i32 %68, 0
br i1 %70, label %71, label %82
71: ; preds = %61, %71
%72 = phi i8 [ %73, %71 ], [ 0, %61 ]
%73 = add i8 %72, 1
%74 = sext i8 %73 to i32
%75 = icmp sgt i32 %69, %74
br i1 %75, label %71, label %76
76: ; preds = %71
%77 = sext i8 %72 to i64
%78 = getelementptr inbounds [4 x i8], [4 x i8]* %2, i64 0, i64 %77
br label %79
79: ; preds = %53, %58, %76
%80 = phi i8* [ %78, %76 ], [ @INADDR_NONE, %58 ], [ @INADDR_NONE, %53 ]
%81 = load i8, i8* %80
br label %82
82: ; preds = %79, %61
%83 = phi i8 [ 0, %61 ], [ %81, %79 ]
ret i8 %83
}