#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*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ stderr;
long long getarg(char *str) {
  long long foo = 0;
  char *s = str;
  long long unit = 1;
  int last = 0;
  unsigned char c;
  if (s == NULL || *s == 0)
    goto usage;
  if (*s == '-') {
    unit = -1;
    s++;
  }
  while ((c = *s++)) {
    if (last)
      goto usage;
    switch (c) {
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
      foo = foo * 10 + (c - '0');
      break;
    case 'k':
    case 'K':
      unit *= 1LL << 10;
      last = 1;
      break;
    case 'm':
    case 'M':
      unit *= 1LL << 20;
      last = 1;
      break;
    case 'g':
    case 'G':
      unit *= 1LL << 30;
      last = 1;
      break;
    case 't':
    case 'T':
      unit *= 1LL << 40;
      last = 1;
      break;
    default:
      goto usage;
    }
  }
  return (foo * unit);
usage:
  fprintf(stderr, "Unknown arg '%s'\n", str);
  fprintf(stderr, "Use <int>[kmgt]\n");
  exit(1);
}


x86 assembly (clang, -O0):
<getarg>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
movq   $0x0,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
movq   $0x1,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     1166 <getarg+0x46>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    116b <getarg+0x4b>
jmp    127d <getarg+0x15d>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    118f <getarg+0x6f>
movq   $0xffffffffffffffff,-0x20(%rbp)
ff
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1194 <getarg+0x74>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
mov    (%rax),%al
mov    %al,-0x25(%rbp)
cmp    $0x0,%al
je     126e <getarg+0x14e>
cmpl   $0x0,-0x24(%rbp)
je     11bf <getarg+0x9f>
jmp    127d <getarg+0x15d>
movzbl -0x25(%rbp),%eax
add    $0xffffffd0,%eax
mov    %eax,%ecx
mov    %rcx,-0x30(%rbp)
sub    $0x44,%eax
ja     1264 <getarg+0x144>
mov    -0x30(%rbp),%rax
lea    0xe20(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
imul   $0xa,-0x10(%rbp),%rax
movzbl -0x25(%rbp),%ecx
sub    $0x30,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
jmp    1269 <getarg+0x149>
mov    -0x20(%rbp),%rax
shl    $0xa,%rax
mov    %rax,-0x20(%rbp)
movl   $0x1,-0x24(%rbp)
jmp    1269 <getarg+0x149>
mov    -0x20(%rbp),%rax
shl    $0x14,%rax
mov    %rax,-0x20(%rbp)
movl   $0x1,-0x24(%rbp)
jmp    1269 <getarg+0x149>
mov    -0x20(%rbp),%rax
shl    $0x1e,%rax
mov    %rax,-0x20(%rbp)
movl   $0x1,-0x24(%rbp)
jmp    1269 <getarg+0x149>
mov    -0x20(%rbp),%rax
shl    $0x28,%rax
mov    %rax,-0x20(%rbp)
movl   $0x1,-0x24(%rbp)
jmp    1269 <getarg+0x149>
jmp    127d <getarg+0x15d>
jmp    1194 <getarg+0x74>
mov    -0x10(%rbp),%rax
imul   -0x20(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret
mov    0x2d5c(%rip),%rax
mov    (%rax),%edi
mov    -0x8(%rbp),%rdx
lea    0xe83(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d41(%rip),%rax
mov    (%rax),%edi
lea    0xe7e(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    $0x1,%edi
call   1040 <exit@plt>

x86 assembly (clang, -O2):
<getarg>:
push   %rbx
mov    %rdi,%r8
test   %rdi,%rdi
je     113d <getarg+0x1d>
mov    (%r8),%dl
cmp    $0x2d,%dl
je     1171 <getarg+0x51>
mov    $0x1,%eax
mov    %r8,%rcx
test   %dl,%dl
jne    1180 <getarg+0x60>
mov    0x2e9c(%rip),%rbx
mov    (%rbx),%edi
lea    0xfc7(%rip),%rsi
mov    %r8,%rdx
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xfc6(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    $0x1,%edi
call   1040 <exit@plt>
lea    0x1(%r8),%rcx
mov    0x1(%r8),%dl
mov    $0xffffffffffffffff,%rax
xor    %edi,%edi
test   %dl,%dl
je     11e8 <getarg+0xc8>
add    $0x1,%rcx
lea    0xe6f(%rip),%r9
xor    %esi,%esi
jmp    11a9 <getarg+0x89>
shl    $0x28,%rax
mov    $0x1,%edi
movzbl (%rcx),%edx
add    $0x1,%rcx
test   %dl,%dl
je     11ea <getarg+0xca>
test   %edi,%edi
jne    113d <getarg+0x1d>
lea    -0x30(%rdx),%edi
cmp    $0x44,%dil
ja     113d <getarg+0x1d>
movzbl %dil,%edi
movslq (%r9,%rdi,4),%rdi
add    %r9,%rdi
jmp    *%rdi
movzbl %dl,%edx
lea    (%rsi,%rsi,4),%rsi
lea    (%rdx,%rsi,2),%rsi
add    $0xffffffffffffffd0,%rsi
xor    %edi,%edi
jmp    119e <getarg+0x7e>
shl    $0x1e,%rax
jmp    1199 <getarg+0x79>
shl    $0xa,%rax
jmp    1199 <getarg+0x79>
shl    $0x14,%rax
jmp    1199 <getarg+0x79>
xor    %esi,%esi
imul   %rsi,%rax
pop    %rbx
ret

LLVM IR (-O0):
@stderr = global i32 0
@.str = [18 x i8] c"Unknown arg '%s'\0A\00"
@.str.1 = [17 x i8] c"Use <int>[kmgt]\0A\00"
define i64 @getarg(i8* %0) {
%2 = alloca i8*
%3 = alloca i64
%4 = alloca i8*
%5 = alloca i64
%6 = alloca i32
%7 = alloca i8
store i8* %0, i8** %2
store i64 0, i64* %3
%8 = load i8*, i8** %2
store i8* %8, i8** %4
store i64 1, i64* %5
store i32 0, i32* %6
%9 = load i8*, i8** %4
%10 = icmp eq i8* %9, null
br i1 %10, label %16, label %11
11: ; preds = %1
%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 %17
16: ; preds = %11, %1
br label %64
17: ; preds = %11
%18 = load i8*, i8** %4
%19 = load i8, i8* %18
%20 = sext i8 %19 to i32
%21 = icmp eq i32 %20, 45
br i1 %21, label %22, label %25
22: ; preds = %17
store i64 -1, i64* %5
%23 = load i8*, i8** %4
%24 = getelementptr inbounds i8, i8* %23, i32 1
store i8* %24, i8** %4
br label %25
25: ; preds = %22, %17
br label %26
26: ; preds = %59, %25
%27 = load i8*, i8** %4
%28 = getelementptr inbounds i8, i8* %27, i32 1
store i8* %28, i8** %4
%29 = load i8, i8* %27
store i8 %29, i8* %7
%30 = icmp ne i8 %29, 0
br i1 %30, label %31, label %60
31: ; preds = %26
%32 = load i32, i32* %6
%33 = icmp ne i32 %32, 0
br i1 %33, label %34, label %35
34: ; preds = %31
br label %64
35: ; preds = %31
%36 = load i8, i8* %7
%37 = zext i8 %36 to i32
switch i32 %37, label %58 [
i32 48, label %38
i32 49, label %38
i32 50, label %38
i32 51, label %38
i32 52, label %38
i32 53, label %38
i32 54, label %38
i32 55, label %38
i32 56, label %38
i32 57, label %38
i32 107, label %46
i32 75, label %46
i32 109, label %49
i32 77, label %49
i32 103, label %52
i32 71, label %52
i32 116, label %55
i32 84, label %55
]
38: ; preds = %35, %35, %35, %35, %35, %35, %35, %35, %35, %35
%39 = load i64, i64* %3
%40 = mul nsw i64 %39, 10
%41 = load i8, i8* %7
%42 = zext i8 %41 to i32
%43 = sub nsw i32 %42, 48
%44 = sext i32 %43 to i64
%45 = add nsw i64 %40, %44
store i64 %45, i64* %3
br label %59
46: ; preds = %35, %35
%47 = load i64, i64* %5
%48 = mul nsw i64 %47, 1024
store i64 %48, i64* %5
store i32 1, i32* %6
br label %59
49: ; preds = %35, %35
%50 = load i64, i64* %5
%51 = mul nsw i64 %50, 1048576
store i64 %51, i64* %5
store i32 1, i32* %6
br label %59
52: ; preds = %35, %35
%53 = load i64, i64* %5
%54 = mul nsw i64 %53, 1073741824
store i64 %54, i64* %5
store i32 1, i32* %6
br label %59
55: ; preds = %35, %35
%56 = load i64, i64* %5
%57 = mul nsw i64 %56, 1099511627776
store i64 %57, i64* %5
store i32 1, i32* %6
br label %59
58: ; preds = %35
br label %64
59: ; preds = %55, %52, %49, %46, %38
br label %26
60: ; preds = %26
%61 = load i64, i64* %3
%62 = load i64, i64* %5
%63 = mul nsw i64 %61, %62
ret i64 %63
64: ; preds = %58, %34, %16
%65 = load i32, i32* @stderr
%66 = load i8*, i8** %2
%67 = call i32 (i32, i8*, ...) @fprintf(i32 %65, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0), i8* %66)
%68 = load i32, i32* @stderr
%69 = call i32 (i32, i8*, ...) @fprintf(i32 %68, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.1, i64 0, i64 0))
%70 = call i32 @exit(i32 1)
unreachable
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [18 x i8] c"Unknown arg '%s'\0A\00"
@.str.1 = [17 x i8] c"Use <int>[kmgt]\0A\00"
define i64 @getarg(i8* %0) {
%2 = icmp eq i8* %0, null
br i1 %2, label %45, label %3
3: ; preds = %1
%4 = load i8, i8* %0
switch i8 %4, label %8 [
i8 0, label %45
i8 45, label %5
]
5: ; preds = %3
%6 = getelementptr inbounds i8, i8* %0, i64 1
%7 = load i8, i8* %6
br label %8
8: ; preds = %3, %5
%9 = phi i8 [ %7, %5 ], [ %4, %3 ]
%10 = phi i8* [ %6, %5 ], [ %0, %3 ]
%11 = phi i64 [ -1, %5 ], [ 1, %3 ]
%12 = icmp eq i8 %9, 0
br i1 %12, label %41, label %13
13: ; preds = %8, %35
%14 = phi i8 [ %39, %35 ], [ %9, %8 ]
%15 = phi i8* [ %19, %35 ], [ %10, %8 ]
%16 = phi i64 [ %38, %35 ], [ 0, %8 ]
%17 = phi i32 [ %37, %35 ], [ 0, %8 ]
%18 = phi i64 [ %36, %35 ], [ %11, %8 ]
%19 = getelementptr inbounds i8, i8* %15, i64 1
%20 = icmp eq i32 %17, 0
br i1 %20, label %21, label %45
21: ; preds = %13
switch i8 %14, label %45 [
i8 48, label %22
i8 49, label %22
i8 50, label %22
i8 51, label %22
i8 52, label %22
i8 53, label %22
i8 54, label %22
i8 55, label %22
i8 56, label %22
i8 57, label %22
i8 107, label %27
i8 75, label %27
i8 109, label %29
i8 77, label %29
i8 103, label %31
i8 71, label %31
i8 116, label %33
i8 84, label %33
]
22: ; preds = %21, %21, %21, %21, %21, %21, %21, %21, %21, %21
%23 = zext i8 %14 to i64
%24 = mul nsw i64 %16, 10
%25 = add i64 %24, -48
%26 = add i64 %25, %23
br label %35
27: ; preds = %21, %21
%28 = shl nsw i64 %18, 10
br label %35
29: ; preds = %21, %21
%30 = shl nsw i64 %18, 20
br label %35
31: ; preds = %21, %21
%32 = shl nsw i64 %18, 30
br label %35
33: ; preds = %21, %21
%34 = shl nsw i64 %18, 40
br label %35
35: ; preds = %33, %31, %29, %27, %22
%36 = phi i64 [ %34, %33 ], [ %32, %31 ], [ %30, %29 ], [ %28, %27 ], [ %18, %22 ]
%37 = phi i32 [ 1, %33 ], [ 1, %31 ], [ 1, %29 ], [ 1, %27 ], [ 0, %22 ]
%38 = phi i64 [ %16, %33 ], [ %16, %31 ], [ %16, %29 ], [ %16, %27 ], [ %26, %22 ]
%39 = load i8, i8* %19
%40 = icmp eq i8 %39, 0
br i1 %40, label %41, label %13
41: ; preds = %35, %8
%42 = phi i64 [ %11, %8 ], [ %36, %35 ]
%43 = phi i64 [ 0, %8 ], [ %38, %35 ]
%44 = mul nsw i64 %43, %42
ret i64 %44
45: ; preds = %21, %13, %3, %1
%46 = load i32, i32* @stderr
%47 = tail call i32 (i32, i8*, ...) @fprintf(i32 %46, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0), i8* %0)
%48 = load i32, i32* @stderr
%49 = tail call i32 (i32, i8*, ...) @fprintf(i32 %48, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.1, i64 0, i64 0))
%50 = tail call i32 @exit(i32 1)
unreachable
}