#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 /*<<< orphan*/ __m128i;

/* Variables and functions */
int check_epi16_overflow_x4(int /*<<< orphan*/ const *,
                            int /*<<< orphan*/ const *,
                            int /*<<< orphan*/ const *,
                            int /*<<< orphan*/ const *);
int check_epi16_overflow_x32(
    const __m128i *preg0, const __m128i *preg1, const __m128i *preg2,
    const __m128i *preg3, const __m128i *preg4, const __m128i *preg5,
    const __m128i *preg6, const __m128i *preg7, const __m128i *preg8,
    const __m128i *preg9, const __m128i *preg10, const __m128i *preg11,
    const __m128i *preg12, const __m128i *preg13, const __m128i *preg14,
    const __m128i *preg15, const __m128i *preg16, const __m128i *preg17,
    const __m128i *preg18, const __m128i *preg19, const __m128i *preg20,
    const __m128i *preg21, const __m128i *preg22, const __m128i *preg23,
    const __m128i *preg24, const __m128i *preg25, const __m128i *preg26,
    const __m128i *preg27, const __m128i *preg28, const __m128i *preg29,
    const __m128i *preg30, const __m128i *preg31) {
  int res0, res1;
  res0 = check_epi16_overflow_x4(preg0, preg1, preg2, preg3);
  res1 = check_epi16_overflow_x4(preg4, preg5, preg6, preg7);
  if (!res0) {
    res0 = check_epi16_overflow_x4(preg8, preg9, preg10, preg11);
    if (!res1) {
      res1 = check_epi16_overflow_x4(preg12, preg13, preg14, preg15);
      if (!res0) {
        res0 = check_epi16_overflow_x4(preg16, preg17, preg18, preg19);
        if (!res1) {
          res1 = check_epi16_overflow_x4(preg20, preg21, preg22, preg23);
          if (!res0) {
            res0 = check_epi16_overflow_x4(preg24, preg25, preg26, preg27);
            if (!res1)
              res1 = check_epi16_overflow_x4(preg28, preg29, preg30, preg31);
          }
        }
      }
    }
  }
  return res0 + res1;
}


x86 assembly (clang, -O0):
<check_epi16_overflow_x32>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    0xd8(%rbp),%rax
mov    0xd0(%rbp),%rax
mov    0xc8(%rbp),%rax
mov    0xc0(%rbp),%rax
mov    0xb8(%rbp),%rax
mov    0xb0(%rbp),%rax
mov    0xa8(%rbp),%rax
mov    0xa0(%rbp),%rax
mov    0x98(%rbp),%rax
mov    0x90(%rbp),%rax
mov    0x88(%rbp),%rax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
call   1030 <check_epi16_overflow_x4@plt>
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    0x10(%rbp),%rdx
mov    0x18(%rbp),%rcx
call   1030 <check_epi16_overflow_x4@plt>
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    12f5 <check_epi16_overflow_x32+0x1e5>
mov    0x20(%rbp),%rdi
mov    0x28(%rbp),%rsi
mov    0x30(%rbp),%rdx
mov    0x38(%rbp),%rcx
call   1030 <check_epi16_overflow_x4@plt>
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x38(%rbp)
jne    12f0 <check_epi16_overflow_x32+0x1e0>
mov    0x40(%rbp),%rdi
mov    0x48(%rbp),%rsi
mov    0x50(%rbp),%rdx
mov    0x58(%rbp),%rcx
call   1030 <check_epi16_overflow_x4@plt>
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    12eb <check_epi16_overflow_x32+0x1db>
mov    0x60(%rbp),%rdi
mov    0x68(%rbp),%rsi
mov    0x70(%rbp),%rdx
mov    0x78(%rbp),%rcx
call   1030 <check_epi16_overflow_x4@plt>
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x38(%rbp)
jne    12e6 <check_epi16_overflow_x32+0x1d6>
mov    0x80(%rbp),%rdi
mov    0x88(%rbp),%rsi
mov    0x90(%rbp),%rdx
mov    0x98(%rbp),%rcx
call   1030 <check_epi16_overflow_x4@plt>
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    12e1 <check_epi16_overflow_x32+0x1d1>
mov    0xa0(%rbp),%rdi
mov    0xa8(%rbp),%rsi
mov    0xb0(%rbp),%rdx
mov    0xb8(%rbp),%rcx
call   1030 <check_epi16_overflow_x4@plt>
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x38(%rbp)
jne    12dc <check_epi16_overflow_x32+0x1cc>
mov    0xc0(%rbp),%rdi
mov    0xc8(%rbp),%rsi
mov    0xd0(%rbp),%rdx
mov    0xd8(%rbp),%rcx
call   1030 <check_epi16_overflow_x4@plt>
mov    %eax,-0x38(%rbp)
jmp    12e1 <check_epi16_overflow_x32+0x1d1>
jmp    12e6 <check_epi16_overflow_x32+0x1d6>
jmp    12eb <check_epi16_overflow_x32+0x1db>
jmp    12f0 <check_epi16_overflow_x32+0x1e0>
jmp    12f5 <check_epi16_overflow_x32+0x1e5>
mov    -0x34(%rbp),%eax
add    -0x38(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<check_epi16_overflow_x32>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %r9,%rbp
mov    %r8,%rbx
mov    0x30(%rsp),%r15
mov    0x38(%rsp),%r12
call   1030 <check_epi16_overflow_x4@plt>
mov    %eax,%r14d
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r15,%rdx
mov    %r12,%rcx
call   1030 <check_epi16_overflow_x4@plt>
mov    %eax,%ebp
test   %r14d,%r14d
jne    123f <check_epi16_overflow_x32+0x12f>
mov    0x58(%rsp),%rcx
mov    0x50(%rsp),%rdx
mov    0x48(%rsp),%rsi
mov    0x40(%rsp),%rdi
call   1030 <check_epi16_overflow_x4@plt>
mov    %eax,%r14d
test   %ebp,%ebp
jne    123f <check_epi16_overflow_x32+0x12f>
mov    0x78(%rsp),%rcx
mov    0x70(%rsp),%rdx
mov    0x68(%rsp),%rsi
mov    0x60(%rsp),%rdi
call   1030 <check_epi16_overflow_x4@plt>
mov    %eax,%ebp
test   %r14d,%r14d
jne    123f <check_epi16_overflow_x32+0x12f>
mov    0x98(%rsp),%rcx
mov    0x90(%rsp),%rdx
mov    0x88(%rsp),%rsi
mov    0x80(%rsp),%rdi
call   1030 <check_epi16_overflow_x4@plt>
mov    %eax,%r14d
test   %ebp,%ebp
jne    123f <check_epi16_overflow_x32+0x12f>
mov    0xb8(%rsp),%rcx
mov    0xb0(%rsp),%rdx
mov    0xa8(%rsp),%rsi
mov    0xa0(%rsp),%rdi
call   1030 <check_epi16_overflow_x4@plt>
mov    %eax,%ebp
test   %r14d,%r14d
jne    123f <check_epi16_overflow_x32+0x12f>
mov    0xd8(%rsp),%rcx
mov    0xd0(%rsp),%rdx
mov    0xc8(%rsp),%rsi
mov    0xc0(%rsp),%rdi
call   1030 <check_epi16_overflow_x4@plt>
mov    %eax,%r14d
test   %ebp,%ebp
jne    123f <check_epi16_overflow_x32+0x12f>
mov    0xf8(%rsp),%rcx
mov    0xf0(%rsp),%rdx
mov    0xe8(%rsp),%rsi
mov    0xe0(%rsp),%rdi
call   1030 <check_epi16_overflow_x4@plt>
mov    %eax,%ebp
add    %ebp,%r14d
mov    %r14d,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @check_epi16_overflow_x32(i32* %0, i32* %1, i32* %2, i32* %3, i32* %4, i32* %5, i32* %6, i32* %7, i32* %8, i32* %9, i32* %10, i32* %11, i32* %12, i32* %13, i32* %14, i32* %15, i32* %16, i32* %17, i32* %18, i32* %19, i32* %20, i32* %21, i32* %22, i32* %23, i32* %24, i32* %25, i32* %26, i32* %27, i32* %28, i32* %29, i32* %30, i32* %31) {
%33 = alloca i32*
%34 = alloca i32*
%35 = alloca i32*
%36 = alloca i32*
%37 = alloca i32*
%38 = alloca i32*
%39 = alloca i32*
%40 = alloca i32*
%41 = alloca i32*
%42 = alloca i32*
%43 = alloca i32*
%44 = alloca i32*
%45 = alloca i32*
%46 = alloca i32*
%47 = alloca i32*
%48 = alloca i32*
%49 = alloca i32*
%50 = alloca i32*
%51 = alloca i32*
%52 = alloca i32*
%53 = alloca i32*
%54 = alloca i32*
%55 = alloca i32*
%56 = alloca i32*
%57 = alloca i32*
%58 = alloca i32*
%59 = alloca i32*
%60 = alloca i32*
%61 = alloca i32*
%62 = alloca i32*
%63 = alloca i32*
%64 = alloca i32*
%65 = alloca i32
%66 = alloca i32
store i32* %0, i32** %33
store i32* %1, i32** %34
store i32* %2, i32** %35
store i32* %3, i32** %36
store i32* %4, i32** %37
store i32* %5, i32** %38
store i32* %6, i32** %39
store i32* %7, i32** %40
store i32* %8, i32** %41
store i32* %9, i32** %42
store i32* %10, i32** %43
store i32* %11, i32** %44
store i32* %12, i32** %45
store i32* %13, i32** %46
store i32* %14, i32** %47
store i32* %15, i32** %48
store i32* %16, i32** %49
store i32* %17, i32** %50
store i32* %18, i32** %51
store i32* %19, i32** %52
store i32* %20, i32** %53
store i32* %21, i32** %54
store i32* %22, i32** %55
store i32* %23, i32** %56
store i32* %24, i32** %57
store i32* %25, i32** %58
store i32* %26, i32** %59
store i32* %27, i32** %60
store i32* %28, i32** %61
store i32* %29, i32** %62
store i32* %30, i32** %63
store i32* %31, i32** %64
%67 = load i32*, i32** %33
%68 = load i32*, i32** %34
%69 = load i32*, i32** %35
%70 = load i32*, i32** %36
%71 = call i32 @check_epi16_overflow_x4(i32* %67, i32* %68, i32* %69, i32* %70)
store i32 %71, i32* %65
%72 = load i32*, i32** %37
%73 = load i32*, i32** %38
%74 = load i32*, i32** %39
%75 = load i32*, i32** %40
%76 = call i32 @check_epi16_overflow_x4(i32* %72, i32* %73, i32* %74, i32* %75)
store i32 %76, i32* %66
%77 = load i32, i32* %65
%78 = icmp ne i32 %77, 0
br i1 %78, label %130, label %79
79: ; preds = %32
%80 = load i32*, i32** %41
%81 = load i32*, i32** %42
%82 = load i32*, i32** %43
%83 = load i32*, i32** %44
%84 = call i32 @check_epi16_overflow_x4(i32* %80, i32* %81, i32* %82, i32* %83)
store i32 %84, i32* %65
%85 = load i32, i32* %66
%86 = icmp ne i32 %85, 0
br i1 %86, label %129, label %87
87: ; preds = %79
%88 = load i32*, i32** %45
%89 = load i32*, i32** %46
%90 = load i32*, i32** %47
%91 = load i32*, i32** %48
%92 = call i32 @check_epi16_overflow_x4(i32* %88, i32* %89, i32* %90, i32* %91)
store i32 %92, i32* %66
%93 = load i32, i32* %65
%94 = icmp ne i32 %93, 0
br i1 %94, label %128, label %95
95: ; preds = %87
%96 = load i32*, i32** %49
%97 = load i32*, i32** %50
%98 = load i32*, i32** %51
%99 = load i32*, i32** %52
%100 = call i32 @check_epi16_overflow_x4(i32* %96, i32* %97, i32* %98, i32* %99)
store i32 %100, i32* %65
%101 = load i32, i32* %66
%102 = icmp ne i32 %101, 0
br i1 %102, label %127, label %103
103: ; preds = %95
%104 = load i32*, i32** %53
%105 = load i32*, i32** %54
%106 = load i32*, i32** %55
%107 = load i32*, i32** %56
%108 = call i32 @check_epi16_overflow_x4(i32* %104, i32* %105, i32* %106, i32* %107)
store i32 %108, i32* %66
%109 = load i32, i32* %65
%110 = icmp ne i32 %109, 0
br i1 %110, label %126, label %111
111: ; preds = %103
%112 = load i32*, i32** %57
%113 = load i32*, i32** %58
%114 = load i32*, i32** %59
%115 = load i32*, i32** %60
%116 = call i32 @check_epi16_overflow_x4(i32* %112, i32* %113, i32* %114, i32* %115)
store i32 %116, i32* %65
%117 = load i32, i32* %66
%118 = icmp ne i32 %117, 0
br i1 %118, label %125, label %119
119: ; preds = %111
%120 = load i32*, i32** %61
%121 = load i32*, i32** %62
%122 = load i32*, i32** %63
%123 = load i32*, i32** %64
%124 = call i32 @check_epi16_overflow_x4(i32* %120, i32* %121, i32* %122, i32* %123)
store i32 %124, i32* %66
br label %125
125: ; preds = %119, %111
br label %126
126: ; preds = %125, %103
br label %127
127: ; preds = %126, %95
br label %128
128: ; preds = %127, %87
br label %129
129: ; preds = %128, %79
br label %130
130: ; preds = %129, %32
%131 = load i32, i32* %65
%132 = load i32, i32* %66
%133 = add nsw i32 %131, %132
ret i32 %133
}

LLVM IR (-O2):
define i32 @check_epi16_overflow_x32(i32* %0, i32* %1, i32* %2, i32* %3, i32* %4, i32* %5, i32* %6, i32* %7, i32* %8, i32* %9, i32* %10, i32* %11, i32* %12, i32* %13, i32* %14, i32* %15, i32* %16, i32* %17, i32* %18, i32* %19, i32* %20, i32* %21, i32* %22, i32* %23, i32* %24, i32* %25, i32* %26, i32* %27, i32* %28, i32* %29, i32* %30, i32* %31) {
%33 = tail call i32 @check_epi16_overflow_x4(i32* %0, i32* %1, i32* %2, i32* %3)
%34 = tail call i32 @check_epi16_overflow_x4(i32* %4, i32* %5, i32* %6, i32* %7)
%35 = icmp eq i32 %33, 0
br i1 %35, label %36, label %53
36: ; preds = %32
%37 = tail call i32 @check_epi16_overflow_x4(i32* %8, i32* %9, i32* %10, i32* %11)
%38 = icmp eq i32 %34, 0
br i1 %38, label %39, label %53
39: ; preds = %36
%40 = tail call i32 @check_epi16_overflow_x4(i32* %12, i32* %13, i32* %14, i32* %15)
%41 = icmp eq i32 %37, 0
br i1 %41, label %42, label %53
42: ; preds = %39
%43 = tail call i32 @check_epi16_overflow_x4(i32* %16, i32* %17, i32* %18, i32* %19)
%44 = icmp eq i32 %40, 0
br i1 %44, label %45, label %53
45: ; preds = %42
%46 = tail call i32 @check_epi16_overflow_x4(i32* %20, i32* %21, i32* %22, i32* %23)
%47 = icmp eq i32 %43, 0
br i1 %47, label %48, label %53
48: ; preds = %45
%49 = tail call i32 @check_epi16_overflow_x4(i32* %24, i32* %25, i32* %26, i32* %27)
%50 = icmp eq i32 %46, 0
br i1 %50, label %51, label %53
51: ; preds = %48
%52 = tail call i32 @check_epi16_overflow_x4(i32* %28, i32* %29, i32* %30, i32* %31)
br label %53
53: ; preds = %36, %42, %48, %51, %45, %39, %32
%54 = phi i32 [ %33, %32 ], [ %37, %36 ], [ %37, %39 ], [ %43, %42 ], [ %43, %45 ], [ %49, %48 ], [ %49, %51 ]
%55 = phi i32 [ %34, %32 ], [ %34, %36 ], [ %40, %39 ], [ %40, %42 ], [ %46, %45 ], [ %46, %48 ], [ %52, %51 ]
%56 = add nsw i32 %55, %54
ret i32 %56
}