#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__ {
  int rm_so;
};
typedef TYPE_1__ regmatch_t;

/* Variables and functions */
int regex_count(regmatch_t matches[], int max) {
  int i = max, total = 0;
  while (i--) {
    if (matches[i].rm_so != -1)
      total++;
  }
  return total;
}


x86 assembly (clang, -O0):
<regex_count>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x10(%rbp)
cmp    $0x0,%eax
je     114c <regex_count+0x4c>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
je     1147 <regex_count+0x47>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1118 <regex_count+0x18>
mov    -0x14(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<regex_count>:
test   %esi,%esi
je     1258 <regex_count+0x158>
movslq %esi,%rcx
add    $0xffffffff,%esi
xor    %eax,%eax
cmp    $0x7,%esi
jb     1240 <regex_count+0x140>
add    $0x1,%rsi
mov    %rsi,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     125b <regex_count+0x15b>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
lea    (%rdi,%rcx,4),%r10
add    $0xfffffffffffffff0,%r10
pxor   %xmm0,%xmm0
mov    $0xfffffffffffffffc,%rdx
pcmpeqd %xmm2,%xmm2
movdqa 0xe9e(%rip),%xmm3
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
movdqu -0x20(%r10,%rdx,4),%xmm4
movdqu -0x10(%r10,%rdx,4),%xmm5
movdqu (%r10,%rdx,4),%xmm6
movdqu 0x10(%r10,%rdx,4),%xmm7
pshufd $0x1b,%xmm7,%xmm7
pshufd $0x1b,%xmm6,%xmm6
pcmpeqd %xmm2,%xmm7
paddd  %xmm0,%xmm7
pcmpeqd %xmm2,%xmm6
paddd  %xmm1,%xmm6
pshufd $0x1b,%xmm5,%xmm0
pcmpeqd %xmm2,%xmm0
pshufd $0x1b,%xmm4,%xmm1
pcmpeqd %xmm2,%xmm1
paddd  %xmm3,%xmm0
paddd  %xmm7,%xmm0
paddd  %xmm3,%xmm1
paddd  %xmm6,%xmm1
add    $0xfffffffffffffff0,%rdx
add    $0xfffffffffffffffe,%rax
jne    1170 <regex_count+0x70>
add    $0x3,%rdx
test   $0x1,%r9b
je     1210 <regex_count+0x110>
add    %rcx,%rdx
movdqu -0x1c(%rdi,%rdx,4),%xmm2
movdqu -0xc(%rdi,%rdx,4),%xmm3
pshufd $0x1b,%xmm3,%xmm3
pshufd $0x1b,%xmm2,%xmm2
pcmpeqd %xmm4,%xmm4
pcmpeqd %xmm4,%xmm3
paddd  %xmm3,%xmm0
pcmpeqd %xmm4,%xmm2
paddd  %xmm2,%xmm1
psubd  %xmm4,%xmm0
psubd  %xmm4,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %r8,%rsi
je     1257 <regex_count+0x157>
sub    %r8,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %edx,%edx
cmpl   $0xffffffff,-0x4(%rdi,%rcx,4)
lea    -0x1(%rcx),%rsi
setne  %dl
add    %edx,%eax
mov    %rsi,%rcx
test   %esi,%esi
jne    1240 <regex_count+0x140>
ret
xor    %eax,%eax
ret
pxor   %xmm0,%xmm0
mov    $0xffffffffffffffff,%rdx
pxor   %xmm1,%xmm1
test   $0x1,%r9b
jne    11db <regex_count+0xdb>
jmp    1210 <regex_count+0x110>

LLVM IR (-O0):
%struct.TYPE_3__ = type { i32 }
define i32 @regex_count(%struct.TYPE_3__* %0, i32 %1) {
%3 = alloca %struct.TYPE_3__*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
store %struct.TYPE_3__* %0, %struct.TYPE_3__** %3
store i32 %1, i32* %4
%7 = load i32, i32* %4
store i32 %7, i32* %5
store i32 0, i32* %6
br label %8
8: ; preds = %23, %2
%9 = load i32, i32* %5
%10 = add nsw i32 %9, -1
store i32 %10, i32* %5
%11 = icmp ne i32 %9, 0
br i1 %11, label %12, label %24
12: ; preds = %8
%13 = load %struct.TYPE_3__*, %struct.TYPE_3__** %3
%14 = load i32, i32* %5
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %13, i64 %15
%17 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %16, i32 0, i32 0
%18 = load i32, i32* %17
%19 = icmp ne i32 %18, -1
br i1 %19, label %20, label %23
20: ; preds = %12
%21 = load i32, i32* %6
%22 = add nsw i32 %21, 1
store i32 %22, i32* %6
br label %23
23: ; preds = %20, %12
br label %8
24: ; preds = %8
%25 = load i32, i32* %6
ret i32 %25
}

LLVM IR (-O2):
%struct.TYPE_3__ = type { i32 }
define i32 @regex_count(%struct.TYPE_3__* nocapture %0, i32 %1) {
%3 = icmp eq i32 %1, 0
br i1 %3, label %108, label %4
4: ; preds = %2
%5 = sext i32 %1 to i64
%6 = add i32 %1, -1
%7 = zext i32 %6 to i64
%8 = add nuw nsw i64 %7, 1
%9 = icmp ult i32 %6, 7
br i1 %9, label %94, label %10
10: ; preds = %4
%11 = and i64 %8, 8589934584
%12 = sub nsw i64 %5, %11
%13 = add nsw i64 %11, -8
%14 = lshr exact i64 %13, 3
%15 = add nuw nsw i64 %14, 1
%16 = and i64 %15, 1
%17 = icmp eq i64 %13, 0
br i1 %17, label %64, label %18
18: ; preds = %10
%19 = and i64 %15, 4611686018427387902
br label %20
20: ; preds = %20, %18
%21 = phi i64 [ 0, %18 ], [ %59, %20 ]
%22 = phi <4 x i32> [ zeroinitializer, %18 ], [ %57, %20 ]
%23 = phi <4 x i32> [ zeroinitializer, %18 ], [ %58, %20 ]
%24 = phi i64 [ 0, %18 ], [ %60, %20 ]
%25 = xor i64 %21, -1
%26 = add i64 %25, %5
%27 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %0, i64 %26, i32 0
%28 = getelementptr inbounds i32, i32* %27, i64 -3
%29 = bitcast i32* %28 to <4 x i32>*
%30 = load <4 x i32>, <4 x i32>* %29
%31 = shufflevector <4 x i32> %30, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%32 = getelementptr inbounds i32, i32* %27, i64 -7
%33 = bitcast i32* %32 to <4 x i32>*
%34 = load <4 x i32>, <4 x i32>* %33
%35 = shufflevector <4 x i32> %34, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%36 = icmp ne <4 x i32> %31, <i32 -1, i32 -1, i32 -1, i32 -1>
%37 = icmp ne <4 x i32> %35, <i32 -1, i32 -1, i32 -1, i32 -1>
%38 = zext <4 x i1> %36 to <4 x i32>
%39 = zext <4 x i1> %37 to <4 x i32>
%40 = add <4 x i32> %22, %38
%41 = add <4 x i32> %23, %39
%42 = sub nuw nsw i64 -9, %21
%43 = add i64 %42, %5
%44 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %0, i64 %43, i32 0
%45 = getelementptr inbounds i32, i32* %44, i64 -3
%46 = bitcast i32* %45 to <4 x i32>*
%47 = load <4 x i32>, <4 x i32>* %46
%48 = shufflevector <4 x i32> %47, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%49 = getelementptr inbounds i32, i32* %44, i64 -7
%50 = bitcast i32* %49 to <4 x i32>*
%51 = load <4 x i32>, <4 x i32>* %50
%52 = shufflevector <4 x i32> %51, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%53 = icmp ne <4 x i32> %48, <i32 -1, i32 -1, i32 -1, i32 -1>
%54 = icmp ne <4 x i32> %52, <i32 -1, i32 -1, i32 -1, i32 -1>
%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> %40, %55
%58 = add <4 x i32> %41, %56
%59 = add nuw i64 %21, 16
%60 = add i64 %24, 2
%61 = icmp eq i64 %60, %19
br i1 %61, label %62, label %20
62: ; preds = %20
%63 = sub i64 -17, %21
br label %64
64: ; preds = %62, %10
%65 = phi <4 x i32> [ undef, %10 ], [ %57, %62 ]
%66 = phi <4 x i32> [ undef, %10 ], [ %58, %62 ]
%67 = phi i64 [ -1, %10 ], [ %63, %62 ]
%68 = phi <4 x i32> [ zeroinitializer, %10 ], [ %57, %62 ]
%69 = phi <4 x i32> [ zeroinitializer, %10 ], [ %58, %62 ]
%70 = icmp eq i64 %16, 0
br i1 %70, label %88, label %71
71: ; preds = %64
%72 = add i64 %67, %5
%73 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %0, i64 %72, i32 0
%74 = getelementptr inbounds i32, i32* %73, i64 -3
%75 = bitcast i32* %74 to <4 x i32>*
%76 = load <4 x i32>, <4 x i32>* %75
%77 = shufflevector <4 x i32> %76, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%78 = getelementptr inbounds i32, i32* %73, i64 -7
%79 = bitcast i32* %78 to <4 x i32>*
%80 = load <4 x i32>, <4 x i32>* %79
%81 = shufflevector <4 x i32> %80, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%82 = icmp ne <4 x i32> %77, <i32 -1, i32 -1, i32 -1, i32 -1>
%83 = icmp ne <4 x i32> %81, <i32 -1, i32 -1, i32 -1, i32 -1>
%84 = zext <4 x i1> %82 to <4 x i32>
%85 = zext <4 x i1> %83 to <4 x i32>
%86 = add <4 x i32> %68, %84
%87 = add <4 x i32> %69, %85
br label %88
88: ; preds = %64, %71
%89 = phi <4 x i32> [ %65, %64 ], [ %86, %71 ]
%90 = phi <4 x i32> [ %66, %64 ], [ %87, %71 ]
%91 = add <4 x i32> %90, %89
%92 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %91)
%93 = icmp eq i64 %8, %11
br i1 %93, label %108, label %94
94: ; preds = %4, %88
%95 = phi i64 [ %5, %4 ], [ %12, %88 ]
%96 = phi i32 [ 0, %4 ], [ %92, %88 ]
br label %97
97: ; preds = %94, %97
%98 = phi i64 [ %100, %97 ], [ %95, %94 ]
%99 = phi i32 [ %105, %97 ], [ %96, %94 ]
%100 = add nsw i64 %98, -1
%101 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %0, i64 %100, i32 0
%102 = load i32, i32* %101
%103 = icmp ne i32 %102, -1
%104 = zext i1 %103 to i32
%105 = add nuw nsw i32 %99, %104
%106 = trunc i64 %100 to i32
%107 = icmp eq i32 %106, 0
br i1 %107, label %108, label %97
108: ; preds = %97, %88, %2
%109 = phi i32 [ 0, %2 ], [ %92, %88 ], [ %105, %97 ]
ret i32 %109
}