#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 */
unsigned long MADV_DONTFORK;
unsigned long MADV_MERGEABLE;
unsigned long MADV_RANDOM;
unsigned long MADV_SEQUENTIAL;
unsigned long MAP_GROWSDOWN;
unsigned long MAP_LOCKED;
unsigned long MAP_NORESERVE;
char *strtok(char *, char *);
void parse_vmflags(char *buf, unsigned long *flags, unsigned long *madv) {
  char *tok;
  if (!buf[0])
    return;
  tok = strtok(buf, " \n");
  if (!tok)
    return;
  do {
    if ((tok[0] == "gd"[0] && tok[1] == "gd"[1]))
      *flags |= MAP_GROWSDOWN;
    else if ((tok[0] == "lo"[0] && tok[1] == "lo"[1]))
      *flags |= MAP_LOCKED;
    else if ((tok[0] == "nr"[0] && tok[1] == "nr"[1]))
      *flags |= MAP_NORESERVE;
    else if ((tok[0] == "ht"[0] && tok[1] == "ht"[1]))
      *flags |= 0x40000;
    if ((tok[0] == "sr"[0] && tok[1] == "sr"[1]))
      *madv |= (1ul << MADV_SEQUENTIAL);
    else if ((tok[0] == "rr"[0] && tok[1] == "rr"[1]))
      *madv |= (1ul << MADV_RANDOM);
    else if ((tok[0] == "dc"[0] && tok[1] == "dc"[1]))
      *madv |= (1ul << MADV_DONTFORK);
    else if ((tok[0] == "dd"[0] && tok[1] == "dd"[1]))
      *madv |= (1ul << 16);
    else if ((tok[0] == "mg"[0] && tok[1] == "mg"[1]))
      *madv |= (1ul << MADV_MERGEABLE);
    else if ((tok[0] == "hg"[0] && tok[1] == "hg"[1]))
      *madv |= (1ul << 14);
    else if ((tok[0] == "nh"[0] && tok[1] == "nh"[1]))
      *madv |= (1ul << 15);
  } while ((tok = strtok(NULL, " \n")));
}


x86 assembly (clang, -O0):
<parse_vmflags>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
cmpb   $0x0,(%rax)
jne    1136 <parse_vmflags+0x26>
jmp    14c7 <parse_vmflags+0x3b7>
mov    -0x8(%rbp),%rdi
lea    0xebf(%rip),%rsi
call   1030 <strtok@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    115a <parse_vmflags+0x4a>
jmp    14c7 <parse_vmflags+0x3b7>
jmp    115f <parse_vmflags+0x4f>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xe96(%rip),%ecx
cmp    %ecx,%eax
jne    11a5 <parse_vmflags+0x95>
mov    -0x20(%rbp),%rax
movsbl 0x1(%rax),%eax
movsbl 0xe80(%rip),%ecx
cmp    %ecx,%eax
jne    11a5 <parse_vmflags+0x95>
mov    0x2e25(%rip),%rax
mov    (%rax),%rcx
mov    -0x10(%rbp),%rax
or     (%rax),%rcx
mov    %rcx,(%rax)
jmp    127e <parse_vmflags+0x16e>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xe53(%rip),%ecx
cmp    %ecx,%eax
jne    11eb <parse_vmflags+0xdb>
mov    -0x20(%rbp),%rax
movsbl 0x1(%rax),%eax
movsbl 0xe3d(%rip),%ecx
cmp    %ecx,%eax
jne    11eb <parse_vmflags+0xdb>
mov    0x2dff(%rip),%rax
mov    (%rax),%rcx
mov    -0x10(%rbp),%rax
or     (%rax),%rcx
mov    %rcx,(%rax)
jmp    1279 <parse_vmflags+0x169>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xe10(%rip),%ecx
cmp    %ecx,%eax
jne    1231 <parse_vmflags+0x121>
mov    -0x20(%rbp),%rax
movsbl 0x1(%rax),%eax
movsbl 0xdfa(%rip),%ecx
cmp    %ecx,%eax
jne    1231 <parse_vmflags+0x121>
mov    0x2dc9(%rip),%rax
mov    (%rax),%rcx
mov    -0x10(%rbp),%rax
or     (%rax),%rcx
mov    %rcx,(%rax)
jmp    1274 <parse_vmflags+0x164>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xdcd(%rip),%ecx
cmp    %ecx,%eax
jne    126f <parse_vmflags+0x15f>
mov    -0x20(%rbp),%rax
movsbl 0x1(%rax),%eax
movsbl 0xdb7(%rip),%ecx
cmp    %ecx,%eax
jne    126f <parse_vmflags+0x15f>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
or     $0x40000,%rcx
mov    %rcx,(%rax)
jmp    1274 <parse_vmflags+0x164>
jmp    1279 <parse_vmflags+0x169>
jmp    127e <parse_vmflags+0x16e>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xd83(%rip),%ecx
cmp    %ecx,%eax
jne    12cf <parse_vmflags+0x1bf>
mov    -0x20(%rbp),%rax
movsbl 0x1(%rax),%eax
movsbl 0xd6d(%rip),%ecx
cmp    %ecx,%eax
jne    12cf <parse_vmflags+0x1bf>
mov    0x2cf6(%rip),%rax
mov    (%rax),%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
or     (%rax),%rcx
mov    %rcx,(%rax)
jmp    14a4 <parse_vmflags+0x394>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xd35(%rip),%ecx
cmp    %ecx,%eax
jne    1320 <parse_vmflags+0x210>
mov    -0x20(%rbp),%rax
movsbl 0x1(%rax),%eax
movsbl 0xd1f(%rip),%ecx
cmp    %ecx,%eax
jne    1320 <parse_vmflags+0x210>
mov    0x2cc5(%rip),%rax
mov    (%rax),%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
or     (%rax),%rcx
mov    %rcx,(%rax)
jmp    149f <parse_vmflags+0x38f>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xce7(%rip),%ecx
cmp    %ecx,%eax
jne    1371 <parse_vmflags+0x261>
mov    -0x20(%rbp),%rax
movsbl 0x1(%rax),%eax
movsbl 0xcd1(%rip),%ecx
cmp    %ecx,%eax
jne    1371 <parse_vmflags+0x261>
mov    0x2c7c(%rip),%rax
mov    (%rax),%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
or     (%rax),%rcx
mov    %rcx,(%rax)
jmp    149a <parse_vmflags+0x38a>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xc99(%rip),%ecx
cmp    %ecx,%eax
jne    13b4 <parse_vmflags+0x2a4>
mov    -0x20(%rbp),%rax
movsbl 0x1(%rax),%eax
movsbl 0xc83(%rip),%ecx
cmp    %ecx,%eax
jne    13b4 <parse_vmflags+0x2a4>
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
or     $0x10000,%rcx
mov    %rcx,(%rax)
jmp    1495 <parse_vmflags+0x385>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xc59(%rip),%ecx
cmp    %ecx,%eax
jne    1405 <parse_vmflags+0x2f5>
mov    -0x20(%rbp),%rax
movsbl 0x1(%rax),%eax
movsbl 0xc43(%rip),%ecx
cmp    %ecx,%eax
jne    1405 <parse_vmflags+0x2f5>
mov    0x2bd8(%rip),%rax
mov    (%rax),%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
or     (%rax),%rcx
mov    %rcx,(%rax)
jmp    1490 <parse_vmflags+0x380>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xc0b(%rip),%ecx
cmp    %ecx,%eax
jne    1448 <parse_vmflags+0x338>
mov    -0x20(%rbp),%rax
movsbl 0x1(%rax),%eax
movsbl 0xbf5(%rip),%ecx
cmp    %ecx,%eax
jne    1448 <parse_vmflags+0x338>
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
or     $0x4000,%rcx
mov    %rcx,(%rax)
jmp    148b <parse_vmflags+0x37b>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xbcb(%rip),%ecx
cmp    %ecx,%eax
jne    1486 <parse_vmflags+0x376>
mov    -0x20(%rbp),%rax
movsbl 0x1(%rax),%eax
movsbl 0xbb5(%rip),%ecx
cmp    %ecx,%eax
jne    1486 <parse_vmflags+0x376>
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
or     $0x8000,%rcx
mov    %rcx,(%rax)
jmp    148b <parse_vmflags+0x37b>
jmp    1490 <parse_vmflags+0x380>
jmp    1495 <parse_vmflags+0x385>
jmp    149a <parse_vmflags+0x38a>
jmp    149f <parse_vmflags+0x38f>
jmp    14a4 <parse_vmflags+0x394>
jmp    14a9 <parse_vmflags+0x399>
xor    %eax,%eax
mov    %eax,%edi
lea    0xb4c(%rip),%rsi
call   1030 <strtok@plt>
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
jne    115f <parse_vmflags+0x4f>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parse_vmflags>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
cmpb   $0x0,(%rdi)
je     1291 <parse_vmflags+0x181>
mov    %rdx,%r14
mov    %rsi,%r15
lea    0xf2f(%rip),%rsi
call   1030 <strtok@plt>
test   %rax,%rax
je     1291 <parse_vmflags+0x181>
lea    0xeda(%rip),%rbx
lea    0xf13(%rip),%r12
lea    0xeac(%rip),%rbp
mov    0x2e8d(%rip),%r13
jmp    1185 <parse_vmflags+0x75>
mov    0x2e6c(%rip),%rax
movzbl (%rax),%ecx
mov    $0x1,%edx
shl    %cl,%rdx
or     %rdx,(%r14)
xor    %edi,%edi
mov    %r12,%rsi
call   1030 <strtok@plt>
test   %rax,%rax
je     1291 <parse_vmflags+0x181>
movzbl (%rax),%ecx
lea    -0x67(%rcx),%edx
cmp    $0x7,%dl
ja     11f0 <parse_vmflags+0xe0>
movzbl %dl,%edx
movslq 0x0(%rbp,%rdx,4),%rdx
add    %rbp,%rdx
jmp    *%rdx
cmpb   $0x64,0x1(%rax)
jne    1172 <parse_vmflags+0x62>
mov    0x2e0e(%rip),%rcx
mov    (%rcx),%rcx
jmp    11ea <parse_vmflags+0xda>
nop
mov    $0x40000,%ecx
cmpb   $0x74,0x1(%rax)
je     11ea <parse_vmflags+0xda>
jmp    121d <parse_vmflags+0x10d>
nopl   (%rax)
cmpb   $0x6f,0x1(%rax)
jne    1172 <parse_vmflags+0x62>
mov    0x2e0b(%rip),%rcx
mov    (%rcx),%rcx
jmp    11ea <parse_vmflags+0xda>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpb   $0x72,0x1(%rax)
jne    1231 <parse_vmflags+0x121>
mov    0x0(%r13),%rcx
or     %rcx,(%r15)
movzbl (%rax),%ecx
add    $0x9c,%cl
cmp    $0xf,%cl
ja     1172 <parse_vmflags+0x62>
movzbl %cl,%ecx
movslq (%rbx,%rcx,4),%rcx
add    %rbx,%rcx
jmp    *%rcx
movzbl 0x1(%rax),%eax
cmp    $0x64,%al
je     1287 <parse_vmflags+0x177>
cmp    $0x63,%al
je     115d <parse_vmflags+0x4d>
jmp    1172 <parse_vmflags+0x62>
mov    $0x4000,%edx
cmpb   $0x67,0x1(%rax)
je     116f <parse_vmflags+0x5f>
jmp    1172 <parse_vmflags+0x62>
mov    $0x8000,%edx
cmpb   $0x68,0x1(%rax)
je     116f <parse_vmflags+0x5f>
jmp    1172 <parse_vmflags+0x62>
cmpb   $0x67,0x1(%rax)
jne    1172 <parse_vmflags+0x62>
mov    0x2d6a(%rip),%rax
jmp    1164 <parse_vmflags+0x54>
cmpb   $0x72,0x1(%rax)
jne    1172 <parse_vmflags+0x62>
mov    0x2d3c(%rip),%rax
jmp    1164 <parse_vmflags+0x54>
cmpb   $0x72,0x1(%rax)
jne    1172 <parse_vmflags+0x62>
mov    0x2d46(%rip),%rax
jmp    1164 <parse_vmflags+0x54>
mov    $0x10000,%edx
jmp    116f <parse_vmflags+0x5f>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c" \0A\00"
@.str.1 = [3 x i8] c"gd\00"
@MAP_GROWSDOWN = global i64 0
@.str.2 = [3 x i8] c"lo\00"
@MAP_LOCKED = global i64 0
@.str.3 = [3 x i8] c"nr\00"
@MAP_NORESERVE = global i64 0
@.str.4 = [3 x i8] c"ht\00"
@.str.5 = [3 x i8] c"sr\00"
@MADV_SEQUENTIAL = global i64 0
@.str.6 = [3 x i8] c"rr\00"
@MADV_RANDOM = global i64 0
@.str.7 = [3 x i8] c"dc\00"
@MADV_DONTFORK = global i64 0
@.str.8 = [3 x i8] c"dd\00"
@.str.9 = [3 x i8] c"mg\00"
@MADV_MERGEABLE = global i64 0
@.str.10 = [3 x i8] c"hg\00"
@.str.11 = [3 x i8] c"nh\00"
define void @parse_vmflags(i8* %0, i64* %1, i64* %2) {
%4 = alloca i8*
%5 = alloca i64*
%6 = alloca i64*
%7 = alloca i8*
store i8* %0, i8** %4
store i64* %1, i64** %5
store i64* %2, i64** %6
%8 = load i8*, i8** %4
%9 = getelementptr inbounds i8, i8* %8, i64 0
%10 = load i8, i8* %9
%11 = icmp ne i8 %10, 0
br i1 %11, label %13, label %12
12: ; preds = %3
br label %264
13: ; preds = %3
%14 = load i8*, i8** %4
%15 = call i8* @strtok(i8* %14, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
store i8* %15, i8** %7
%16 = load i8*, i8** %7
%17 = icmp ne i8* %16, null
br i1 %17, label %19, label %18
18: ; preds = %13
br label %264
19: ; preds = %13
br label %20
20: ; preds = %261, %19
%21 = load i8*, i8** %7
%22 = getelementptr inbounds i8, i8* %21, i64 0
%23 = load i8, i8* %22
%24 = sext i8 %23 to i32
%25 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0)
%26 = sext i8 %25 to i32
%27 = icmp eq i32 %24, %26
br i1 %27, label %28, label %41
28: ; preds = %20
%29 = load i8*, i8** %7
%30 = getelementptr inbounds i8, i8* %29, i64 1
%31 = load i8, i8* %30
%32 = sext i8 %31 to i32
%33 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 1)
%34 = sext i8 %33 to i32
%35 = icmp eq i32 %32, %34
br i1 %35, label %36, label %41
36: ; preds = %28
%37 = load i64, i64* @MAP_GROWSDOWN
%38 = load i64*, i64** %5
%39 = load i64, i64* %38
%40 = or i64 %39, %37
store i64 %40, i64* %38
br label %106
41: ; preds = %28, %20
%42 = load i8*, i8** %7
%43 = getelementptr inbounds i8, i8* %42, i64 0
%44 = load i8, i8* %43
%45 = sext i8 %44 to i32
%46 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0)
%47 = sext i8 %46 to i32
%48 = icmp eq i32 %45, %47
br i1 %48, label %49, label %62
49: ; preds = %41
%50 = load i8*, i8** %7
%51 = getelementptr inbounds i8, i8* %50, i64 1
%52 = load i8, i8* %51
%53 = sext i8 %52 to i32
%54 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 1)
%55 = sext i8 %54 to i32
%56 = icmp eq i32 %53, %55
br i1 %56, label %57, label %62
57: ; preds = %49
%58 = load i64, i64* @MAP_LOCKED
%59 = load i64*, i64** %5
%60 = load i64, i64* %59
%61 = or i64 %60, %58
store i64 %61, i64* %59
br label %105
62: ; preds = %49, %41
%63 = load i8*, i8** %7
%64 = getelementptr inbounds i8, i8* %63, i64 0
%65 = load i8, i8* %64
%66 = sext i8 %65 to i32
%67 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0)
%68 = sext i8 %67 to i32
%69 = icmp eq i32 %66, %68
br i1 %69, label %70, label %83
70: ; preds = %62
%71 = load i8*, i8** %7
%72 = getelementptr inbounds i8, i8* %71, i64 1
%73 = load i8, i8* %72
%74 = sext i8 %73 to i32
%75 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 1)
%76 = sext i8 %75 to i32
%77 = icmp eq i32 %74, %76
br i1 %77, label %78, label %83
78: ; preds = %70
%79 = load i64, i64* @MAP_NORESERVE
%80 = load i64*, i64** %5
%81 = load i64, i64* %80
%82 = or i64 %81, %79
store i64 %82, i64* %80
br label %104
83: ; preds = %70, %62
%84 = load i8*, i8** %7
%85 = getelementptr inbounds i8, i8* %84, i64 0
%86 = load i8, i8* %85
%87 = sext i8 %86 to i32
%88 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0)
%89 = sext i8 %88 to i32
%90 = icmp eq i32 %87, %89
br i1 %90, label %91, label %103
91: ; preds = %83
%92 = load i8*, i8** %7
%93 = getelementptr inbounds i8, i8* %92, i64 1
%94 = load i8, i8* %93
%95 = sext i8 %94 to i32
%96 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 1)
%97 = sext i8 %96 to i32
%98 = icmp eq i32 %95, %97
br i1 %98, label %99, label %103
99: ; preds = %91
%100 = load i64*, i64** %5
%101 = load i64, i64* %100
%102 = or i64 %101, 262144
store i64 %102, i64* %100
br label %103
103: ; preds = %99, %91, %83
br label %104
104: ; preds = %103, %78
br label %105
105: ; preds = %104, %57
br label %106
106: ; preds = %105, %36
%107 = load i8*, i8** %7
%108 = getelementptr inbounds i8, i8* %107, i64 0
%109 = load i8, i8* %108
%110 = sext i8 %109 to i32
%111 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0)
%112 = sext i8 %111 to i32
%113 = icmp eq i32 %110, %112
br i1 %113, label %114, label %128
114: ; preds = %106
%115 = load i8*, i8** %7
%116 = getelementptr inbounds i8, i8* %115, i64 1
%117 = load i8, i8* %116
%118 = sext i8 %117 to i32
%119 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 1)
%120 = sext i8 %119 to i32
%121 = icmp eq i32 %118, %120
br i1 %121, label %122, label %128
122: ; preds = %114
%123 = load i64, i64* @MADV_SEQUENTIAL
%124 = shl i64 1, %123
%125 = load i64*, i64** %6
%126 = load i64, i64* %125
%127 = or i64 %126, %124
store i64 %127, i64* %125
br label %260
128: ; preds = %114, %106
%129 = load i8*, i8** %7
%130 = getelementptr inbounds i8, i8* %129, i64 0
%131 = load i8, i8* %130
%132 = sext i8 %131 to i32
%133 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0)
%134 = sext i8 %133 to i32
%135 = icmp eq i32 %132, %134
br i1 %135, label %136, label %150
136: ; preds = %128
%137 = load i8*, i8** %7
%138 = getelementptr inbounds i8, i8* %137, i64 1
%139 = load i8, i8* %138
%140 = sext i8 %139 to i32
%141 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 1)
%142 = sext i8 %141 to i32
%143 = icmp eq i32 %140, %142
br i1 %143, label %144, label %150
144: ; preds = %136
%145 = load i64, i64* @MADV_RANDOM
%146 = shl i64 1, %145
%147 = load i64*, i64** %6
%148 = load i64, i64* %147
%149 = or i64 %148, %146
store i64 %149, i64* %147
br label %259
150: ; preds = %136, %128
%151 = load i8*, i8** %7
%152 = getelementptr inbounds i8, i8* %151, i64 0
%153 = load i8, i8* %152
%154 = sext i8 %153 to i32
%155 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0)
%156 = sext i8 %155 to i32
%157 = icmp eq i32 %154, %156
br i1 %157, label %158, label %172
158: ; preds = %150
%159 = load i8*, i8** %7
%160 = getelementptr inbounds i8, i8* %159, i64 1
%161 = load i8, i8* %160
%162 = sext i8 %161 to i32
%163 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 1)
%164 = sext i8 %163 to i32
%165 = icmp eq i32 %162, %164
br i1 %165, label %166, label %172
166: ; preds = %158
%167 = load i64, i64* @MADV_DONTFORK
%168 = shl i64 1, %167
%169 = load i64*, i64** %6
%170 = load i64, i64* %169
%171 = or i64 %170, %168
store i64 %171, i64* %169
br label %258
172: ; preds = %158, %150
%173 = load i8*, i8** %7
%174 = getelementptr inbounds i8, i8* %173, i64 0
%175 = load i8, i8* %174
%176 = sext i8 %175 to i32
%177 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0)
%178 = sext i8 %177 to i32
%179 = icmp eq i32 %176, %178
br i1 %179, label %180, label %192
180: ; preds = %172
%181 = load i8*, i8** %7
%182 = getelementptr inbounds i8, i8* %181, i64 1
%183 = load i8, i8* %182
%184 = sext i8 %183 to i32
%185 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 1)
%186 = sext i8 %185 to i32
%187 = icmp eq i32 %184, %186
br i1 %187, label %188, label %192
188: ; preds = %180
%189 = load i64*, i64** %6
%190 = load i64, i64* %189
%191 = or i64 %190, 65536
store i64 %191, i64* %189
br label %257
192: ; preds = %180, %172
%193 = load i8*, i8** %7
%194 = getelementptr inbounds i8, i8* %193, i64 0
%195 = load i8, i8* %194
%196 = sext i8 %195 to i32
%197 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i64 0, i64 0)
%198 = sext i8 %197 to i32
%199 = icmp eq i32 %196, %198
br i1 %199, label %200, label %214
200: ; preds = %192
%201 = load i8*, i8** %7
%202 = getelementptr inbounds i8, i8* %201, i64 1
%203 = load i8, i8* %202
%204 = sext i8 %203 to i32
%205 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i64 0, i64 1)
%206 = sext i8 %205 to i32
%207 = icmp eq i32 %204, %206
br i1 %207, label %208, label %214
208: ; preds = %200
%209 = load i64, i64* @MADV_MERGEABLE
%210 = shl i64 1, %209
%211 = load i64*, i64** %6
%212 = load i64, i64* %211
%213 = or i64 %212, %210
store i64 %213, i64* %211
br label %256
214: ; preds = %200, %192
%215 = load i8*, i8** %7
%216 = getelementptr inbounds i8, i8* %215, i64 0
%217 = load i8, i8* %216
%218 = sext i8 %217 to i32
%219 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0)
%220 = sext i8 %219 to i32
%221 = icmp eq i32 %218, %220
br i1 %221, label %222, label %234
222: ; preds = %214
%223 = load i8*, i8** %7
%224 = getelementptr inbounds i8, i8* %223, i64 1
%225 = load i8, i8* %224
%226 = sext i8 %225 to i32
%227 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 1)
%228 = sext i8 %227 to i32
%229 = icmp eq i32 %226, %228
br i1 %229, label %230, label %234
230: ; preds = %222
%231 = load i64*, i64** %6
%232 = load i64, i64* %231
%233 = or i64 %232, 16384
store i64 %233, i64* %231
br label %255
234: ; preds = %222, %214
%235 = load i8*, i8** %7
%236 = getelementptr inbounds i8, i8* %235, i64 0
%237 = load i8, i8* %236
%238 = sext i8 %237 to i32
%239 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, i64 0, i64 0)
%240 = sext i8 %239 to i32
%241 = icmp eq i32 %238, %240
br i1 %241, label %242, label %254
242: ; preds = %234
%243 = load i8*, i8** %7
%244 = getelementptr inbounds i8, i8* %243, i64 1
%245 = load i8, i8* %244
%246 = sext i8 %245 to i32
%247 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, i64 0, i64 1)
%248 = sext i8 %247 to i32
%249 = icmp eq i32 %246, %248
br i1 %249, label %250, label %254
250: ; preds = %242
%251 = load i64*, i64** %6
%252 = load i64, i64* %251
%253 = or i64 %252, 32768
store i64 %253, i64* %251
br label %254
254: ; preds = %250, %242, %234
br label %255
255: ; preds = %254, %230
br label %256
256: ; preds = %255, %208
br label %257
257: ; preds = %256, %188
br label %258
258: ; preds = %257, %166
br label %259
259: ; preds = %258, %144
br label %260
260: ; preds = %259, %122
br label %261
261: ; preds = %260
%262 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
store i8* %262, i8** %7
%263 = icmp ne i8* %262, null
br i1 %263, label %20, label %264
264: ; preds = %12, %18, %261
ret void
}

LLVM IR (-O2):
@.str = [3 x i8] c" \0A\00"
@MAP_GROWSDOWN = global i64 0
@MAP_LOCKED = global i64 0
@MAP_NORESERVE = global i64 0
@MADV_SEQUENTIAL = global i64 0
@MADV_RANDOM = global i64 0
@MADV_DONTFORK = global i64 0
@MADV_MERGEABLE = global i64 0
define void @parse_vmflags(i8* %0, i64* nocapture %1, i64* nocapture %2) {
%4 = load i8, i8* %0
%5 = icmp eq i8 %4, 0
br i1 %5, label %83, label %6
6: ; preds = %3
%7 = tail call i8* @strtok(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
%8 = icmp eq i8* %7, null
br i1 %8, label %83, label %9
9: ; preds = %6, %80
%10 = phi i8* [ %81, %80 ], [ %7, %6 ]
%11 = load i8, i8* %10
switch i8 %11, label %39 [
i8 103, label %12
i8 108, label %18
i8 110, label %24
i8 104, label %30
]
12: ; preds = %9
%13 = getelementptr inbounds i8, i8* %10, i64 1
%14 = load i8, i8* %13
%15 = icmp eq i8 %14, 100
br i1 %15, label %16, label %80
16: ; preds = %12
%17 = load i64, i64* @MAP_GROWSDOWN
br label %34
18: ; preds = %9
%19 = getelementptr inbounds i8, i8* %10, i64 1
%20 = load i8, i8* %19
%21 = icmp eq i8 %20, 111
br i1 %21, label %22, label %80
22: ; preds = %18
%23 = load i64, i64* @MAP_LOCKED
br label %34
24: ; preds = %9
%25 = getelementptr inbounds i8, i8* %10, i64 1
%26 = load i8, i8* %25
%27 = icmp eq i8 %26, 114
br i1 %27, label %28, label %72
28: ; preds = %24
%29 = load i64, i64* @MAP_NORESERVE
br label %34
30: ; preds = %9
%31 = getelementptr inbounds i8, i8* %10, i64 1
%32 = load i8, i8* %31
%33 = icmp eq i8 %32, 116
br i1 %33, label %34, label %68
34: ; preds = %30, %16, %28, %22
%35 = phi i64 [ %17, %16 ], [ %29, %28 ], [ %23, %22 ], [ 262144, %30 ]
%36 = load i64, i64* %1
%37 = or i64 %36, %35
store i64 %37, i64* %1
%38 = load i8, i8* %10
br label %39
39: ; preds = %34, %9
%40 = phi i8 [ %38, %34 ], [ %11, %9 ]
switch i8 %40, label %80 [
i8 115, label %41
i8 114, label %48
i8 100, label %55
i8 109, label %61
i8 104, label %68
i8 110, label %72
]
41: ; preds = %39
%42 = getelementptr inbounds i8, i8* %10, i64 1
%43 = load i8, i8* %42
%44 = icmp eq i8 %43, 114
br i1 %44, label %45, label %80
45: ; preds = %41
%46 = load i64, i64* @MADV_SEQUENTIAL
%47 = shl nuw i64 1, %46
br label %76
48: ; preds = %39
%49 = getelementptr inbounds i8, i8* %10, i64 1
%50 = load i8, i8* %49
%51 = icmp eq i8 %50, 114
br i1 %51, label %52, label %80
52: ; preds = %48
%53 = load i64, i64* @MADV_RANDOM
%54 = shl nuw i64 1, %53
br label %76
55: ; preds = %39
%56 = getelementptr inbounds i8, i8* %10, i64 1
%57 = load i8, i8* %56
switch i8 %57, label %80 [
i8 99, label %58
i8 100, label %76
]
58: ; preds = %55
%59 = load i64, i64* @MADV_DONTFORK
%60 = shl nuw i64 1, %59
br label %76
61: ; preds = %39
%62 = getelementptr inbounds i8, i8* %10, i64 1
%63 = load i8, i8* %62
%64 = icmp eq i8 %63, 103
br i1 %64, label %65, label %80
65: ; preds = %61
%66 = load i64, i64* @MADV_MERGEABLE
%67 = shl nuw i64 1, %66
br label %76
68: ; preds = %30, %39
%69 = getelementptr inbounds i8, i8* %10, i64 1
%70 = load i8, i8* %69
%71 = icmp eq i8 %70, 103
br i1 %71, label %76, label %80
72: ; preds = %24, %39
%73 = getelementptr inbounds i8, i8* %10, i64 1
%74 = load i8, i8* %73
%75 = icmp eq i8 %74, 104
br i1 %75, label %76, label %80
76: ; preds = %72, %68, %55, %52, %65, %58, %45
%77 = phi i64 [ %47, %45 ], [ %60, %58 ], [ %67, %65 ], [ %54, %52 ], [ 65536, %55 ], [ 16384, %68 ], [ 32768, %72 ]
%78 = load i64, i64* %2
%79 = or i64 %78, %77
store i64 %79, i64* %2
br label %80
80: ; preds = %76, %55, %12, %18, %39, %41, %48, %61, %68, %72
%81 = tail call i8* @strtok(i8* null, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
%82 = icmp eq i8* %81, null
br i1 %82, label %83, label %9
83: ; preds = %80, %6, %3
ret void
}