#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 */
typedef int uint64_t;

/* Variables and functions */
unsigned int strlen(char const *);
int bit_entry_64(const char *token, int bits, uint64_t *data, uint64_t *mask) {
  do {
    unsigned int count = 0;
    unsigned int index;
    int buf_index;
    if (token == NULL)
      return 0;
    if ((bits > 64) || (bits < 1))
      return 0;
    count = strlen(token);
    buf_index = bits - 1;
    for (index = 0; index < count; index++) {
      if ((token[index] == '{') || (token[index] == '}')) {
      } else if ((token[index] == ' ') || (token[index] == '\t')) {
      } else if (token[index] == '0') {
        *data &= ~(1 << buf_index);
        *mask |= (1 << buf_index);
        buf_index--;
      } else if (token[index] == '1') {
        *data |= (1 << buf_index);
        *mask |= (1 << buf_index);
        buf_index--;
      } else if ((token[index] == '-') || (token[index] == '*')) {
        *data &= ~(1 << buf_index);
        *mask &= ~(1 << buf_index);
        buf_index--;
      } else {
        return 0;
      };
    };
    if (buf_index != -1)
      return 0;
    return 1;
  } while (0);
  ;
}


x86 assembly (clang, -O0):
<bit_entry_64>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    1145 <bit_entry_64+0x35>
movl   $0x0,-0x4(%rbp)
jmp    1332 <bit_entry_64+0x222>
cmpl   $0x40,-0x14(%rbp)
jg     1159 <bit_entry_64+0x49>
cmpl   $0x1,-0x14(%rbp)
jge    1165 <bit_entry_64+0x55>
movl   $0x0,-0x4(%rbp)
jmp    1332 <bit_entry_64+0x222>
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    1315 <bit_entry_64+0x205>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7b,%eax
je     11b5 <bit_entry_64+0xa5>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7d,%eax
jne    11ba <bit_entry_64+0xaa>
jmp    1302 <bit_entry_64+0x1f2>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     11e2 <bit_entry_64+0xd2>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x9,%eax
jne    11e7 <bit_entry_64+0xd7>
jmp    12fd <bit_entry_64+0x1ed>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jne    1234 <bit_entry_64+0x124>
mov    -0x34(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,%ecx
xor    $0xffffffff,%ecx
mov    -0x20(%rbp),%rax
and    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x34(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,%ecx
mov    -0x28(%rbp),%rax
or     (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    12f8 <bit_entry_64+0x1e8>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x31,%eax
jne    127e <bit_entry_64+0x16e>
mov    -0x34(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,%ecx
mov    -0x20(%rbp),%rax
or     (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x34(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,%ecx
mov    -0x28(%rbp),%rax
or     (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    12f3 <bit_entry_64+0x1e3>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
je     12a6 <bit_entry_64+0x196>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2a,%eax
jne    12e2 <bit_entry_64+0x1d2>
mov    -0x34(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,%ecx
xor    $0xffffffff,%ecx
mov    -0x20(%rbp),%rax
and    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x34(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,%ecx
xor    $0xffffffff,%ecx
mov    -0x28(%rbp),%rax
and    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    12ee <bit_entry_64+0x1de>
movl   $0x0,-0x4(%rbp)
jmp    1332 <bit_entry_64+0x222>
jmp    12f3 <bit_entry_64+0x1e3>
jmp    12f8 <bit_entry_64+0x1e8>
jmp    12fd <bit_entry_64+0x1ed>
jmp    1302 <bit_entry_64+0x1f2>
jmp    1307 <bit_entry_64+0x1f7>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1181 <bit_entry_64+0x71>
cmpl   $0xffffffff,-0x34(%rbp)
je     132b <bit_entry_64+0x21b>
movl   $0x0,-0x4(%rbp)
jmp    1332 <bit_entry_64+0x222>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bit_entry_64>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
xor    %eax,%eax
test   %rdi,%rdi
je     11d8 <bit_entry_64+0xc8>
mov    %rcx,%r14
mov    %esi,%ebx
lea    -0x41(%rbx),%ecx
cmp    $0xffffffc0,%ecx
jb     11d8 <bit_entry_64+0xc8>
mov    %rdx,%r15
mov    %rdi,%r12
call   1030 <strlen@plt>
add    $0xffffffff,%ebx
test   %eax,%eax
je     11d0 <bit_entry_64+0xc0>
mov    %eax,%eax
xor    %edx,%edx
lea    0xeab(%rip),%rsi
jmp    1181 <bit_entry_64+0x71>
nopw   0x0(%rax,%rax,1)
mov    $0xfffffffe,%edi
mov    %ebx,%ecx
rol    %cl,%edi
and    %edi,(%r15)
mov    (%r14),%ecx
btr    %ebx,%ecx
mov    %ecx,(%r14)
add    $0xffffffff,%ebx
add    $0x1,%rdx
cmp    %rdx,%rax
je     11d0 <bit_entry_64+0xc0>
movzbl (%r12,%rdx,1),%ecx
lea    -0x9(%rcx),%edi
cmp    $0x28,%dil
ja     11b0 <bit_entry_64+0xa0>
movzbl %dil,%ecx
movslq (%rsi,%rcx,4),%rcx
add    %rsi,%rcx
jmp    *%rcx
mov    $0xfffffffe,%edi
mov    %ebx,%ecx
rol    %cl,%edi
and    %edi,(%r15)
jmp    11c8 <bit_entry_64+0xb8>
nopw   0x0(%rax,%rax,1)
cmp    $0x7b,%cl
je     1178 <bit_entry_64+0x68>
cmp    $0x7d,%cl
je     1178 <bit_entry_64+0x68>
jmp    11e4 <bit_entry_64+0xd4>
mov    $0x1,%edi
mov    %ebx,%ecx
shl    %cl,%edi
or     %edi,(%r15)
mov    (%r14),%ecx
bts    %ebx,%ecx
jmp    1172 <bit_entry_64+0x62>
xor    %eax,%eax
cmp    $0xffffffff,%ebx
sete   %al
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
xor    %eax,%eax
jmp    11d8 <bit_entry_64+0xc8>

LLVM IR (-O0):
define i32 @bit_entry_64(i8* %0, i32 %1, i32* %2, i32* %3) {
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32*
%9 = alloca i32*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store i8* %0, i8** %6
store i32 %1, i32* %7
store i32* %2, i32** %8
store i32* %3, i32** %9
br label %13
13: ; preds = %4
store i32 0, i32* %10
%14 = load i8*, i8** %6
%15 = icmp eq i8* %14, null
br i1 %15, label %16, label %17
16: ; preds = %13
store i32 0, i32* %5
br label %155
17: ; preds = %13
%18 = load i32, i32* %7
%19 = icmp sgt i32 %18, 64
br i1 %19, label %23, label %20
20: ; preds = %17
%21 = load i32, i32* %7
%22 = icmp slt i32 %21, 1
br i1 %22, label %23, label %24
23: ; preds = %20, %17
store i32 0, i32* %5
br label %155
24: ; preds = %20
%25 = load i8*, i8** %6
%26 = call i32 @strlen(i8* %25)
store i32 %26, i32* %10
%27 = load i32, i32* %7
%28 = sub nsw i32 %27, 1
store i32 %28, i32* %12
store i32 0, i32* %11
br label %29
29: ; preds = %147, %24
%30 = load i32, i32* %11
%31 = load i32, i32* %10
%32 = icmp ult i32 %30, %31
br i1 %32, label %33, label %150
33: ; preds = %29
%34 = load i8*, i8** %6
%35 = load i32, i32* %11
%36 = zext i32 %35 to i64
%37 = getelementptr inbounds i8, i8* %34, i64 %36
%38 = load i8, i8* %37
%39 = sext i8 %38 to i32
%40 = icmp eq i32 %39, 123
br i1 %40, label %49, label %41
41: ; preds = %33
%42 = load i8*, i8** %6
%43 = load i32, i32* %11
%44 = zext i32 %43 to i64
%45 = getelementptr inbounds i8, i8* %42, i64 %44
%46 = load i8, i8* %45
%47 = sext i8 %46 to i32
%48 = icmp eq i32 %47, 125
br i1 %48, label %49, label %50
49: ; preds = %41, %33
br label %146
50: ; preds = %41
%51 = load i8*, i8** %6
%52 = load i32, i32* %11
%53 = zext i32 %52 to i64
%54 = getelementptr inbounds i8, i8* %51, i64 %53
%55 = load i8, i8* %54
%56 = sext i8 %55 to i32
%57 = icmp eq i32 %56, 32
br i1 %57, label %66, label %58
58: ; preds = %50
%59 = load i8*, i8** %6
%60 = load i32, i32* %11
%61 = zext i32 %60 to i64
%62 = getelementptr inbounds i8, i8* %59, i64 %61
%63 = load i8, i8* %62
%64 = sext i8 %63 to i32
%65 = icmp eq i32 %64, 9
br i1 %65, label %66, label %67
66: ; preds = %58, %50
br label %145
67: ; preds = %58
%68 = load i8*, i8** %6
%69 = load i32, i32* %11
%70 = zext i32 %69 to i64
%71 = getelementptr inbounds i8, i8* %68, i64 %70
%72 = load i8, i8* %71
%73 = sext i8 %72 to i32
%74 = icmp eq i32 %73, 48
br i1 %74, label %75, label %89
75: ; preds = %67
%76 = load i32, i32* %12
%77 = shl i32 1, %76
%78 = xor i32 %77, -1
%79 = load i32*, i32** %8
%80 = load i32, i32* %79
%81 = and i32 %80, %78
store i32 %81, i32* %79
%82 = load i32, i32* %12
%83 = shl i32 1, %82
%84 = load i32*, i32** %9
%85 = load i32, i32* %84
%86 = or i32 %85, %83
store i32 %86, i32* %84
%87 = load i32, i32* %12
%88 = add nsw i32 %87, -1
store i32 %88, i32* %12
br label %144
89: ; preds = %67
%90 = load i8*, i8** %6
%91 = load i32, i32* %11
%92 = zext i32 %91 to i64
%93 = getelementptr inbounds i8, i8* %90, i64 %92
%94 = load i8, i8* %93
%95 = sext i8 %94 to i32
%96 = icmp eq i32 %95, 49
br i1 %96, label %97, label %110
97: ; preds = %89
%98 = load i32, i32* %12
%99 = shl i32 1, %98
%100 = load i32*, i32** %8
%101 = load i32, i32* %100
%102 = or i32 %101, %99
store i32 %102, i32* %100
%103 = load i32, i32* %12
%104 = shl i32 1, %103
%105 = load i32*, i32** %9
%106 = load i32, i32* %105
%107 = or i32 %106, %104
store i32 %107, i32* %105
%108 = load i32, i32* %12
%109 = add nsw i32 %108, -1
store i32 %109, i32* %12
br label %143
110: ; preds = %89
%111 = load i8*, i8** %6
%112 = load i32, i32* %11
%113 = zext i32 %112 to i64
%114 = getelementptr inbounds i8, i8* %111, i64 %113
%115 = load i8, i8* %114
%116 = sext i8 %115 to i32
%117 = icmp eq i32 %116, 45
br i1 %117, label %126, label %118
118: ; preds = %110
%119 = load i8*, i8** %6
%120 = load i32, i32* %11
%121 = zext i32 %120 to i64
%122 = getelementptr inbounds i8, i8* %119, i64 %121
%123 = load i8, i8* %122
%124 = sext i8 %123 to i32
%125 = icmp eq i32 %124, 42
br i1 %125, label %126, label %141
126: ; preds = %118, %110
%127 = load i32, i32* %12
%128 = shl i32 1, %127
%129 = xor i32 %128, -1
%130 = load i32*, i32** %8
%131 = load i32, i32* %130
%132 = and i32 %131, %129
store i32 %132, i32* %130
%133 = load i32, i32* %12
%134 = shl i32 1, %133
%135 = xor i32 %134, -1
%136 = load i32*, i32** %9
%137 = load i32, i32* %136
%138 = and i32 %137, %135
store i32 %138, i32* %136
%139 = load i32, i32* %12
%140 = add nsw i32 %139, -1
store i32 %140, i32* %12
br label %142
141: ; preds = %118
store i32 0, i32* %5
br label %155
142: ; preds = %126
br label %143
143: ; preds = %142, %97
br label %144
144: ; preds = %143, %75
br label %145
145: ; preds = %144, %66
br label %146
146: ; preds = %145, %49
br label %147
147: ; preds = %146
%148 = load i32, i32* %11
%149 = add i32 %148, 1
store i32 %149, i32* %11
br label %29
150: ; preds = %29
%151 = load i32, i32* %12
%152 = icmp ne i32 %151, -1
br i1 %152, label %153, label %154
153: ; preds = %150
store i32 0, i32* %5
br label %155
154: ; preds = %150
store i32 1, i32* %5
br label %155
155: ; preds = %16, %23, %141, %153, %154
%156 = load i32, i32* %5
ret i32 %156
}

LLVM IR (-O2):
define i32 @bit_entry_64(i8* %0, i32 %1, i32* nocapture %2, i32* nocapture %3) {
%5 = icmp eq i8* %0, null
%6 = add i32 %1, -65
%7 = icmp ult i32 %6, -64
%8 = or i1 %5, %7
br i1 %8, label %51, label %9
9: ; preds = %4
%10 = tail call i32 @strlen(i8* %0)
%11 = add nsw i32 %1, -1
%12 = icmp eq i32 %10, 0
br i1 %12, label %47, label %13
13: ; preds = %9
%14 = zext i32 %10 to i64
br label %15
15: ; preds = %13, %43
%16 = phi i64 [ 0, %13 ], [ %45, %43 ]
%17 = phi i32 [ %11, %13 ], [ %44, %43 ]
%18 = getelementptr inbounds i8, i8* %0, i64 %16
%19 = load i8, i8* %18
switch i8 %19, label %51 [
i8 123, label %43
i8 125, label %43
i8 32, label %43
i8 9, label %43
i8 48, label %20
i8 49, label %27
i8 45, label %33
i8 42, label %33
]
20: ; preds = %15
%21 = shl nuw i32 1, %17
%22 = xor i32 %21, -1
%23 = load i32, i32* %2
%24 = and i32 %23, %22
store i32 %24, i32* %2
%25 = load i32, i32* %3
%26 = or i32 %25, %21
br label %40
27: ; preds = %15
%28 = shl nuw i32 1, %17
%29 = load i32, i32* %2
%30 = or i32 %29, %28
store i32 %30, i32* %2
%31 = load i32, i32* %3
%32 = or i32 %31, %28
br label %40
33: ; preds = %15, %15
%34 = shl nuw i32 1, %17
%35 = xor i32 %34, -1
%36 = load i32, i32* %2
%37 = and i32 %36, %35
store i32 %37, i32* %2
%38 = load i32, i32* %3
%39 = and i32 %38, %35
br label %40
40: ; preds = %27, %33, %20
%41 = phi i32 [ %26, %20 ], [ %39, %33 ], [ %32, %27 ]
store i32 %41, i32* %3
%42 = add nsw i32 %17, -1
br label %43
43: ; preds = %40, %15, %15, %15, %15
%44 = phi i32 [ %17, %15 ], [ %17, %15 ], [ %17, %15 ], [ %17, %15 ], [ %42, %40 ]
%45 = add nuw nsw i64 %16, 1
%46 = icmp eq i64 %45, %14
br i1 %46, label %47, label %15
47: ; preds = %43, %9
%48 = phi i32 [ %11, %9 ], [ %44, %43 ]
%49 = icmp eq i32 %48, -1
%50 = zext i1 %49 to i32
br label %51
51: ; preds = %15, %47, %4
%52 = phi i32 [ 0, %4 ], [ %50, %47 ], [ 0, %15 ]
ret i32 %52
}