#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 */
void *parse(char *, char *);
int /*<<< orphan*/ parse_string(char *, char *, char *, int);
int /*<<< orphan*/
printf(char *, unsigned long, unsigned long, char *, unsigned long long,
       unsigned long long, unsigned long long, unsigned long long,
       unsigned long long, unsigned long long, unsigned long long,
       unsigned long long, unsigned long long, unsigned long long,
       unsigned long long, unsigned long long, unsigned long long,
       unsigned long long, unsigned long long, unsigned long long,
       unsigned long long, unsigned long long);
void parse_pool(char *s) {
  char pool_type[3];
  unsigned long cli_id = parse(s, "CI");
  unsigned long pool_id = parse(s, "PI");
  unsigned long long pgp_count = parse(s, "Pc");
  unsigned long long max_pgp_count = parse(s, "Pm");
  unsigned long long obj_count = parse(s, "Oc");
  unsigned long long max_obj_count = parse(s, "Om");
  unsigned long long objnode_count = parse(s, "Nc");
  unsigned long long max_objnode_count = parse(s, "Nm");
  unsigned long long good_puts = parse(s, "ps");
  unsigned long long puts = parse(s, "pt");
  unsigned long long no_mem_puts = parse(s, "px");
  unsigned long long dup_puts_flushed = parse(s, "pd");
  unsigned long long dup_puts_replaced = parse(s, "pr");
  unsigned long long found_gets = parse(s, "gs");
  unsigned long long gets = parse(s, "gt");
  unsigned long long flushs_found = parse(s, "fs");
  unsigned long long flushs = parse(s, "ft");
  unsigned long long flush_objs_found = parse(s, "os");
  unsigned long long flush_objs = parse(s, "ot");
  parse_string(s, "PT", pool_type, 2);
  pool_type[2] = '\0';
  if (pool_type[1] == 'S')
    return;
  printf("domid%lu,id%lu[%s]:pgp=%llu(max=%llu) obj=%llu(%llu) "
         "objnode=%llu(%llu) puts=%llu/%llu/%llu(dup=%llu/%llu) "
         "gets=%llu/%llu(%llu%%) "
         "flush=%llu/%llu flobj=%llu/%llu\n",
         cli_id, pool_id, pool_type, pgp_count, max_pgp_count, obj_count,
         max_obj_count, objnode_count, max_objnode_count, good_puts, puts,
         no_mem_puts, dup_puts_flushed, dup_puts_replaced, found_gets, gets,
         gets ? (found_gets * 100LL) / gets : 0, flushs_found, flushs,
         flush_objs_found, flush_objs);
}


x86 assembly (clang, -O0):
<parse_pool>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1b8,%rsp
mov    %rdi,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xead(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe9c(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x48(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe8b(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x50(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe7a(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x58(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe69(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x60(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe58(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x68(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe47(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x70(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe36(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x78(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe25(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x80(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe14(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x88(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe00(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x90(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xdec(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x98(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xdd8(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0xa0(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xdc4(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xdb0(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0xb0(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xd9c(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0xb8(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xd88(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0xc0(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xd74(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0xc8(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xd60(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0xd0(%rbp)
mov    -0x30(%rbp),%rdi
lea    -0x33(%rbp),%rdx
lea    0xd48(%rip),%rsi
mov    $0x2,%ecx
call   1030 <parse_string@plt>
movb   $0x0,-0x31(%rbp)
movsbl -0x32(%rbp),%eax
cmp    $0x53,%eax
jne    1311 <parse_pool+0x1e1>
jmp    14fc <parse_pool+0x3cc>
mov    -0x40(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x148(%rbp)
lea    -0x33(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x138(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x130(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x120(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x118(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x100(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0xa0(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0xb0(%rbp),%rax
mov    %rax,-0xd8(%rbp)
cmpq   $0x0,-0xb0(%rbp)
je     1400 <parse_pool+0x2d0>
imul   $0x64,-0xa8(%rbp),%rax
64
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0xb0(%rbp)
mov    %rax,-0x158(%rbp)
jmp    140e <parse_pool+0x2de>
xor    %eax,%eax
mov    %rax,-0x158(%rbp)
jmp    140e <parse_pool+0x2de>
mov    -0xe0(%rbp),%r12
mov    -0xe8(%rbp),%r13
mov    -0x128(%rbp),%r15
mov    -0x130(%rbp),%r9
mov    -0x138(%rbp),%r8
mov    -0x140(%rbp),%rcx
mov    -0x148(%rbp),%rdx
mov    -0x150(%rbp),%rsi
mov    -0x158(%rbp),%r14
mov    -0xb8(%rbp),%rbx
mov    -0xc0(%rbp),%r11
mov    -0xc8(%rbp),%r10
mov    -0xd0(%rbp),%rax
lea    0xbcc(%rip),%rdi
mov    %r15,(%rsp)
mov    -0x120(%rbp),%r15
mov    %r15,0x8(%rsp)
mov    -0x118(%rbp),%r15
mov    %r15,0x10(%rsp)
mov    -0x110(%rbp),%r15
mov    %r15,0x18(%rsp)
mov    -0x108(%rbp),%r15
mov    %r15,0x20(%rsp)
mov    -0x100(%rbp),%r15
mov    %r15,0x28(%rsp)
mov    -0xf8(%rbp),%r15
mov    %r15,0x30(%rsp)
mov    -0xf0(%rbp),%r15
mov    %r15,0x38(%rsp)
mov    -0xd8(%rbp),%r15
mov    %r13,0x40(%rsp)
mov    %r12,0x48(%rsp)
mov    %r15,0x50(%rsp)
mov    %r14,0x58(%rsp)
mov    %rbx,0x60(%rsp)
mov    %r11,0x68(%rsp)
mov    %r10,0x70(%rsp)
mov    %rax,0x78(%rsp)
call   1040 <printf@plt>
add    $0x1b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<parse_pool>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %rdi,%r14
lea    0xeb8(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,%rbp
lea    0xeac(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,%rbx
lea    0xe9d(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x20(%rsp)
lea    0xe8c(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x10(%rsp)
lea    0xe7b(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x30(%rsp)
lea    0xe6a(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x28(%rsp)
lea    0xe59(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x18(%rsp)
lea    0xe48(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x8(%rsp)
lea    0xe37(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x70(%rsp)
lea    0xe26(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x68(%rsp)
lea    0xe15(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x60(%rsp)
lea    0xe04(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x58(%rsp)
lea    0xdf3(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x50(%rsp)
lea    0xde2(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x38(%rsp)
lea    0xdd1(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,%r13
lea    0xdc2(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x48(%rsp)
lea    0xdb1(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x40(%rsp)
lea    0xda0(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,%r15
lea    0xd91(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,%r12
lea    0xd82(%rip),%rsi
lea    0x5(%rsp),%rdx
mov    %r14,%rdi
mov    $0x2,%ecx
call   1030 <parse_string@plt>
movb   $0x0,0x7(%rsp)
cmpb   $0x53,0x6(%rsp)
je     137b <parse_pool+0x24b>
mov    %rbx,%r14
mov    %rbp,%rsi
test   %r13,%r13
je     12fd <parse_pool+0x1cd>
imul   $0x64,0x38(%rsp),%rax
mov    %r13,%rcx
or     %rax,%rcx
shr    $0x20,%rcx
je     1301 <parse_pool+0x1d1>
xor    %edx,%edx
div    %r13
jmp    1306 <parse_pool+0x1d6>
xor    %eax,%eax
jmp    1306 <parse_pool+0x1d6>
xor    %edx,%edx
div    %r13d
mov    0x30(%rsp),%r10
mov    0x28(%rsp),%r11
mov    0x20(%rsp),%r8
mov    0x18(%rsp),%rbp
mov    0x10(%rsp),%r9
mov    0x8(%rsp),%rbx
lea    0xd11(%rip),%rdi
lea    0x5(%rsp),%rcx
mov    %r14,%rdx
push   %r12
push   %r15
push   0x50(%rsp)
push   0x60(%rsp)
push   %rax
push   %r13
push   0x68(%rsp)
push   0x88(%rsp)
push   0x98(%rsp)
push   0xa8(%rsp)
push   0xb8(%rsp)
push   0xc8(%rsp)
push   %rbx
push   %rbp
push   %r11
push   %r10
call   1040 <printf@plt>
add    $0x80,%rsp
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"CI\00"
@.str.1 = [3 x i8] c"PI\00"
@.str.2 = [3 x i8] c"Pc\00"
@.str.3 = [3 x i8] c"Pm\00"
@.str.4 = [3 x i8] c"Oc\00"
@.str.5 = [3 x i8] c"Om\00"
@.str.6 = [3 x i8] c"Nc\00"
@.str.7 = [3 x i8] c"Nm\00"
@.str.8 = [3 x i8] c"ps\00"
@.str.9 = [3 x i8] c"pt\00"
@.str.10 = [3 x i8] c"px\00"
@.str.11 = [3 x i8] c"pd\00"
@.str.12 = [3 x i8] c"pr\00"
@.str.13 = [3 x i8] c"gs\00"
@.str.14 = [3 x i8] c"gt\00"
@.str.15 = [3 x i8] c"fs\00"
@.str.16 = [3 x i8] c"ft\00"
@.str.17 = [3 x i8] c"os\00"
@.str.18 = [3 x i8] c"ot\00"
@.str.19 = [3 x i8] c"PT\00"
@.str.20 = [163 x i8] c"domid%lu,id%lu[%s]:pgp=%llu(max=%llu) obj=%llu(%llu) objnode=%llu(%llu) puts=%llu/%llu/%llu(dup=%llu/%llu) gets=%llu/%llu(%llu%%) flush=%llu/%llu flobj=%llu/%llu\0A\00"
define void @parse_pool(i8* %0) {
%2 = alloca i8*
%3 = alloca [3 x i8]
%4 = alloca i64
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
%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** %2
%23 = load i8*, i8** %2
%24 = call i8* @parse(i8* %23, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
%25 = ptrtoint i8* %24 to i64
store i64 %25, i64* %4
%26 = load i8*, i8** %2
%27 = call i8* @parse(i8* %26, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%28 = ptrtoint i8* %27 to i64
store i64 %28, i64* %5
%29 = load i8*, i8** %2
%30 = call i8* @parse(i8* %29, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%31 = ptrtoint i8* %30 to i64
store i64 %31, i64* %6
%32 = load i8*, i8** %2
%33 = call i8* @parse(i8* %32, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0))
%34 = ptrtoint i8* %33 to i64
store i64 %34, i64* %7
%35 = load i8*, i8** %2
%36 = call i8* @parse(i8* %35, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0))
%37 = ptrtoint i8* %36 to i64
store i64 %37, i64* %8
%38 = load i8*, i8** %2
%39 = call i8* @parse(i8* %38, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
%40 = ptrtoint i8* %39 to i64
store i64 %40, i64* %9
%41 = load i8*, i8** %2
%42 = call i8* @parse(i8* %41, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%43 = ptrtoint i8* %42 to i64
store i64 %43, i64* %10
%44 = load i8*, i8** %2
%45 = call i8* @parse(i8* %44, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0))
%46 = ptrtoint i8* %45 to i64
store i64 %46, i64* %11
%47 = load i8*, i8** %2
%48 = call i8* @parse(i8* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0))
%49 = ptrtoint i8* %48 to i64
store i64 %49, i64* %12
%50 = load i8*, i8** %2
%51 = call i8* @parse(i8* %50, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i64 0, i64 0))
%52 = ptrtoint i8* %51 to i64
store i64 %52, i64* %13
%53 = load i8*, i8** %2
%54 = call i8* @parse(i8* %53, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0))
%55 = ptrtoint i8* %54 to i64
store i64 %55, i64* %14
%56 = load i8*, i8** %2
%57 = call i8* @parse(i8* %56, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, i64 0, i64 0))
%58 = ptrtoint i8* %57 to i64
store i64 %58, i64* %15
%59 = load i8*, i8** %2
%60 = call i8* @parse(i8* %59, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.12, i64 0, i64 0))
%61 = ptrtoint i8* %60 to i64
store i64 %61, i64* %16
%62 = load i8*, i8** %2
%63 = call i8* @parse(i8* %62, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0))
%64 = ptrtoint i8* %63 to i64
store i64 %64, i64* %17
%65 = load i8*, i8** %2
%66 = call i8* @parse(i8* %65, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0))
%67 = ptrtoint i8* %66 to i64
store i64 %67, i64* %18
%68 = load i8*, i8** %2
%69 = call i8* @parse(i8* %68, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.15, i64 0, i64 0))
%70 = ptrtoint i8* %69 to i64
store i64 %70, i64* %19
%71 = load i8*, i8** %2
%72 = call i8* @parse(i8* %71, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.16, i64 0, i64 0))
%73 = ptrtoint i8* %72 to i64
store i64 %73, i64* %20
%74 = load i8*, i8** %2
%75 = call i8* @parse(i8* %74, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.17, i64 0, i64 0))
%76 = ptrtoint i8* %75 to i64
store i64 %76, i64* %21
%77 = load i8*, i8** %2
%78 = call i8* @parse(i8* %77, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.18, i64 0, i64 0))
%79 = ptrtoint i8* %78 to i64
store i64 %79, i64* %22
%80 = load i8*, i8** %2
%81 = getelementptr inbounds [3 x i8], [3 x i8]* %3, i64 0, i64 0
%82 = call i32 @parse_string(i8* %80, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.19, i64 0, i64 0), i8* %81, i32 2)
%83 = getelementptr inbounds [3 x i8], [3 x i8]* %3, i64 0, i64 2
store i8 0, i8* %83
%84 = getelementptr inbounds [3 x i8], [3 x i8]* %3, i64 0, i64 1
%85 = load i8, i8* %84
%86 = sext i8 %85 to i32
%87 = icmp eq i32 %86, 83
br i1 %87, label %88, label %89
88: ; preds = %1
br label %121
89: ; preds = %1
%90 = load i64, i64* %4
%91 = load i64, i64* %5
%92 = getelementptr inbounds [3 x i8], [3 x i8]* %3, i64 0, i64 0
%93 = load i64, i64* %6
%94 = load i64, i64* %7
%95 = load i64, i64* %8
%96 = load i64, i64* %9
%97 = load i64, i64* %10
%98 = load i64, i64* %11
%99 = load i64, i64* %12
%100 = load i64, i64* %13
%101 = load i64, i64* %14
%102 = load i64, i64* %15
%103 = load i64, i64* %16
%104 = load i64, i64* %17
%105 = load i64, i64* %18
%106 = load i64, i64* %18
%107 = icmp ne i64 %106, 0
br i1 %107, label %108, label %113
108: ; preds = %89
%109 = load i64, i64* %17
%110 = mul i64 %109, 100
%111 = load i64, i64* %18
%112 = udiv i64 %110, %111
br label %114
113: ; preds = %89
br label %114
114: ; preds = %113, %108
%115 = phi i64 [ %112, %108 ], [ 0, %113 ]
%116 = load i64, i64* %19
%117 = load i64, i64* %20
%118 = load i64, i64* %21
%119 = load i64, i64* %22
%120 = call i32 @printf(i8* getelementptr inbounds ([163 x i8], [163 x i8]* @.str.20, i64 0, i64 0), i64 %90, i64 %91, i8* %92, i64 %93, i64 %94, i64 %95, i64 %96, i64 %97, i64 %98, i64 %99, i64 %100, i64 %101, i64 %102, i64 %103, i64 %104, i64 %105, i64 %115, i64 %116, i64 %117, i64 %118, i64 %119)
br label %121
121: ; preds = %114, %88
ret void
}

LLVM IR (-O2):
@.str = [3 x i8] c"CI\00"
@.str.1 = [3 x i8] c"PI\00"
@.str.2 = [3 x i8] c"Pc\00"
@.str.3 = [3 x i8] c"Pm\00"
@.str.4 = [3 x i8] c"Oc\00"
@.str.5 = [3 x i8] c"Om\00"
@.str.6 = [3 x i8] c"Nc\00"
@.str.7 = [3 x i8] c"Nm\00"
@.str.8 = [3 x i8] c"ps\00"
@.str.9 = [3 x i8] c"pt\00"
@.str.10 = [3 x i8] c"px\00"
@.str.11 = [3 x i8] c"pd\00"
@.str.12 = [3 x i8] c"pr\00"
@.str.13 = [3 x i8] c"gs\00"
@.str.14 = [3 x i8] c"gt\00"
@.str.15 = [3 x i8] c"fs\00"
@.str.16 = [3 x i8] c"ft\00"
@.str.17 = [3 x i8] c"os\00"
@.str.18 = [3 x i8] c"ot\00"
@.str.19 = [3 x i8] c"PT\00"
@.str.20 = [163 x i8] c"domid%lu,id%lu[%s]:pgp=%llu(max=%llu) obj=%llu(%llu) objnode=%llu(%llu) puts=%llu/%llu/%llu(dup=%llu/%llu) gets=%llu/%llu(%llu%%) flush=%llu/%llu flobj=%llu/%llu\0A\00"
define void @parse_pool(i8* %0) {
%2 = alloca [3 x i8]
%3 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 0
%4 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
%5 = ptrtoint i8* %4 to i64
%6 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%7 = ptrtoint i8* %6 to i64
%8 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%9 = ptrtoint i8* %8 to i64
%10 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0))
%11 = ptrtoint i8* %10 to i64
%12 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0))
%13 = ptrtoint i8* %12 to i64
%14 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
%15 = ptrtoint i8* %14 to i64
%16 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%17 = ptrtoint i8* %16 to i64
%18 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0))
%19 = ptrtoint i8* %18 to i64
%20 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0))
%21 = ptrtoint i8* %20 to i64
%22 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i64 0, i64 0))
%23 = ptrtoint i8* %22 to i64
%24 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0))
%25 = ptrtoint i8* %24 to i64
%26 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, i64 0, i64 0))
%27 = ptrtoint i8* %26 to i64
%28 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.12, i64 0, i64 0))
%29 = ptrtoint i8* %28 to i64
%30 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0))
%31 = ptrtoint i8* %30 to i64
%32 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0))
%33 = ptrtoint i8* %32 to i64
%34 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.15, i64 0, i64 0))
%35 = ptrtoint i8* %34 to i64
%36 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.16, i64 0, i64 0))
%37 = ptrtoint i8* %36 to i64
%38 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.17, i64 0, i64 0))
%39 = ptrtoint i8* %38 to i64
%40 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.18, i64 0, i64 0))
%41 = ptrtoint i8* %40 to i64
%42 = call i32 @parse_string(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.19, i64 0, i64 0), i8* %3, i32 2)
%43 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 2
store i8 0, i8* %43
%44 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 1
%45 = load i8, i8* %44
%46 = icmp eq i8 %45, 83
br i1 %46, label %55, label %47
47: ; preds = %1
%48 = icmp eq i8* %32, null
br i1 %48, label %52, label %49
49: ; preds = %47
%50 = mul i64 %31, 100
%51 = udiv i64 %50, %33
br label %52
52: ; preds = %47, %49
%53 = phi i64 [ %51, %49 ], [ 0, %47 ]
%54 = call i32 @printf(i8* getelementptr inbounds ([163 x i8], [163 x i8]* @.str.20, i64 0, i64 0), i64 %5, i64 %7, i8* %3, i64 %9, i64 %11, i64 %13, i64 %15, i64 %17, i64 %19, i64 %21, i64 %23, i64 %25, i64 %27, i64 %29, i64 %31, i64 %33, i64 %53, i64 %35, i64 %37, i64 %39, i64 %41)
br label %55
55: ; preds = %1, %52
ret void
}