#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 */
typedef struct TYPE_3__ TYPE_1__;

/* Type definitions */
struct TYPE_3__ {
  scalar_t__ *__bits;
};
typedef TYPE_1__ cpu_set_t;
typedef scalar_t__ __cpu_mask;

/* Variables and functions */
size_t __CPUELT(size_t);
scalar_t__ __CPUMASK(size_t);
char char_to_val(char const);
int /*<<< orphan*/ memcmp(char const *, char *, long);
int strlen(char const *);
int cpumask_parse(const char *str, cpu_set_t *set, size_t setsize) {
  int len = strlen(str);
  const char *ptr = str + len - 1;
  int cpu = 0;
  if (len > 1 && !memcmp(str, "0x", 2L))
    str += 2;
  do {
    size_t __i;
    size_t __imax = (setsize) / sizeof(__cpu_mask);
    __cpu_mask *__bits = (set)->__bits;
    for (__i = 0; __i < __imax; ++__i)
      __bits[__i] = 0;
  } while (0);
  while (ptr >= str) {
    char val;
    if (*ptr == ',')
      ptr--;
    val = char_to_val(*ptr);
    if (val == (char)-1)
      return -1;
    if (val & 1)
      ({
        size_t __cpu = (cpu);
        __cpu < 8 * (setsize)
            ? (((__cpu_mask *)((set)->__bits))[__CPUELT(__cpu)] |=
               __CPUMASK(__cpu))
            : 0;
      });
    if (val & 2)
      ({
        size_t __cpu = (cpu + 1);
        __cpu < 8 * (setsize)
            ? (((__cpu_mask *)((set)->__bits))[__CPUELT(__cpu)] |=
               __CPUMASK(__cpu))
            : 0;
      });
    if (val & 4)
      ({
        size_t __cpu = (cpu + 2);
        __cpu < 8 * (setsize)
            ? (((__cpu_mask *)((set)->__bits))[__CPUELT(__cpu)] |=
               __CPUMASK(__cpu))
            : 0;
      });
    if (val & 8)
      ({
        size_t __cpu = (cpu + 3);
        __cpu < 8 * (setsize)
            ? (((__cpu_mask *)((set)->__bits))[__CPUELT(__cpu)] |=
               __CPUMASK(__cpu))
            : 0;
      });
    len--;
    ptr--;
    cpu += 4;
  }
  return 0;
}


x86 assembly (clang, -O0):
<cpumask_parse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
add    %rcx,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x1,-0x24(%rbp)
jle    11ae <cpumask_parse+0x6e>
mov    -0x10(%rbp),%rax
movzwl (%rax),%eax
sub    $0x7830,%eax
setne  %al
movzbl %al,%eax
cmp    $0x0,%eax
jne    11ae <cpumask_parse+0x6e>
mov    -0x10(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x10(%rbp)
jmp    11b3 <cpumask_parse+0x73>
mov    -0x20(%rbp),%rax
shr    $0x3,%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x50(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1201 <cpumask_parse+0xc1>
mov    -0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    11d2 <cpumask_parse+0x92>
jmp    1206 <cpumask_parse+0xc6>
jmp    120b <cpumask_parse+0xcb>
mov    -0x30(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     14e6 <cpumask_parse+0x3a6>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2c,%eax
jne    1235 <cpumask_parse+0xf5>
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1030 <char_to_val@plt>
mov    %al,-0x51(%rbp)
movsbl -0x51(%rbp),%eax
cmp    $0xffffffff,%eax
jne    125d <cpumask_parse+0x11d>
movl   $0xffffffff,-0x4(%rbp)
jmp    14ed <cpumask_parse+0x3ad>
movsbl -0x51(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     12ef <cpumask_parse+0x1af>
movslq -0x34(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x3,%rcx
cmp    %rcx,%rax
jae    12d6 <cpumask_parse+0x196>
mov    -0x60(%rbp),%rdi
call   1050 <__CPUMASK@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x60(%rbp),%rdi
call   1060 <__CPUELT@plt>
mov    -0xb0(%rbp),%rcx
mov    %rax,%rdx
mov    -0xa8(%rbp),%rax
or     (%rcx,%rdx,8),%rax
mov    %rax,(%rcx,%rdx,8)
mov    %rax,-0xa0(%rbp)
jmp    12e4 <cpumask_parse+0x1a4>
xor    %eax,%eax
mov    %rax,-0xa0(%rbp)
jmp    12e4 <cpumask_parse+0x1a4>
mov    -0xa0(%rbp),%rax
mov    %rax,-0x68(%rbp)
movsbl -0x51(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     1385 <cpumask_parse+0x245>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
cltq
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x3,%rcx
cmp    %rcx,%rax
jae    136c <cpumask_parse+0x22c>
mov    -0x70(%rbp),%rdi
call   1050 <__CPUMASK@plt>
mov    %rax,-0xc0(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x70(%rbp),%rdi
call   1060 <__CPUELT@plt>
mov    -0xc8(%rbp),%rcx
mov    %rax,%rdx
mov    -0xc0(%rbp),%rax
or     (%rcx,%rdx,8),%rax
mov    %rax,(%rcx,%rdx,8)
mov    %rax,-0xb8(%rbp)
jmp    137a <cpumask_parse+0x23a>
xor    %eax,%eax
mov    %rax,-0xb8(%rbp)
jmp    137a <cpumask_parse+0x23a>
mov    -0xb8(%rbp),%rax
mov    %rax,-0x78(%rbp)
movsbl -0x51(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     141e <cpumask_parse+0x2de>
mov    -0x34(%rbp),%eax
add    $0x2,%eax
cltq
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x3,%rcx
cmp    %rcx,%rax
jae    1402 <cpumask_parse+0x2c2>
mov    -0x80(%rbp),%rdi
call   1050 <__CPUMASK@plt>
mov    %rax,-0xd8(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x80(%rbp),%rdi
call   1060 <__CPUELT@plt>
mov    -0xe0(%rbp),%rcx
mov    %rax,%rdx
mov    -0xd8(%rbp),%rax
or     (%rcx,%rdx,8),%rax
mov    %rax,(%rcx,%rdx,8)
mov    %rax,-0xd0(%rbp)
jmp    1410 <cpumask_parse+0x2d0>
xor    %eax,%eax
mov    %rax,-0xd0(%rbp)
jmp    1410 <cpumask_parse+0x2d0>
mov    -0xd0(%rbp),%rax
mov    %rax,-0x88(%rbp)
movsbl -0x51(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     14c3 <cpumask_parse+0x383>
mov    -0x34(%rbp),%eax
add    $0x3,%eax
cltq
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x3,%rcx
cmp    %rcx,%rax
jae    14a7 <cpumask_parse+0x367>
mov    -0x90(%rbp),%rdi
call   1050 <__CPUMASK@plt>
mov    %rax,-0xf0(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xf8(%rbp)
mov    -0x90(%rbp),%rdi
call   1060 <__CPUELT@plt>
mov    -0xf8(%rbp),%rcx
mov    %rax,%rdx
mov    -0xf0(%rbp),%rax
or     (%rcx,%rdx,8),%rax
mov    %rax,(%rcx,%rdx,8)
mov    %rax,-0xe8(%rbp)
jmp    14b5 <cpumask_parse+0x375>
xor    %eax,%eax
mov    %rax,-0xe8(%rbp)
jmp    14b5 <cpumask_parse+0x375>
mov    -0xe8(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
mov    -0x34(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x34(%rbp)
jmp    120b <cpumask_parse+0xcb>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cpumask_parse>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdx,%r15
mov    %rsi,(%rsp)
mov    %rdi,%r12
call   1040 <strlen@plt>
cltq
mov    %r12,0x8(%rsp)
cmp    $0x2,%eax
jl     1192 <cpumask_parse+0x42>
movzwl (%r12),%ecx
xor    %edx,%edx
cmp    $0x7830,%ecx
sete   %dl
lea    (%r12,%rdx,2),%rcx
mov    %rcx,0x8(%rsp)
add    %rax,%r12
cmp    $0x8,%r15
jb     11b0 <cpumask_parse+0x60>
mov    (%rsp),%rax
mov    (%rax),%rdi
mov    %r15,%rdx
and    $0xfffffffffffffff8,%rdx
xor    %esi,%esi
call   1050 <memset@plt>
lea    -0x1(%r12),%rcx
xor    %eax,%eax
cmp    0x8(%rsp),%rcx
jb     12e5 <cpumask_parse+0x195>
shl    $0x3,%r15
xor    %r13d,%r13d
mov    %r15,0x10(%rsp)
jmp    11e4 <cpumask_parse+0x94>
add    $0x4,%r13
lea    -0x1(%r12),%rcx
cmp    0x8(%rsp),%rcx
jb     12dc <cpumask_parse+0x18c>
cmpb   $0x2c,-0x1(%r12)
je     1200 <cpumask_parse+0xb0>
mov    %rcx,%r12
jmp    1204 <cpumask_parse+0xb4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0xfffffffffffffffe,%r12
movsbl (%r12),%edi
call   1030 <char_to_val@plt>
cmp    $0xff,%al
je     12e0 <cpumask_parse+0x190>
mov    %eax,%ebx
test   $0x1,%al
je     1240 <cpumask_parse+0xf0>
cmp    %r13,%r15
jbe    1240 <cpumask_parse+0xf0>
mov    %r13,%rdi
call   1060 <__CPUMASK@plt>
mov    %rax,%r14
mov    (%rsp),%rax
mov    (%rax),%rbp
mov    %r13,%rdi
call   1070 <__CPUELT@plt>
or     %r14,0x0(%rbp,%rax,8)
test   $0x2,%bl
je     1271 <cpumask_parse+0x121>
lea    0x1(%r13),%rbp
cmp    %rbp,%r15
jbe    1271 <cpumask_parse+0x121>
mov    %rbp,%rdi
call   1060 <__CPUMASK@plt>
mov    %rax,%r14
mov    (%rsp),%rax
mov    (%rax),%r15
mov    %rbp,%rdi
call   1070 <__CPUELT@plt>
or     %r14,(%r15,%rax,8)
mov    0x10(%rsp),%r15
test   $0x4,%bl
je     12a2 <cpumask_parse+0x152>
lea    0x2(%r13),%rbp
cmp    %rbp,%r15
jbe    12a2 <cpumask_parse+0x152>
mov    %rbp,%rdi
call   1060 <__CPUMASK@plt>
mov    %rax,%r14
mov    (%rsp),%rax
mov    (%rax),%r15
mov    %rbp,%rdi
call   1070 <__CPUELT@plt>
or     %r14,(%r15,%rax,8)
mov    0x10(%rsp),%r15
test   $0x8,%bl
je     11d0 <cpumask_parse+0x80>
lea    0x3(%r13),%rbx
cmp    %rbx,%r15
jbe    11d0 <cpumask_parse+0x80>
mov    %rbx,%rdi
call   1060 <__CPUMASK@plt>
mov    %rax,%r14
mov    (%rsp),%rax
mov    (%rax),%rbp
mov    %rbx,%rdi
call   1070 <__CPUELT@plt>
or     %r14,0x0(%rbp,%rax,8)
jmp    11d0 <cpumask_parse+0x80>
xor    %eax,%eax
jmp    12e5 <cpumask_parse+0x195>
mov    $0xffffffff,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
%struct.TYPE_3__ = type { i64* }
@.str = [3 x i8] c"0x\00"
define i32 @cpumask_parse(i8* %0, %struct.TYPE_3__* nocapture %1, i64 %2) {
%4 = tail call i32 @strlen(i8* %0)
%5 = sext i32 %4 to i64
%6 = getelementptr inbounds i8, i8* %0, i64 %5
%7 = icmp sgt i32 %4, 1
br i1 %7, label %8, label %13
8: ; preds = %3
%9 = tail call i32 @bcmp(i8* dereferenceable(2) %0, i8* dereferenceable(2) getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i64 2)
%10 = icmp eq i32 %9, 0
%11 = select i1 %10, i64 2, i64 0
%12 = getelementptr i8, i8* %0, i64 %11
br label %13
13: ; preds = %8, %3
%14 = phi i8* [ %0, %3 ], [ %12, %8 ]
%15 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %1, i64 0, i32 0
%16 = icmp ult i64 %2, 8
br i1 %16, label %21, label %17
17: ; preds = %13
%18 = bitcast %struct.TYPE_3__* %1 to i8**
%19 = load i8*, i8** %18
%20 = and i64 %2, -8
br label %21
21: ; preds = %17, %13
%22 = getelementptr inbounds i8, i8* %6, i64 -1
%23 = icmp ult i8* %22, %14
br i1 %23, label %93, label %24
24: ; preds = %21
%25 = shl i64 %2, 3
br label %26
26: ; preds = %24, %89
%27 = phi i64 [ 0, %24 ], [ %90, %89 ]
%28 = phi i8* [ %22, %24 ], [ %91, %89 ]
%29 = phi i8* [ %6, %24 ], [ %33, %89 ]
%30 = load i8, i8* %28
%31 = icmp eq i8 %30, 44
%32 = getelementptr inbounds i8, i8* %29, i64 -2
%33 = select i1 %31, i8* %32, i8* %28
%34 = load i8, i8* %33
%35 = tail call signext i8 @char_to_val(i8 signext %34)
%36 = zext i8 %35 to i32
%37 = icmp eq i8 %35, -1
br i1 %37, label %93, label %38
38: ; preds = %26
%39 = and i32 %36, 1
%40 = icmp ne i32 %39, 0
%41 = icmp ugt i64 %25, %27
%42 = select i1 %40, i1 %41, i1 false
br i1 %42, label %43, label %50
43: ; preds = %38
%44 = tail call i64 @__CPUMASK(i64 %27)
%45 = load i64*, i64** %15
%46 = tail call i64 @__CPUELT(i64 %27)
%47 = getelementptr inbounds i64, i64* %45, i64 %46
%48 = load i64, i64* %47
%49 = or i64 %48, %44
store i64 %49, i64* %47
br label %50
50: ; preds = %43, %38
%51 = and i32 %36, 2
%52 = icmp eq i32 %51, 0
br i1 %52, label %63, label %53
53: ; preds = %50
%54 = or i64 %27, 1
%55 = icmp ugt i64 %25, %54
br i1 %55, label %56, label %63
56: ; preds = %53
%57 = tail call i64 @__CPUMASK(i64 %54)
%58 = load i64*, i64** %15
%59 = tail call i64 @__CPUELT(i64 %54)
%60 = getelementptr inbounds i64, i64* %58, i64 %59
%61 = load i64, i64* %60
%62 = or i64 %61, %57
store i64 %62, i64* %60
br label %63
63: ; preds = %56, %53, %50
%64 = and i32 %36, 4
%65 = icmp eq i32 %64, 0
br i1 %65, label %76, label %66
66: ; preds = %63
%67 = or i64 %27, 2
%68 = icmp ugt i64 %25, %67
br i1 %68, label %69, label %76
69: ; preds = %66
%70 = tail call i64 @__CPUMASK(i64 %67)
%71 = load i64*, i64** %15
%72 = tail call i64 @__CPUELT(i64 %67)
%73 = getelementptr inbounds i64, i64* %71, i64 %72
%74 = load i64, i64* %73
%75 = or i64 %74, %70
store i64 %75, i64* %73
br label %76
76: ; preds = %69, %66, %63
%77 = and i32 %36, 8
%78 = icmp eq i32 %77, 0
br i1 %78, label %89, label %79
79: ; preds = %76
%80 = or i64 %27, 3
%81 = icmp ugt i64 %25, %80
br i1 %81, label %82, label %89
82: ; preds = %79
%83 = tail call i64 @__CPUMASK(i64 %80)
%84 = load i64*, i64** %15
%85 = tail call i64 @__CPUELT(i64 %80)
%86 = getelementptr inbounds i64, i64* %84, i64 %85
%87 = load i64, i64* %86
%88 = or i64 %87, %83
store i64 %88, i64* %86
br label %89
89: ; preds = %76, %79, %82
%90 = add nuw i64 %27, 4
%91 = getelementptr inbounds i8, i8* %33, i64 -1
%92 = icmp ult i8* %91, %14
br i1 %92, label %93, label %26
93: ; preds = %89, %26, %21
%94 = phi i32 [ 0, %21 ], [ -1, %26 ], [ 0, %89 ]
ret i32 %94
}