long unsigned int convertsizetolong(char *sizestr) {
  long unsigned int answer = 0;
  int i = 0;
  while (sizestr[i] != '\0') {
    if (sizestr[i] == '0')
      answer *= 10;
    if (sizestr[i] >= '1' && sizestr[i] <= '9') {
      answer *= 10;
      answer += (sizestr[i] - '1' + 1);
    }
    if (sizestr[i] == 'k' || sizestr[i] == 'K')
      answer *= 1024;
    if (sizestr[i] == 'm' || sizestr[i] == 'M')
      answer *= (1024 * 1024);
    if (sizestr[i] == 'g' || sizestr[i] == 'G')
      answer *= (1024 * 1024 * 1024);
    i++;
  }
  return answer;
}


x86 assembly (clang, -O0):
<convertsizetolong>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movq   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1249 <convertsizetolong+0x149>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jne    114a <convertsizetolong+0x4a>
imul   $0xa,-0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x31,%eax
jl     1199 <convertsizetolong+0x99>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
jg     1199 <convertsizetolong+0x99>
imul   $0xa,-0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x31,%eax
add    $0x1,%eax
cltq
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x6b,%eax
je     11c3 <convertsizetolong+0xc3>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4b,%eax
jne    11cf <convertsizetolong+0xcf>
mov    -0x10(%rbp),%rax
shl    $0xa,%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x6d,%eax
je     11f9 <convertsizetolong+0xf9>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4d,%eax
jne    1205 <convertsizetolong+0x105>
mov    -0x10(%rbp),%rax
shl    $0x14,%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x67,%eax
je     122f <convertsizetolong+0x12f>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x47,%eax
jne    123b <convertsizetolong+0x13b>
mov    -0x10(%rbp),%rax
shl    $0x1e,%rax
mov    %rax,-0x10(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1117 <convertsizetolong+0x17>
mov    -0x10(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<convertsizetolong>:
xor    %eax,%eax
jmp    111e <convertsizetolong+0x1e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    %rax,%rax
lea    (%rax,%rax,4),%rdx
add    $0x1,%rdi
mov    %rdx,%rax
movsbq (%rdi),%rcx
cmp    $0x30,%rcx
je     1110 <convertsizetolong+0x10>
test   %cl,%cl
je     1167 <convertsizetolong+0x67>
lea    -0x31(%rcx),%edx
lea    -0x30(%rcx),%esi
cmp    $0x9,%dl
lea    (%rax,%rax,4),%rdx
lea    (%rsi,%rdx,2),%rdx
cmovae %rax,%rdx
mov    %ecx,%eax
or     $0x20,%al
cmp    $0x6b,%al
jne    114d <convertsizetolong+0x4d>
shl    $0xa,%rdx
mov    %ecx,%eax
or     $0x20,%al
cmp    $0x6d,%al
jne    1159 <convertsizetolong+0x59>
shl    $0x14,%rdx
or     $0x20,%cl
cmp    $0x67,%cl
jne    1117 <convertsizetolong+0x17>
shl    $0x1e,%rdx
jmp    1117 <convertsizetolong+0x17>
ret

LLVM IR (-O0):
define i64 @convertsizetolong(i8* %0) {
%2 = alloca i8*
%3 = alloca i64
%4 = alloca i32
store i8* %0, i8** %2
store i64 0, i64* %3
store i32 0, i32* %4
br label %5
5: ; preds = %111, %1
%6 = load i8*, i8** %2
%7 = load i32, i32* %4
%8 = sext i32 %7 to i64
%9 = getelementptr inbounds i8, i8* %6, i64 %8
%10 = load i8, i8* %9
%11 = sext i8 %10 to i32
%12 = icmp ne i32 %11, 0
br i1 %12, label %13, label %114
13: ; preds = %5
%14 = load i8*, i8** %2
%15 = load i32, i32* %4
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds i8, i8* %14, i64 %16
%18 = load i8, i8* %17
%19 = sext i8 %18 to i32
%20 = icmp eq i32 %19, 48
br i1 %20, label %21, label %24
21: ; preds = %13
%22 = load i64, i64* %3
%23 = mul i64 %22, 10
store i64 %23, i64* %3
br label %24
24: ; preds = %21, %13
%25 = load i8*, i8** %2
%26 = load i32, i32* %4
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds i8, i8* %25, i64 %27
%29 = load i8, i8* %28
%30 = sext i8 %29 to i32
%31 = icmp sge i32 %30, 49
br i1 %31, label %32, label %54
32: ; preds = %24
%33 = load i8*, i8** %2
%34 = load i32, i32* %4
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds i8, i8* %33, i64 %35
%37 = load i8, i8* %36
%38 = sext i8 %37 to i32
%39 = icmp sle i32 %38, 57
br i1 %39, label %40, label %54
40: ; preds = %32
%41 = load i64, i64* %3
%42 = mul i64 %41, 10
store i64 %42, i64* %3
%43 = load i8*, i8** %2
%44 = load i32, i32* %4
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i8, i8* %43, i64 %45
%47 = load i8, i8* %46
%48 = sext i8 %47 to i32
%49 = sub nsw i32 %48, 49
%50 = add nsw i32 %49, 1
%51 = sext i32 %50 to i64
%52 = load i64, i64* %3
%53 = add i64 %52, %51
store i64 %53, i64* %3
br label %54
54: ; preds = %40, %32, %24
%55 = load i8*, i8** %2
%56 = load i32, i32* %4
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds i8, i8* %55, i64 %57
%59 = load i8, i8* %58
%60 = sext i8 %59 to i32
%61 = icmp eq i32 %60, 107
br i1 %61, label %70, label %62
62: ; preds = %54
%63 = load i8*, i8** %2
%64 = load i32, i32* %4
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds i8, i8* %63, i64 %65
%67 = load i8, i8* %66
%68 = sext i8 %67 to i32
%69 = icmp eq i32 %68, 75
br i1 %69, label %70, label %73
70: ; preds = %62, %54
%71 = load i64, i64* %3
%72 = mul i64 %71, 1024
store i64 %72, i64* %3
br label %73
73: ; preds = %70, %62
%74 = load i8*, i8** %2
%75 = load i32, i32* %4
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds i8, i8* %74, i64 %76
%78 = load i8, i8* %77
%79 = sext i8 %78 to i32
%80 = icmp eq i32 %79, 109
br i1 %80, label %89, label %81
81: ; preds = %73
%82 = load i8*, i8** %2
%83 = load i32, i32* %4
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i8, i8* %82, i64 %84
%86 = load i8, i8* %85
%87 = sext i8 %86 to i32
%88 = icmp eq i32 %87, 77
br i1 %88, label %89, label %92
89: ; preds = %81, %73
%90 = load i64, i64* %3
%91 = mul i64 %90, 1048576
store i64 %91, i64* %3
br label %92
92: ; preds = %89, %81
%93 = load i8*, i8** %2
%94 = load i32, i32* %4
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds i8, i8* %93, i64 %95
%97 = load i8, i8* %96
%98 = sext i8 %97 to i32
%99 = icmp eq i32 %98, 103
br i1 %99, label %108, label %100
100: ; preds = %92
%101 = load i8*, i8** %2
%102 = load i32, i32* %4
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds i8, i8* %101, i64 %103
%105 = load i8, i8* %104
%106 = sext i8 %105 to i32
%107 = icmp eq i32 %106, 71
br i1 %107, label %108, label %111
108: ; preds = %100, %92
%109 = load i64, i64* %3
%110 = mul i64 %109, 1073741824
store i64 %110, i64* %3
br label %111
111: ; preds = %108, %100
%112 = load i32, i32* %4
%113 = add nsw i32 %112, 1
store i32 %113, i32* %4
br label %5
114: ; preds = %5
%115 = load i64, i64* %3
ret i64 %115
}

LLVM IR (-O2):
define i64 @convertsizetolong(i8* nocapture %0) {
br label %2
2: ; preds = %28, %1
%3 = phi i64 [ %30, %28 ], [ 0, %1 ]
%4 = phi i64 [ %29, %28 ], [ 0, %1 ]
%5 = getelementptr inbounds i8, i8* %0, i64 %3
%6 = load i8, i8* %5
switch i8 %6, label %9 [
i8 0, label %31
i8 48, label %7
]
7: ; preds = %2
%8 = mul i64 %4, 10
br label %28
9: ; preds = %2
%10 = sext i8 %6 to i64
%11 = add i8 %6, -49
%12 = icmp ult i8 %11, 9
%13 = mul i64 %4, 10
%14 = add nsw i64 %10, 4294967248
%15 = and i64 %14, 4294967295
%16 = add i64 %15, %13
%17 = select i1 %12, i64 %16, i64 %4
switch i8 %6, label %20 [
i8 107, label %18
i8 75, label %18
]
18: ; preds = %9, %9
%19 = shl i64 %17, 10
br label %20
20: ; preds = %9, %18
%21 = phi i64 [ %19, %18 ], [ %17, %9 ]
switch i8 %6, label %24 [
i8 109, label %22
i8 77, label %22
]
22: ; preds = %20, %20
%23 = shl i64 %21, 20
br label %24
24: ; preds = %20, %22
%25 = phi i64 [ %23, %22 ], [ %21, %20 ]
switch i8 %6, label %28 [
i8 103, label %26
i8 71, label %26
]
26: ; preds = %24, %24
%27 = shl i64 %25, 30
br label %28
28: ; preds = %7, %24, %26
%29 = phi i64 [ %27, %26 ], [ %25, %24 ], [ %8, %7 ]
%30 = add nuw i64 %3, 1
br label %2
31: ; preds = %2
ret i64 %4
}