#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 MAC_GEN(unsigned char const *, unsigned char const *, unsigned long long,
            unsigned char *, unsigned long long *);
int MAC_VERIF(const unsigned char *_K, const unsigned char *_M,
              unsigned long long _mlen, const unsigned char *_C,
              unsigned long long _clen) {
  int result = 0;
  unsigned long long d, len = 0;
  unsigned char tag[16];
  result = MAC_GEN(_K, _M, _mlen, tag, &len);
  if (len != _clen)
    result |= 1;
  for (d = 0; d < len; d++) {
    if (tag[d] != _C[d])
      result |= 1;
  }
  if (result != 0)
    return -1;
  return 0;
}


x86 assembly (clang, -O0):
<MAC_VERIF>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
lea    -0x60(%rbp),%rcx
lea    -0x48(%rbp),%r8
call   1030 <MAC_GEN@plt>
mov    %eax,-0x34(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x30(%rbp),%rax
je     116e <MAC_VERIF+0x5e>
mov    -0x34(%rbp),%eax
or     $0x1,%eax
mov    %eax,-0x34(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    11c0 <MAC_VERIF+0xb0>
mov    -0x40(%rbp),%rax
movzbl -0x60(%rbp,%rax,1),%eax
mov    -0x28(%rbp),%rcx
mov    -0x40(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     11aa <MAC_VERIF+0x9a>
mov    -0x34(%rbp),%eax
or     $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11af <MAC_VERIF+0x9f>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1176 <MAC_VERIF+0x66>
cmpl   $0x0,-0x34(%rbp)
je     11d6 <MAC_VERIF+0xc6>
movl   $0xffffffff,-0x4(%rbp)
jmp    11dd <MAC_VERIF+0xcd>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MAC_VERIF>:
push   %r14
push   %rbx
sub    $0x18,%rsp
mov    %r8,%r14
mov    %rcx,%rbx
movq   $0x0,0x10(%rsp)
mov    %rsp,%rcx
lea    0x10(%rsp),%r8
call   1030 <MAC_GEN@plt>
mov    0x10(%rsp),%r8
xor    %edx,%edx
cmp    %r14,%r8
setne  %dl
or     %eax,%edx
test   %r8,%r8
je     12cf <MAC_VERIF+0x1bf>
cmp    $0x8,%r8
jae    1158 <MAC_VERIF+0x48>
xor    %eax,%eax
jmp    12b8 <MAC_VERIF+0x1a8>
mov    %r8,%rax
and    $0xfffffffffffffff8,%rax
movd   %edx,%xmm0
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     12ab <MAC_VERIF+0x19b>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
pxor   %xmm1,%xmm1
xor    %esi,%esi
pcmpeqd %xmm2,%xmm2
movdqa 0xe6c(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movd   0x4(%rsp,%rsi,1),%xmm6
movd   (%rbx,%rsi,1),%xmm5
movd   0x4(%rbx,%rsi,1),%xmm4
pcmpeqb %xmm6,%xmm4
pcmpeqb (%rsp,%rsi,1),%xmm5
pxor   %xmm2,%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
pand   %xmm3,%xmm5
por    %xmm0,%xmm5
pxor   %xmm2,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm3,%xmm4
por    %xmm1,%xmm4
movq   0x8(%rsp,%rsi,1),%xmm1
movd   0xc(%rsp,%rsi,1),%xmm6
movd   0x8(%rbx,%rsi,1),%xmm0
pcmpeqb %xmm1,%xmm0
movd   0xc(%rbx,%rsi,1),%xmm1
pcmpeqb %xmm6,%xmm1
pxor   %xmm2,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
pand   %xmm3,%xmm0
por    %xmm5,%xmm0
pxor   %xmm2,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
pand   %xmm3,%xmm1
por    %xmm4,%xmm1
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    11a0 <MAC_VERIF+0x90>
test   $0x1,%dl
je     128f <MAC_VERIF+0x17f>
movq   (%rsp,%rsi,1),%xmm2
movd   0x4(%rsp,%rsi,1),%xmm3
movd   (%rbx,%rsi,1),%xmm4
pcmpeqb %xmm2,%xmm4
movd   0x4(%rbx,%rsi,1),%xmm2
pcmpeqb %xmm3,%xmm2
pcmpeqd %xmm3,%xmm3
pxor   %xmm3,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
movdqa 0xd8d(%rip),%xmm5
pand   %xmm5,%xmm4
por    %xmm4,%xmm0
pxor   %xmm3,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
pand   %xmm5,%xmm2
por    %xmm2,%xmm1
por    %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
por    %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
por    %xmm1,%xmm0
movd   %xmm0,%edx
jmp    12ca <MAC_VERIF+0x1ba>
pxor   %xmm1,%xmm1
xor    %esi,%esi
test   $0x1,%dl
jne    123d <MAC_VERIF+0x12d>
jmp    128f <MAC_VERIF+0x17f>
mov    (%rsp,%rax,1),%cl
xor    %esi,%esi
cmp    (%rbx,%rax,1),%cl
setne  %sil
or     %esi,%edx
add    $0x1,%rax
cmp    %rax,%r8
jne    12b8 <MAC_VERIF+0x1a8>
neg    %edx
sbb    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define i32 @MAC_VERIF(i8* %0, i8* %1, i64 %2, i8* %3, i64 %4) {
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i64
%10 = alloca i8*
%11 = alloca i64
%12 = alloca i32
%13 = alloca i64
%14 = alloca i64
%15 = alloca [16 x i8]
store i8* %0, i8** %7
store i8* %1, i8** %8
store i64 %2, i64* %9
store i8* %3, i8** %10
store i64 %4, i64* %11
store i32 0, i32* %12
store i64 0, i64* %14
%16 = load i8*, i8** %7
%17 = load i8*, i8** %8
%18 = load i64, i64* %9
%19 = getelementptr inbounds [16 x i8], [16 x i8]* %15, i64 0, i64 0
%20 = call i32 @MAC_GEN(i8* %16, i8* %17, i64 %18, i8* %19, i64* %14)
store i32 %20, i32* %12
%21 = load i64, i64* %14
%22 = load i64, i64* %11
%23 = icmp ne i64 %21, %22
br i1 %23, label %24, label %27
24: ; preds = %5
%25 = load i32, i32* %12
%26 = or i32 %25, 1
store i32 %26, i32* %12
br label %27
27: ; preds = %24, %5
store i64 0, i64* %13
br label %28
28: ; preds = %47, %27
%29 = load i64, i64* %13
%30 = load i64, i64* %14
%31 = icmp ult i64 %29, %30
br i1 %31, label %32, label %50
32: ; preds = %28
%33 = load i64, i64* %13
%34 = getelementptr inbounds [16 x i8], [16 x i8]* %15, i64 0, i64 %33
%35 = load i8, i8* %34
%36 = zext i8 %35 to i32
%37 = load i8*, i8** %10
%38 = load i64, i64* %13
%39 = getelementptr inbounds i8, i8* %37, i64 %38
%40 = load i8, i8* %39
%41 = zext i8 %40 to i32
%42 = icmp ne i32 %36, %41
br i1 %42, label %43, label %46
43: ; preds = %32
%44 = load i32, i32* %12
%45 = or i32 %44, 1
store i32 %45, i32* %12
br label %46
46: ; preds = %43, %32
br label %47
47: ; preds = %46
%48 = load i64, i64* %13
%49 = add i64 %48, 1
store i64 %49, i64* %13
br label %28
50: ; preds = %28
%51 = load i32, i32* %12
%52 = icmp ne i32 %51, 0
br i1 %52, label %53, label %54
53: ; preds = %50
store i32 -1, i32* %6
br label %55
54: ; preds = %50
store i32 0, i32* %6
br label %55
55: ; preds = %54, %53
%56 = load i32, i32* %6
ret i32 %56
}

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