unsigned char API_frame_is_correct(unsigned char *buf, unsigned int n) {
  unsigned int i;
  unsigned int length;
  unsigned int checksum = 0;
  if (buf[0] != 0x7e)
    return 0;
  length = (((unsigned int)buf[1]) << 8) | ((unsigned int)buf[2]);
  if (n < length + 4)
    return 0;
  checksum += buf[3];
  for (i = 0; i < (length - 1); i++)
    checksum += buf[4 + i];
  checksum += buf[length + 3];
  if ((checksum & 0xFF) != 0xFF)
    return 0;
  return 1;
}


x86 assembly (clang, -O0):
<API_frame_is_correct>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x7e,%eax
je     112b <API_frame_is_correct+0x2b>
movb   $0x0,-0x1(%rbp)
jmp    11dd <API_frame_is_correct+0xdd>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
shl    $0x8,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jae    115d <API_frame_is_correct+0x5d>
movb   $0x0,-0x1(%rbp)
jmp    11dd <API_frame_is_correct+0xdd>
mov    -0x10(%rbp),%rax
movzbl 0x3(%rax),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jae    11a7 <API_frame_is_correct+0xa7>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x4,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1172 <API_frame_is_correct+0x72>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    $0xff,%eax
cmp    $0xff,%eax
je     11d9 <API_frame_is_correct+0xd9>
movb   $0x0,-0x1(%rbp)
jmp    11dd <API_frame_is_correct+0xdd>
movb   $0x1,-0x1(%rbp)
movzbl -0x1(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<API_frame_is_correct>:
cmpb   $0x7e,(%rdi)
jne    1119 <API_frame_is_correct+0x19>
movzwl 0x1(%rdi),%r10d
shl    $0x30,%r10
bswap  %r10
lea    0x4(%r10),%eax
cmp    %esi,%eax
jbe    111c <API_frame_is_correct+0x1c>
xor    %eax,%eax
ret
movzbl 0x3(%rdi),%esi
mov    %r10d,%eax
add    $0xffffffff,%eax
je     12c9 <API_frame_is_correct+0x1c9>
mov    %eax,%r9d
cmp    $0x8,%eax
jae    11ba <API_frame_is_correct+0xba>
xor    %edx,%edx
mov    %rdx,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rax
and    $0x3,%rax
je     1161 <API_frame_is_correct+0x61>
nopl   0x0(%rax)
movzbl 0x4(%rdi,%rdx,1),%ecx
add    %ecx,%esi
add    $0x1,%rdx
add    $0xffffffffffffffff,%rax
jne    1150 <API_frame_is_correct+0x50>
cmp    $0x3,%r8
jb     12c9 <API_frame_is_correct+0x1c9>
neg    %r9
add    $0x4,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %edx,%eax
movzbl (%rdi,%rax,1),%eax
add    %esi,%eax
lea    0x1(%rdx),%ecx
movzbl (%rdi,%rcx,1),%ecx
add    %eax,%ecx
lea    0x2(%rdx),%eax
movzbl (%rdi,%rax,1),%eax
add    %ecx,%eax
lea    0x3(%rdx),%ecx
movzbl (%rdi,%rcx,1),%esi
add    %eax,%esi
lea    (%r9,%rdx,1),%rax
add    $0x4,%rax
add    $0x4,%rdx
cmp    $0x4,%rax
jne    1180 <API_frame_is_correct+0x80>
jmp    12c9 <API_frame_is_correct+0x1c9>
lea    -0x1(%r9),%rax
mov    %eax,%ecx
not    %ecx
xor    %edx,%edx
test   $0xfffffffc,%ecx
je     113a <API_frame_is_correct+0x3a>
shr    $0x20,%rax
jne    113a <API_frame_is_correct+0x3a>
mov    %r9d,%edx
and    $0xfffffff8,%edx
movd   %esi,%xmm0
lea    -0x8(%rdx),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     1270 <API_frame_is_correct+0x170>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
pxor   %xmm2,%xmm2
xor    %esi,%esi
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
mov    %esi,%eax
and    $0xfffffff0,%eax
movd   0x4(%rdi,%rax,1),%xmm3
movd   0x8(%rdi,%rax,1),%xmm4
punpcklbw %xmm2,%xmm3
punpcklwd %xmm2,%xmm3
paddd  %xmm0,%xmm3
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
paddd  %xmm1,%xmm4
movd   0xc(%rdi,%rax,1),%xmm0
movd   0x10(%rdi,%rax,1),%xmm1
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
paddd  %xmm3,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rcx
jne    1210 <API_frame_is_correct+0x110>
and    $0xfffffff0,%esi
or     $0x4,%rsi
jmp    1279 <API_frame_is_correct+0x179>
pxor   %xmm1,%xmm1
mov    $0x4,%esi
test   $0x1,%r8b
je     12a6 <API_frame_is_correct+0x1a6>
movd   (%rdi,%rsi,1),%xmm2
movd   0x4(%rdi,%rsi,1),%xmm3
pxor   %xmm4,%xmm4
punpcklbw %xmm4,%xmm2
punpcklwd %xmm4,%xmm2
paddd  %xmm2,%xmm0
punpcklbw %xmm4,%xmm3
punpcklwd %xmm4,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%esi
cmp    %r9,%rdx
jne    113a <API_frame_is_correct+0x3a>
movzbl 0x3(%r10,%rdi,1),%eax
add    %esi,%eax
cmp    $0xff,%al
sete   %al
ret

LLVM IR (-O0):
define zeroext i8 @API_frame_is_correct(i8* %0, i32 %1) {
%3 = alloca i8
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store i8* %0, i8** %4
store i32 %1, i32* %5
store i32 0, i32* %8
%9 = load i8*, i8** %4
%10 = getelementptr inbounds i8, i8* %9, i64 0
%11 = load i8, i8* %10
%12 = zext i8 %11 to i32
%13 = icmp ne i32 %12, 126
br i1 %13, label %14, label %15
14: ; preds = %2
store i8 0, i8* %3
br label %71
15: ; preds = %2
%16 = load i8*, i8** %4
%17 = getelementptr inbounds i8, i8* %16, i64 1
%18 = load i8, i8* %17
%19 = zext i8 %18 to i32
%20 = shl i32 %19, 8
%21 = load i8*, i8** %4
%22 = getelementptr inbounds i8, i8* %21, i64 2
%23 = load i8, i8* %22
%24 = zext i8 %23 to i32
%25 = or i32 %20, %24
store i32 %25, i32* %7
%26 = load i32, i32* %5
%27 = load i32, i32* %7
%28 = add i32 %27, 4
%29 = icmp ult i32 %26, %28
br i1 %29, label %30, label %31
30: ; preds = %15
store i8 0, i8* %3
br label %71
31: ; preds = %15
%32 = load i8*, i8** %4
%33 = getelementptr inbounds i8, i8* %32, i64 3
%34 = load i8, i8* %33
%35 = zext i8 %34 to i32
%36 = load i32, i32* %8
%37 = add i32 %36, %35
store i32 %37, i32* %8
store i32 0, i32* %6
br label %38
38: ; preds = %53, %31
%39 = load i32, i32* %6
%40 = load i32, i32* %7
%41 = sub i32 %40, 1
%42 = icmp ult i32 %39, %41
br i1 %42, label %43, label %56
43: ; preds = %38
%44 = load i8*, i8** %4
%45 = load i32, i32* %6
%46 = add i32 4, %45
%47 = zext i32 %46 to i64
%48 = getelementptr inbounds i8, i8* %44, i64 %47
%49 = load i8, i8* %48
%50 = zext i8 %49 to i32
%51 = load i32, i32* %8
%52 = add i32 %51, %50
store i32 %52, i32* %8
br label %53
53: ; preds = %43
%54 = load i32, i32* %6
%55 = add i32 %54, 1
store i32 %55, i32* %6
br label %38
56: ; preds = %38
%57 = load i8*, i8** %4
%58 = load i32, i32* %7
%59 = add i32 %58, 3
%60 = zext i32 %59 to i64
%61 = getelementptr inbounds i8, i8* %57, i64 %60
%62 = load i8, i8* %61
%63 = zext i8 %62 to i32
%64 = load i32, i32* %8
%65 = add i32 %64, %63
store i32 %65, i32* %8
%66 = load i32, i32* %8
%67 = and i32 %66, 255
%68 = icmp ne i32 %67, 255
br i1 %68, label %69, label %70
69: ; preds = %56
store i8 0, i8* %3
br label %71
70: ; preds = %56
store i8 1, i8* %3
br label %71
71: ; preds = %70, %69, %30, %14
%72 = load i8, i8* %3
ret i8 %72
}

LLVM IR (-O2):
define zeroext i8 @API_frame_is_correct(i8* nocapture %0, i32 %1) {
%3 = load i8, i8* %0
%4 = icmp eq i8 %3, 126
br i1 %4, label %5, label %165
5: ; preds = %2
%6 = getelementptr inbounds i8, i8* %0, i64 1
%7 = load i8, i8* %6
%8 = zext i8 %7 to i32
%9 = shl nuw nsw i32 %8, 8
%10 = getelementptr inbounds i8, i8* %0, i64 2
%11 = load i8, i8* %10
%12 = zext i8 %11 to i32
%13 = or i32 %9, %12
%14 = add nuw nsw i32 %13, 4
%15 = icmp ugt i32 %14, %1
br i1 %15, label %165, label %16
16: ; preds = %5
%17 = getelementptr inbounds i8, i8* %0, i64 3
%18 = load i8, i8* %17
%19 = zext i8 %18 to i32
%20 = add nsw i32 %13, -1
%21 = icmp eq i32 %20, 0
br i1 %21, label %154, label %22
22: ; preds = %16
%23 = zext i32 %20 to i64
%24 = icmp ult i32 %20, 8
br i1 %24, label %100, label %25
25: ; preds = %22
%26 = add nsw i64 %23, -1
%27 = and i64 %26, 4294967292
%28 = icmp eq i64 %27, 4294967292
%29 = icmp ugt i64 %26, 4294967295
%30 = or i1 %28, %29
br i1 %30, label %100, label %31
31: ; preds = %25
%32 = and i64 %23, 4294967288
%33 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %19, i64 0
%34 = add nsw i64 %32, -8
%35 = lshr exact i64 %34, 3
%36 = add nuw nsw i64 %35, 1
%37 = and i64 %36, 1
%38 = icmp eq i64 %34, 0
br i1 %38, label %76, label %39
39: ; preds = %31
%40 = and i64 %36, 4611686018427387902
br label %41
41: ; preds = %41, %39
%42 = phi i64 [ 0, %39 ], [ %70, %41 ]
%43 = phi <4 x i32> [ %33, %39 ], [ %68, %41 ]
%44 = phi <4 x i32> [ zeroinitializer, %39 ], [ %69, %41 ]
%45 = phi i64 [ 0, %39 ], [ %71, %41 ]
%46 = and i64 %42, 4294967280
%47 = or i64 %46, 4
%48 = getelementptr inbounds i8, i8* %0, i64 %47
%49 = bitcast i8* %48 to <4 x i8>*
%50 = load <4 x i8>, <4 x i8>* %49
%51 = getelementptr inbounds i8, i8* %48, i64 4
%52 = bitcast i8* %51 to <4 x i8>*
%53 = load <4 x i8>, <4 x i8>* %52
%54 = zext <4 x i8> %50 to <4 x i32>
%55 = zext <4 x i8> %53 to <4 x i32>
%56 = add <4 x i32> %43, %54
%57 = add <4 x i32> %44, %55
%58 = and i64 %42, 4294967280
%59 = or i64 %58, 12
%60 = getelementptr inbounds i8, i8* %0, i64 %59
%61 = bitcast i8* %60 to <4 x i8>*
%62 = load <4 x i8>, <4 x i8>* %61
%63 = getelementptr inbounds i8, i8* %60, i64 4
%64 = bitcast i8* %63 to <4 x i8>*
%65 = load <4 x i8>, <4 x i8>* %64
%66 = zext <4 x i8> %62 to <4 x i32>
%67 = zext <4 x i8> %65 to <4 x i32>
%68 = add <4 x i32> %56, %66
%69 = add <4 x i32> %57, %67
%70 = add nuw i64 %42, 16
%71 = add i64 %45, 2
%72 = icmp eq i64 %71, %40
br i1 %72, label %73, label %41
73: ; preds = %41
%74 = and i64 %70, 4294967280
%75 = or i64 %74, 4
br label %76
76: ; preds = %73, %31
%77 = phi <4 x i32> [ undef, %31 ], [ %68, %73 ]
%78 = phi <4 x i32> [ undef, %31 ], [ %69, %73 ]
%79 = phi i64 [ 4, %31 ], [ %75, %73 ]
%80 = phi <4 x i32> [ %33, %31 ], [ %68, %73 ]
%81 = phi <4 x i32> [ zeroinitializer, %31 ], [ %69, %73 ]
%82 = icmp eq i64 %37, 0
br i1 %82, label %94, label %83
83: ; preds = %76
%84 = getelementptr inbounds i8, i8* %0, i64 %79
%85 = bitcast i8* %84 to <4 x i8>*
%86 = load <4 x i8>, <4 x i8>* %85
%87 = getelementptr inbounds i8, i8* %84, i64 4
%88 = bitcast i8* %87 to <4 x i8>*
%89 = load <4 x i8>, <4 x i8>* %88
%90 = zext <4 x i8> %86 to <4 x i32>
%91 = zext <4 x i8> %89 to <4 x i32>
%92 = add <4 x i32> %80, %90
%93 = add <4 x i32> %81, %91
br label %94
94: ; preds = %76, %83
%95 = phi <4 x i32> [ %77, %76 ], [ %92, %83 ]
%96 = phi <4 x i32> [ %78, %76 ], [ %93, %83 ]
%97 = add <4 x i32> %96, %95
%98 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %97)
%99 = icmp eq i64 %32, %23
br i1 %99, label %154, label %100
100: ; preds = %25, %22, %94
%101 = phi i64 [ 0, %25 ], [ 0, %22 ], [ %32, %94 ]
%102 = phi i32 [ %19, %25 ], [ %19, %22 ], [ %98, %94 ]
%103 = xor i64 %101, -1
%104 = add nsw i64 %103, %23
%105 = and i64 %23, 3
%106 = icmp eq i64 %105, 0
br i1 %106, label %120, label %107
107: ; preds = %100, %107
%108 = phi i64 [ %117, %107 ], [ %101, %100 ]
%109 = phi i32 [ %116, %107 ], [ %102, %100 ]
%110 = phi i64 [ %118, %107 ], [ 0, %100 ]
%111 = add nuw i64 %108, 4
%112 = and i64 %111, 4294967295
%113 = getelementptr inbounds i8, i8* %0, i64 %112
%114 = load i8, i8* %113
%115 = zext i8 %114 to i32
%116 = add i32 %109, %115
%117 = add nuw nsw i64 %108, 1
%118 = add i64 %110, 1
%119 = icmp eq i64 %118, %105
br i1 %119, label %120, label %107
120: ; preds = %107, %100
%121 = phi i32 [ undef, %100 ], [ %116, %107 ]
%122 = phi i64 [ %101, %100 ], [ %117, %107 ]
%123 = phi i32 [ %102, %100 ], [ %116, %107 ]
%124 = icmp ult i64 %104, 3
br i1 %124, label %154, label %125
125: ; preds = %120, %125
%126 = phi i64 [ %152, %125 ], [ %122, %120 ]
%127 = phi i32 [ %151, %125 ], [ %123, %120 ]
%128 = add nuw i64 %126, 4
%129 = and i64 %128, 4294967295
%130 = getelementptr inbounds i8, i8* %0, i64 %129
%131 = load i8, i8* %130
%132 = zext i8 %131 to i32
%133 = add i32 %127, %132
%134 = add nuw i64 %126, 5
%135 = and i64 %134, 4294967295
%136 = getelementptr inbounds i8, i8* %0, i64 %135
%137 = load i8, i8* %136
%138 = zext i8 %137 to i32
%139 = add i32 %133, %138
%140 = add nuw i64 %126, 6
%141 = and i64 %140, 4294967295
%142 = getelementptr inbounds i8, i8* %0, i64 %141
%143 = load i8, i8* %142
%144 = zext i8 %143 to i32
%145 = add i32 %139, %144
%146 = add nuw i64 %126, 7
%147 = and i64 %146, 4294967295
%148 = getelementptr inbounds i8, i8* %0, i64 %147
%149 = load i8, i8* %148
%150 = zext i8 %149 to i32
%151 = add i32 %145, %150
%152 = add nuw nsw i64 %126, 4
%153 = icmp eq i64 %152, %23
br i1 %153, label %154, label %125
154: ; preds = %120, %125, %94, %16
%155 = phi i32 [ %19, %16 ], [ %98, %94 ], [ %121, %120 ], [ %151, %125 ]
%156 = add nuw nsw i32 %13, 3
%157 = zext i32 %156 to i64
%158 = getelementptr inbounds i8, i8* %0, i64 %157
%159 = load i8, i8* %158
%160 = zext i8 %159 to i32
%161 = add i32 %155, %160
%162 = and i32 %161, 255
%163 = icmp eq i32 %162, 255
%164 = zext i1 %163 to i8
br label %165
165: ; preds = %154, %5, %2
%166 = phi i8 [ 0, %2 ], [ 0, %5 ], [ %164, %154 ]
ret i8 %166
}