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

/* Variables and functions */
int /*<<< orphan*/ EINVAL;
int /*<<< orphan*/ ERANGE;
int /*<<< orphan*/ errno;
int /*<<< orphan*/ isalpha(char const);
size_t strlen(char const *);
int strtoull(char const *, char **, int);
char tolower(char const);
int _dehumanize_number(const char *buf, uint64_t *dest) {
  char *endptr;
  uint64_t n, n_check, d;
  uint64_t multiplier;
  size_t len;
  if (*buf == '\0') {
    errno = EINVAL;
    return -1;
  }
  len = strlen(buf);
  if (tolower(buf[len - 1]) == 'b')
    --len;
  multiplier = 1;
  switch (tolower(buf[len - 1])) {
  case 'y':
    multiplier *= 1024;
  case 'z':
    multiplier *= 1024;
  case 'e':
    multiplier *= 1024;
  case 'p':
    multiplier *= 1024;
  case 't':
    multiplier *= 1024;
  case 'g':
    multiplier *= 1024;
  case 'm':
    multiplier *= 1024;
  case 'k':
    multiplier *= 1024;
    break;
  default:
    if (isalpha(buf[len - 1])) {
      errno = EINVAL;
      return -1;
    }
  }
  d = 0;
  n = n_check = strtoull(buf, &endptr, 10);
  if (endptr) {
    if ((*endptr != '.') && (*endptr != '\0') && (*endptr != ' ') &&
        (endptr != &buf[len - 1])) {
      errno = EINVAL;
      return -1;
    }
    if (*endptr == '.') {
      d = strtoull(endptr + 1, &endptr, 10);
      if (endptr && (*endptr != '\0') && (*endptr != ' ') &&
          (endptr != &buf[len - 1])) {
        errno = EINVAL;
        return -1;
      }
    }
  }
  if (d != 0) {
    while (d < 100)
      d *= 10;
    while (d > 1000)
      d /= 10;
  }
  d *= (multiplier / 1024);
  n *= multiplier;
  if ((uint64_t)(n / multiplier) != n_check) {
    errno = ERANGE;
    return -1;
  }
  n += d;
  *dest = n;
  return 0;
}


x86 assembly (clang, -O0):
<_dehumanize_number>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    117e <_dehumanize_number+0x3e>
mov    0x2e69(%rip),%rax
mov    (%rax),%ecx
mov    0x2e68(%rip),%rax
mov    %ecx,(%rax)
movl   $0xffffffff,-0x4(%rbp)
jmp    1466 <_dehumanize_number+0x326>
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movsbl (%rax,%rcx,1),%edi
call   1050 <tolower@plt>
movsbl %al,%eax
cmp    $0x62,%eax
jne    11b8 <_dehumanize_number+0x78>
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x10(%rbp),%rcx
mov    -0x38(%rbp),%rax
movsbl -0x1(%rax,%rcx,1),%edi
call   1050 <tolower@plt>
movsbl %al,%eax
add    $0xffffff9b,%eax
mov    %eax,%ecx
mov    %rcx,-0x40(%rbp)
sub    $0x15,%eax
ja     1247 <_dehumanize_number+0x107>
mov    -0x40(%rbp),%rax
lea    0xe0f(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x30(%rbp),%eax
shl    $0xa,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
shl    $0xa,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
shl    $0xa,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
shl    $0xa,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
shl    $0xa,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
shl    $0xa,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
shl    $0xa,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
shl    $0xa,%eax
mov    %eax,-0x30(%rbp)
jmp    1288 <_dehumanize_number+0x148>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movsbl (%rax,%rcx,1),%edi
call   1060 <isalpha@plt>
cmp    $0x0,%eax
je     1283 <_dehumanize_number+0x143>
mov    0x2d64(%rip),%rax
mov    (%rax),%ecx
mov    0x2d63(%rip),%rax
mov    %ecx,(%rax)
movl   $0xffffffff,-0x4(%rbp)
jmp    1466 <_dehumanize_number+0x326>
jmp    1288 <_dehumanize_number+0x148>
movl   $0x0,-0x2c(%rbp)
mov    -0x10(%rbp),%rdi
lea    -0x20(%rbp),%rsi
mov    $0xa,%edx
call   1040 <strtoull@plt>
mov    %eax,-0x28(%rbp)
mov    %eax,-0x24(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     13b4 <_dehumanize_number+0x274>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
je     131c <_dehumanize_number+0x1dc>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     131c <_dehumanize_number+0x1dc>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
je     131c <_dehumanize_number+0x1dc>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x38(%rbp),%rdx
sub    $0x1,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
je     131c <_dehumanize_number+0x1dc>
mov    0x2ccb(%rip),%rax
mov    (%rax),%ecx
mov    0x2cca(%rip),%rax
mov    %ecx,(%rax)
movl   $0xffffffff,-0x4(%rbp)
jmp    1466 <_dehumanize_number+0x326>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    13af <_dehumanize_number+0x26f>
mov    -0x20(%rbp),%rdi
add    $0x1,%rdi
lea    -0x20(%rbp),%rsi
mov    $0xa,%edx
call   1040 <strtoull@plt>
mov    %eax,-0x2c(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     13aa <_dehumanize_number+0x26a>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     13aa <_dehumanize_number+0x26a>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
je     13aa <_dehumanize_number+0x26a>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x38(%rbp),%rdx
sub    $0x1,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
je     13aa <_dehumanize_number+0x26a>
mov    0x2c3d(%rip),%rax
mov    (%rax),%ecx
mov    0x2c3c(%rip),%rax
mov    %ecx,(%rax)
movl   $0xffffffff,-0x4(%rbp)
jmp    1466 <_dehumanize_number+0x326>
jmp    13af <_dehumanize_number+0x26f>
jmp    13b4 <_dehumanize_number+0x274>
cmpl   $0x0,-0x2c(%rbp)
je     1403 <_dehumanize_number+0x2c3>
jmp    13c3 <_dehumanize_number+0x283>
cmpl   $0x64,-0x2c(%rbp)
jge    13d9 <_dehumanize_number+0x299>
imul   $0xa,-0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    13c3 <_dehumanize_number+0x283>
jmp    13de <_dehumanize_number+0x29e>
cmpl   $0x3e8,-0x2c(%rbp)
jle    13fe <_dehumanize_number+0x2be>
mov    -0x2c(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x2c(%rbp)
jmp    13de <_dehumanize_number+0x29e>
jmp    1403 <_dehumanize_number+0x2c3>
mov    -0x30(%rbp),%eax
mov    $0x400,%ecx
cltd
idiv   %ecx
imul   -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cltd
idivl  -0x30(%rbp)
cmp    -0x28(%rbp),%eax
je     144d <_dehumanize_number+0x30d>
mov    0x2bb2(%rip),%rax
mov    (%rax),%ecx
mov    0x2b99(%rip),%rax
mov    %ecx,(%rax)
movl   $0xffffffff,-0x4(%rbp)
jmp    1466 <_dehumanize_number+0x326>
mov    -0x2c(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_dehumanize_number>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x10,%rsp
cmpb   $0x0,(%rdi)
je     12b8 <_dehumanize_number+0x178>
mov    %rsi,%r14
mov    %rdi,%r15
call   1030 <strlen@plt>
mov    %rax,%rbp
lea    -0x1(%rax),%rbx
movsbl -0x1(%r15,%rax,1),%edi
call   1050 <tolower@plt>
cmp    $0x62,%al
cmovne %rbp,%rbx
lea    (%rbx,%r15,1),%r12
add    $0xffffffffffffffff,%r12
movsbl -0x1(%rbx,%r15,1),%edi
call   1050 <tolower@plt>
movsbl %al,%edx
add    $0xffffff9b,%edx
cmp    $0x15,%edx
ja     1285 <_dehumanize_number+0x145>
mov    $0x400,%ebp
mov    $0x100000,%ecx
mov    $0x40000000,%eax
lea    0xe50(%rip),%rsi
movslq (%rsi,%rdx,4),%rdx
add    %rsi,%rdx
jmp    *%rdx
xor    %eax,%eax
mov    %eax,%ecx
mov    %ecx,%ebp
lea    0x8(%rsp),%rsi
mov    %r15,%rdi
mov    $0xa,%edx
call   1040 <strtoull@plt>
mov    %eax,%ebx
mov    0x8(%rsp),%rdi
xor    %r15d,%r15d
mov    $0x0,%ecx
test   %rdi,%rdi
je     129f <_dehumanize_number+0x15f>
mov    (%rdi),%al
mov    $0x0,%ecx
test   %al,%al
je     129f <_dehumanize_number+0x15f>
mov    $0x0,%ecx
cmp    $0x20,%al
je     129f <_dehumanize_number+0x15f>
cmp    $0x2e,%al
jne    1275 <_dehumanize_number+0x135>
add    $0x1,%rdi
lea    0x8(%rsp),%rsi
mov    $0xa,%edx
call   1040 <strtoull@plt>
mov    0x8(%rsp),%rcx
test   %rcx,%rcx
je     122f <_dehumanize_number+0xef>
testb  $0xdf,(%rcx)
jne    12af <_dehumanize_number+0x16f>
mov    $0x0,%ecx
test   %eax,%eax
je     129f <_dehumanize_number+0x15f>
cmp    $0x63,%eax
jg     124a <_dehumanize_number+0x10a>
nopl   (%rax)
add    %eax,%eax
lea    (%rax,%rax,4),%eax
cmp    $0x64,%eax
jl     1240 <_dehumanize_number+0x100>
cmp    $0x3e9,%eax
jb     129d <_dehumanize_number+0x15d>
mov    $0xcccccccd,%edx
cs nopw 0x0(%rax,%rax,1)
mov    %eax,%ecx
imul   %rdx,%rcx
shr    $0x23,%rcx
cmp    $0x2719,%eax
mov    %ecx,%eax
ja     1260 <_dehumanize_number+0x120>
jmp    129f <_dehumanize_number+0x15f>
cmp    %r12,%rdi
jne    12b8 <_dehumanize_number+0x178>
mov    $0x0,%ecx
cmp    $0x2e,%al
je     1209 <_dehumanize_number+0xc9>
jmp    129f <_dehumanize_number+0x15f>
movsbl (%r12),%edi
call   1060 <isalpha@plt>
test   %eax,%eax
jne    12b8 <_dehumanize_number+0x178>
mov    $0x1,%ebp
jmp    11bf <_dehumanize_number+0x7f>
mov    %eax,%ecx
imul   %ebp,%ebx
shr    $0xa,%ebp
imul   %ecx,%ebp
add    %ebx,%ebp
mov    %ebp,(%r14)
jmp    12d0 <_dehumanize_number+0x190>
cmp    %r12,%rcx
je     122f <_dehumanize_number+0xef>
mov    0x2d19(%rip),%rax
mov    (%rax),%eax
mov    0x2d18(%rip),%rcx
mov    %eax,(%rcx)
mov    $0xffffffff,%r15d
mov    %r15d,%eax
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@EINVAL = global i32 0
@errno = global i32 0
@ERANGE = global i32 0
define i32 @_dehumanize_number(i8* %0, i32* nocapture writeonly %1) {
%3 = alloca i8*
%4 = bitcast i8** %3 to i8*
%5 = load i8, i8* %0
%6 = icmp eq i8 %5, 0
br i1 %6, label %7, label %9
7: ; preds = %2
%8 = load i32, i32* @EINVAL
store i32 %8, i32* @errno
br label %78
9: ; preds = %2
%10 = tail call i64 @strlen(i8* %0)
%11 = add i64 %10, -1
%12 = getelementptr inbounds i8, i8* %0, i64 %11
%13 = load i8, i8* %12
%14 = tail call signext i8 @tolower(i8 signext %13)
%15 = icmp eq i8 %14, 98
%16 = select i1 %15, i64 %11, i64 %10
%17 = add i64 %16, -1
%18 = getelementptr inbounds i8, i8* %0, i64 %17
%19 = load i8, i8* %18
%20 = tail call signext i8 @tolower(i8 signext %19)
%21 = sext i8 %20 to i32
switch i32 %21, label %27 [
i32 121, label %22
i32 122, label %22
i32 101, label %22
i32 112, label %22
i32 116, label %22
i32 103, label %23
i32 109, label %25
i32 107, label %33
]
22: ; preds = %9, %9, %9, %9, %9
br label %23
23: ; preds = %9, %22
%24 = phi i32 [ 1073741824, %9 ], [ 0, %22 ]
br label %25
25: ; preds = %9, %23
%26 = phi i32 [ 1048576, %9 ], [ %24, %23 ]
br label %33
27: ; preds = %9
%28 = load i8, i8* %18
%29 = tail call i32 @isalpha(i8 signext %28)
%30 = icmp eq i32 %29, 0
br i1 %30, label %33, label %31
31: ; preds = %27
%32 = load i32, i32* @EINVAL
store i32 %32, i32* @errno
br label %78
33: ; preds = %25, %9, %27
%34 = phi i32 [ 1, %27 ], [ 1024, %9 ], [ %26, %25 ]
%35 = call i32 @strtoull(i8* %0, i8** %3, i32 10)
%36 = load i8*, i8** %3
%37 = icmp eq i8* %36, null
br i1 %37, label %72, label %38
38: ; preds = %33
%39 = load i8, i8* %36
switch i8 %39, label %40 [
i8 46, label %46
i8 0, label %72
i8 32, label %72
]
40: ; preds = %38
%41 = icmp eq i8* %36, %18
br i1 %41, label %44, label %42
42: ; preds = %40
%43 = load i32, i32* @EINVAL
store i32 %43, i32* @errno
br label %78
44: ; preds = %40
%45 = icmp eq i8 %39, 46
br i1 %45, label %46, label %72
46: ; preds = %38, %44
%47 = getelementptr inbounds i8, i8* %36, i64 1
%48 = call i32 @strtoull(i8* %47, i8** %3, i32 10)
%49 = load i8*, i8** %3
%50 = icmp eq i8* %49, null
br i1 %50, label %57, label %51
51: ; preds = %46
%52 = load i8, i8* %49
switch i8 %52, label %53 [
i8 0, label %57
i8 32, label %57
]
53: ; preds = %51
%54 = icmp eq i8* %49, %18
br i1 %54, label %57, label %55
55: ; preds = %53
%56 = load i32, i32* @EINVAL
store i32 %56, i32* @errno
br label %78
57: ; preds = %51, %51, %53, %46
%58 = icmp eq i32 %48, 0
br i1 %58, label %72, label %59
59: ; preds = %57
%60 = icmp slt i32 %48, 100
br i1 %60, label %64, label %61
61: ; preds = %64, %59
%62 = phi i32 [ %48, %59 ], [ %66, %64 ]
%63 = icmp ugt i32 %62, 1000
br i1 %63, label %68, label %72
64: ; preds = %59, %64
%65 = phi i32 [ %66, %64 ], [ %48, %59 ]
%66 = mul nsw i32 %65, 10
%67 = icmp slt i32 %66, 100
br i1 %67, label %64, label %61
68: ; preds = %61, %68
%69 = phi i32 [ %70, %68 ], [ %62, %61 ]
%70 = udiv i32 %69, 10
%71 = icmp ugt i32 %69, 10009
br i1 %71, label %68, label %72
72: ; preds = %68, %61, %38, %38, %33, %44, %57
%73 = phi i32 [ 0, %57 ], [ 0, %44 ], [ 0, %33 ], [ 0, %38 ], [ 0, %38 ], [ %62, %61 ], [ %70, %68 ]
%74 = mul nsw i32 %35, %34
%75 = sdiv i32 %34, 1024
%76 = mul nsw i32 %73, %75
%77 = add nsw i32 %76, %74
store i32 %77, i32* %1
br label %78
78: ; preds = %72, %55, %42, %31, %7
%79 = phi i32 [ -1, %7 ], [ -1, %31 ], [ -1, %42 ], [ -1, %55 ], [ 0, %72 ]
ret i32 %79
}