#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 */
int /*<<< orphan*/ sscanf(char *, char *, int *);
int strlen(char *);
int get_effective_genes(char **rules, int numRxns, int *gene_effective,
                        int num_genes) {
  int i, j, n, k, r, stat, stata, geneid, ctrlBrackets;
  char opera;
  for (i = 0; i < num_genes; i++)
    gene_effective[i] = 0;
  i = 0;
  for (k = 0; k < numRxns; k++) {
    n = strlen(rules[k]);
    if (n > 15) {
      stat = 1;
      opera = '&';
      for (j = 15; j < n; j++) {
        if (rules[k][j] == '(') {
          ctrlBrackets = 1;
          sscanf(rules[k] + j + 1, "%d", &geneid);
          gene_effective[geneid - 1] = 1;
        }
      }
    }
  }
  r = 0;
  for (i = 0; i < num_genes; i++) {
    if (gene_effective[i] > 0)
      r++;
  }
  return r;
}


x86 assembly (clang, -O0):
<get_effective_genes>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1166 <get_effective_genes+0x46>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    113d <get_effective_genes+0x1d>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1246 <get_effective_genes+0x126>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x28(%rbp)
cmpl   $0xf,-0x28(%rbp)
jle    1233 <get_effective_genes+0x113>
movl   $0x1,-0x34(%rbp)
movb   $0x26,-0x41(%rbp)
movl   $0xf,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    122e <get_effective_genes+0x10e>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x28,%eax
jne    121b <get_effective_genes+0xfb>
movl   $0x1,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
add    $0x1,%rdi
lea    0xe02(%rip),%rsi
lea    -0x3c(%rbp),%rdx
call   1040 <sscanf@plt>
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    1220 <get_effective_genes+0x100>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11b0 <get_effective_genes+0x90>
jmp    1233 <get_effective_genes+0x113>
jmp    1238 <get_effective_genes+0x118>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1174 <get_effective_genes+0x54>
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    128e <get_effective_genes+0x16e>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    127b <get_effective_genes+0x15b>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1280 <get_effective_genes+0x160>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1254 <get_effective_genes+0x134>
mov    -0x30(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_effective_genes>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdx,%r15
mov    %esi,%r14d
mov    %rdi,%rbp
mov    %ecx,%ebx
mov    %ecx,(%rsp)
test   %ecx,%ecx
jle    1162 <get_effective_genes+0x32>
lea    0x0(,%rbx,4),%rdx
mov    %r15,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
mov    %rbx,0x8(%rsp)
mov    %r15,%rbx
test   %r14d,%r14d
jle    1200 <get_effective_genes+0xd0>
mov    %r14d,%eax
mov    %rax,0x10(%rsp)
xor    %r13d,%r13d
lea    0x4(%rsp),%r12
jmp    119b <get_effective_genes+0x6b>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r13
cmp    0x10(%rsp),%r13
je     1200 <get_effective_genes+0xd0>
mov    0x0(%rbp,%r13,8),%rdi
call   1030 <strlen@plt>
cmp    $0x10,%eax
jl     1190 <get_effective_genes+0x60>
mov    %eax,%eax
mov    $0xf,%r14d
sub    %rax,%r14
mov    $0x10,%r15d
jmp    11d2 <get_effective_genes+0xa2>
nopl   (%rax)
lea    (%r14,%r15,1),%rax
add    $0x1,%rax
add    $0x1,%r15
cmp    $0x10,%rax
je     1190 <get_effective_genes+0x60>
mov    0x0(%rbp,%r13,8),%rdi
cmpb   $0x28,-0x1(%rdi,%r15,1)
jne    11c0 <get_effective_genes+0x90>
add    %r15,%rdi
lea    0xe17(%rip),%rsi
mov    %r12,%rdx
call   1050 <sscanf@plt>
movslq 0x4(%rsp),%rax
movl   $0x1,-0x4(%rbx,%rax,4)
jmp    11c0 <get_effective_genes+0x90>
mov    (%rsp),%eax
test   %eax,%eax
jle    121a <get_effective_genes+0xea>
cmp    $0x8,%eax
jae    1221 <get_effective_genes+0xf1>
xor    %ecx,%ecx
xor    %eax,%eax
mov    0x8(%rsp),%rbp
jmp    12f0 <get_effective_genes+0x1c0>
xor    %eax,%eax
jmp    1304 <get_effective_genes+0x1d4>
mov    0x8(%rsp),%rbp
mov    %ebp,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rax
shr    $0x3,%rax
add    $0x1,%rax
test   %rdx,%rdx
je     1313 <get_effective_genes+0x1e3>
mov    %rax,%rsi
and    $0xfffffffffffffffe,%rsi
pxor   %xmm2,%xmm2
xor    %edx,%edx
pxor   %xmm0,%xmm0
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movdqu (%rbx,%rdx,4),%xmm3
movdqu 0x10(%rbx,%rdx,4),%xmm4
movdqu 0x20(%rbx,%rdx,4),%xmm5
movdqu 0x30(%rbx,%rdx,4),%xmm6
pcmpgtd %xmm2,%xmm3
psubd  %xmm3,%xmm0
pcmpgtd %xmm2,%xmm4
psubd  %xmm4,%xmm1
pcmpgtd %xmm2,%xmm5
psubd  %xmm5,%xmm0
pcmpgtd %xmm2,%xmm6
psubd  %xmm6,%xmm1
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1260 <get_effective_genes+0x130>
test   $0x1,%al
je     12c4 <get_effective_genes+0x194>
movdqu (%rbx,%rdx,4),%xmm2
movdqu 0x10(%rbx,%rdx,4),%xmm3
pxor   %xmm4,%xmm4
pcmpgtd %xmm4,%xmm2
psubd  %xmm2,%xmm0
pcmpgtd %xmm4,%xmm3
psubd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %rbp,%rcx
je     1304 <get_effective_genes+0x1d4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %edx,%edx
cmpl   $0x0,(%rbx,%rcx,4)
setg   %dl
add    %edx,%eax
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    12f0 <get_effective_genes+0x1c0>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
pxor   %xmm0,%xmm0
xor    %edx,%edx
pxor   %xmm1,%xmm1
test   $0x1,%al
jne    12a5 <get_effective_genes+0x175>
jmp    12c4 <get_effective_genes+0x194>

LLVM IR (-O0):
@.str = [3 x i8] c"%d\00"
define i32 @get_effective_genes(i8** %0, i32 %1, i32* %2, i32 %3) {
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i8
store i8** %0, i8*** %5
store i32 %1, i32* %6
store i32* %2, i32** %7
store i32 %3, i32* %8
store i32 0, i32* %9
br label %19
19: ; preds = %28, %4
%20 = load i32, i32* %9
%21 = load i32, i32* %8
%22 = icmp slt i32 %20, %21
br i1 %22, label %23, label %31
23: ; preds = %19
%24 = load i32*, i32** %7
%25 = load i32, i32* %9
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds i32, i32* %24, i64 %26
store i32 0, i32* %27
br label %28
28: ; preds = %23
%29 = load i32, i32* %9
%30 = add nsw i32 %29, 1
store i32 %30, i32* %9
br label %19
31: ; preds = %19
store i32 0, i32* %9
store i32 0, i32* %12
br label %32
32: ; preds = %84, %31
%33 = load i32, i32* %12
%34 = load i32, i32* %6
%35 = icmp slt i32 %33, %34
br i1 %35, label %36, label %87
36: ; preds = %32
%37 = load i8**, i8*** %5
%38 = load i32, i32* %12
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i8*, i8** %37, i64 %39
%41 = load i8*, i8** %40
%42 = call i32 @strlen(i8* %41)
store i32 %42, i32* %11
%43 = load i32, i32* %11
%44 = icmp sgt i32 %43, 15
br i1 %44, label %45, label %83
45: ; preds = %36
store i32 1, i32* %14
store i8 38, i8* %18
store i32 15, i32* %10
br label %46
46: ; preds = %79, %45
%47 = load i32, i32* %10
%48 = load i32, i32* %11
%49 = icmp slt i32 %47, %48
br i1 %49, label %50, label %82
50: ; preds = %46
%51 = load i8**, i8*** %5
%52 = load i32, i32* %12
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i8*, i8** %51, i64 %53
%55 = load i8*, i8** %54
%56 = load i32, i32* %10
%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, 40
br i1 %61, label %62, label %78
62: ; preds = %50
store i32 1, i32* %17
%63 = load i8**, i8*** %5
%64 = load i32, i32* %12
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds i8*, i8** %63, i64 %65
%67 = load i8*, i8** %66
%68 = load i32, i32* %10
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i8, i8* %67, i64 %69
%71 = getelementptr inbounds i8, i8* %70, i64 1
%72 = call i32 @sscanf(i8* %71, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %16)
%73 = load i32*, i32** %7
%74 = load i32, i32* %16
%75 = sub nsw i32 %74, 1
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds i32, i32* %73, i64 %76
store i32 1, i32* %77
br label %78
78: ; preds = %62, %50
br label %79
79: ; preds = %78
%80 = load i32, i32* %10
%81 = add nsw i32 %80, 1
store i32 %81, i32* %10
br label %46
82: ; preds = %46
br label %83
83: ; preds = %82, %36
br label %84
84: ; preds = %83
%85 = load i32, i32* %12
%86 = add nsw i32 %85, 1
store i32 %86, i32* %12
br label %32
87: ; preds = %32
store i32 0, i32* %13
store i32 0, i32* %9
br label %88
88: ; preds = %103, %87
%89 = load i32, i32* %9
%90 = load i32, i32* %8
%91 = icmp slt i32 %89, %90
br i1 %91, label %92, label %106
92: ; preds = %88
%93 = load i32*, i32** %7
%94 = load i32, i32* %9
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds i32, i32* %93, i64 %95
%97 = load i32, i32* %96
%98 = icmp sgt i32 %97, 0
br i1 %98, label %99, label %102
99: ; preds = %92
%100 = load i32, i32* %13
%101 = add nsw i32 %100, 1
store i32 %101, i32* %13
br label %102
102: ; preds = %99, %92
br label %103
103: ; preds = %102
%104 = load i32, i32* %9
%105 = add nsw i32 %104, 1
store i32 %105, i32* %9
br label %88
106: ; preds = %88
%107 = load i32, i32* %13
ret i32 %107
}

LLVM IR (-O2):
@.str = [3 x i8] c"%d\00"
define i32 @get_effective_genes(i8** nocapture %0, i32 %1, i32* nocapture %2, i32 %3) {
%5 = alloca i32
%6 = bitcast i32* %5 to i8*
%7 = icmp sgt i32 %3, 0
br i1 %7, label %8, label %12
8: ; preds = %4
%9 = bitcast i32* %2 to i8*
%10 = zext i32 %3 to i64
%11 = shl nuw nsw i64 %10, 2
br label %12
12: ; preds = %8, %4
%13 = icmp sgt i32 %1, 0
br i1 %13, label %14, label %16
14: ; preds = %12
%15 = zext i32 %1 to i64
br label %91
16: ; preds = %115, %12
br i1 %7, label %17, label %128
17: ; preds = %16
%18 = zext i32 %3 to i64
%19 = icmp ult i32 %3, 8
br i1 %19, label %88, label %20
20: ; preds = %17
%21 = and i64 %18, 4294967288
%22 = add nsw i64 %21, -8
%23 = lshr exact i64 %22, 3
%24 = add nuw nsw i64 %23, 1
%25 = and i64 %24, 1
%26 = icmp eq i64 %22, 0
br i1 %26, label %62, label %27
27: ; preds = %20
%28 = and i64 %24, 4611686018427387902
br label %29
29: ; preds = %29, %27
%30 = phi i64 [ 0, %27 ], [ %59, %29 ]
%31 = phi <4 x i32> [ zeroinitializer, %27 ], [ %57, %29 ]
%32 = phi <4 x i32> [ zeroinitializer, %27 ], [ %58, %29 ]
%33 = phi i64 [ 0, %27 ], [ %60, %29 ]
%34 = getelementptr inbounds i32, i32* %2, i64 %30
%35 = bitcast i32* %34 to <4 x i32>*
%36 = load <4 x i32>, <4 x i32>* %35
%37 = getelementptr inbounds i32, i32* %34, i64 4
%38 = bitcast i32* %37 to <4 x i32>*
%39 = load <4 x i32>, <4 x i32>* %38
%40 = icmp sgt <4 x i32> %36, zeroinitializer
%41 = icmp sgt <4 x i32> %39, zeroinitializer
%42 = zext <4 x i1> %40 to <4 x i32>
%43 = zext <4 x i1> %41 to <4 x i32>
%44 = add <4 x i32> %31, %42
%45 = add <4 x i32> %32, %43
%46 = or i64 %30, 8
%47 = getelementptr inbounds i32, i32* %2, i64 %46
%48 = bitcast i32* %47 to <4 x i32>*
%49 = load <4 x i32>, <4 x i32>* %48
%50 = getelementptr inbounds i32, i32* %47, i64 4
%51 = bitcast i32* %50 to <4 x i32>*
%52 = load <4 x i32>, <4 x i32>* %51
%53 = icmp sgt <4 x i32> %49, zeroinitializer
%54 = icmp sgt <4 x i32> %52, zeroinitializer
%55 = zext <4 x i1> %53 to <4 x i32>
%56 = zext <4 x i1> %54 to <4 x i32>
%57 = add <4 x i32> %44, %55
%58 = add <4 x i32> %45, %56
%59 = add nuw i64 %30, 16
%60 = add i64 %33, 2
%61 = icmp eq i64 %60, %28
br i1 %61, label %62, label %29
62: ; preds = %29, %20
%63 = phi <4 x i32> [ undef, %20 ], [ %57, %29 ]
%64 = phi <4 x i32> [ undef, %20 ], [ %58, %29 ]
%65 = phi i64 [ 0, %20 ], [ %59, %29 ]
%66 = phi <4 x i32> [ zeroinitializer, %20 ], [ %57, %29 ]
%67 = phi <4 x i32> [ zeroinitializer, %20 ], [ %58, %29 ]
%68 = icmp eq i64 %25, 0
br i1 %68, label %82, label %69
69: ; preds = %62
%70 = getelementptr inbounds i32, i32* %2, i64 %65
%71 = bitcast i32* %70 to <4 x i32>*
%72 = load <4 x i32>, <4 x i32>* %71
%73 = getelementptr inbounds i32, i32* %70, i64 4
%74 = bitcast i32* %73 to <4 x i32>*
%75 = load <4 x i32>, <4 x i32>* %74
%76 = icmp sgt <4 x i32> %72, zeroinitializer
%77 = icmp sgt <4 x i32> %75, zeroinitializer
%78 = zext <4 x i1> %76 to <4 x i32>
%79 = zext <4 x i1> %77 to <4 x i32>
%80 = add <4 x i32> %66, %78
%81 = add <4 x i32> %67, %79
br label %82
82: ; preds = %62, %69
%83 = phi <4 x i32> [ %63, %62 ], [ %80, %69 ]
%84 = phi <4 x i32> [ %64, %62 ], [ %81, %69 ]
%85 = add <4 x i32> %84, %83
%86 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %85)
%87 = icmp eq i64 %21, %18
br i1 %87, label %128, label %88
88: ; preds = %17, %82
%89 = phi i64 [ 0, %17 ], [ %21, %82 ]
%90 = phi i32 [ 0, %17 ], [ %86, %82 ]
br label %118
91: ; preds = %14, %115
%92 = phi i64 [ 0, %14 ], [ %116, %115 ]
%93 = getelementptr inbounds i8*, i8** %0, i64 %92
%94 = load i8*, i8** %93
%95 = call i32 @strlen(i8* %94)
%96 = icmp sgt i32 %95, 15
br i1 %96, label %97, label %115
97: ; preds = %91
%98 = zext i32 %95 to i64
br label %99
99: ; preds = %97, %112
%100 = phi i64 [ 15, %97 ], [ %113, %112 ]
%101 = load i8*, i8** %93
%102 = getelementptr inbounds i8, i8* %101, i64 %100
%103 = load i8, i8* %102
%104 = icmp eq i8 %103, 40
br i1 %104, label %105, label %112
105: ; preds = %99
%106 = getelementptr inbounds i8, i8* %102, i64 1
%107 = call i32 @sscanf(i8* %106, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %5)
%108 = load i32, i32* %5
%109 = add nsw i32 %108, -1
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds i32, i32* %2, i64 %110
store i32 1, i32* %111
br label %112
112: ; preds = %99, %105
%113 = add nuw nsw i64 %100, 1
%114 = icmp eq i64 %113, %98
br i1 %114, label %115, label %99
115: ; preds = %112, %91
%116 = add nuw nsw i64 %92, 1
%117 = icmp eq i64 %116, %15
br i1 %117, label %16, label %91
118: ; preds = %88, %118
%119 = phi i64 [ %126, %118 ], [ %89, %88 ]
%120 = phi i32 [ %125, %118 ], [ %90, %88 ]
%121 = getelementptr inbounds i32, i32* %2, i64 %119
%122 = load i32, i32* %121
%123 = icmp sgt i32 %122, 0
%124 = zext i1 %123 to i32
%125 = add nuw nsw i32 %120, %124
%126 = add nuw nsw i64 %119, 1
%127 = icmp eq i64 %126, %18
br i1 %127, label %128, label %118
128: ; preds = %118, %82, %16
%129 = phi i32 [ 0, %16 ], [ %86, %82 ], [ %125, %118 ]
ret i32 %129
}