#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 INT_MAX;
int INT_MIN;
int absInteger(int);
int /*<<< orphan*/ overflowError(unsigned int, char *);
void map2check_binop_mul(int param1, int param2, unsigned line, unsigned scope,
                         char *function_name) {
  if ((param1 == 0) || (param2 == 0)) {
    return;
  }
  if ((param1 == 1) || (param2 == 1)) {
    return;
  }
  char isParam1Positive = (param1 >= 0);
  char isParam2Positive = (param2 >= 0);
  if ((isParam1Positive && isParam2Positive) ||
      (!isParam1Positive && !isParam2Positive)) {
    int limitPositiveResult = INT_MAX / param1;
    switch (isParam1Positive) {
    case 1:
      if (limitPositiveResult < param2) {
        overflowError(line, function_name);
      }
      break;
    case 0:
      if (param2 < limitPositiveResult) {
        overflowError(line, function_name);
      }
      break;
    }
  } else {
    int limitNegativeResult = INT_MIN / param1;
    switch (isParam1Positive) {
    case 1:
      if (limitNegativeResult > param2) {
        overflowError(line, function_name);
      }
      break;
    case 0:
      if (param2 > absInteger(limitNegativeResult)) {
        overflowError(line, function_name);
      }
      break;
    }
  }
}


x86 assembly (clang, -O0):
<map2check_binop_mul>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8,-0x18(%rbp)
cmpl   $0x0,-0x4(%rbp)
je     114c <map2check_binop_mul+0x2c>
cmpl   $0x0,-0x8(%rbp)
jne    1151 <map2check_binop_mul+0x31>
jmp    12b1 <map2check_binop_mul+0x191>
cmpl   $0x1,-0x4(%rbp)
je     1165 <map2check_binop_mul+0x45>
cmpl   $0x1,-0x8(%rbp)
jne    116a <map2check_binop_mul+0x4a>
jmp    12b1 <map2check_binop_mul+0x191>
cmpl   $0x0,-0x4(%rbp)
setge  %al
and    $0x1,%al
movzbl %al,%eax
mov    %al,-0x19(%rbp)
cmpl   $0x0,-0x8(%rbp)
setge  %al
and    $0x1,%al
movzbl %al,%eax
mov    %al,-0x1a(%rbp)
movsbl -0x19(%rbp),%eax
cmp    $0x0,%eax
je     11a2 <map2check_binop_mul+0x82>
movsbl -0x1a(%rbp),%eax
cmp    $0x0,%eax
jne    11b6 <map2check_binop_mul+0x96>
cmpb   $0x0,-0x19(%rbp)
jne    122c <map2check_binop_mul+0x10c>
cmpb   $0x0,-0x1a(%rbp)
jne    122c <map2check_binop_mul+0x10c>
mov    0x2e2b(%rip),%rax
mov    (%rax),%eax
mov    -0x4(%rbp),%ecx
cltd
idiv   %ecx
mov    %eax,-0x20(%rbp)
movsbl -0x19(%rbp),%eax
mov    %eax,-0x28(%rbp)
test   %eax,%eax
je     120a <map2check_binop_mul+0xea>
jmp    11dc <map2check_binop_mul+0xbc>
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
jne    1227 <map2check_binop_mul+0x107>
jmp    11ed <map2check_binop_mul+0xcd>
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1205 <map2check_binop_mul+0xe5>
mov    -0xc(%rbp),%edi
mov    -0x18(%rbp),%rsi
call   1030 <overflowError@plt>
jmp    1227 <map2check_binop_mul+0x107>
mov    -0x8(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1222 <map2check_binop_mul+0x102>
mov    -0xc(%rbp),%edi
mov    -0x18(%rbp),%rsi
call   1030 <overflowError@plt>
jmp    1227 <map2check_binop_mul+0x107>
jmp    12b1 <map2check_binop_mul+0x191>
mov    0x2dad(%rip),%rax
mov    (%rax),%eax
mov    -0x4(%rbp),%ecx
cltd
idiv   %ecx
mov    %eax,-0x24(%rbp)
movsbl -0x19(%rbp),%eax
mov    %eax,-0x2c(%rbp)
test   %eax,%eax
je     1280 <map2check_binop_mul+0x160>
jmp    1252 <map2check_binop_mul+0x132>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
jne    12ac <map2check_binop_mul+0x18c>
jmp    1263 <map2check_binop_mul+0x143>
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jle    127b <map2check_binop_mul+0x15b>
mov    -0xc(%rbp),%edi
mov    -0x18(%rbp),%rsi
call   1030 <overflowError@plt>
jmp    12ac <map2check_binop_mul+0x18c>
mov    -0x8(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%edi
call   1040 <absInteger@plt>
mov    %eax,%ecx
mov    -0x30(%rbp),%eax
cmp    %ecx,%eax
jle    12a7 <map2check_binop_mul+0x187>
mov    -0xc(%rbp),%edi
mov    -0x18(%rbp),%rsi
call   1030 <overflowError@plt>
jmp    12ac <map2check_binop_mul+0x18c>
jmp    12b1 <map2check_binop_mul+0x191>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<map2check_binop_mul>:
push   %rbp
push   %r14
push   %rbx
test   %edi,%edi
je     1183 <map2check_binop_mul+0x63>
mov    %esi,%ebx
test   %esi,%esi
je     1183 <map2check_binop_mul+0x63>
cmp    $0x1,%edi
je     1183 <map2check_binop_mul+0x63>
cmp    $0x1,%ebx
je     1183 <map2check_binop_mul+0x63>
mov    %r8,%r14
mov    %edx,%ebp
mov    %edi,%edx
shr    $0x1f,%edx
mov    %edx,%ecx
xor    $0x1,%cl
mov    %ebx,%eax
shr    $0x1f,%eax
or     %al,%dl
je     116f <map2check_binop_mul+0x4f>
xor    $0x1,%al
or     %cl,%al
je     116f <map2check_binop_mul+0x4f>
mov    0x2e83(%rip),%rax
mov    (%rax),%eax
cltd
idiv   %edi
test   %cl,%cl
jne    1188 <map2check_binop_mul+0x68>
mov    %eax,%edi
call   1040 <absInteger@plt>
jmp    117f <map2check_binop_mul+0x5f>
mov    0x2e72(%rip),%rax
mov    (%rax),%eax
cltd
idiv   %edi
test   %cl,%cl
je     1188 <map2check_binop_mul+0x68>
cmp    %ebx,%eax
jl     118c <map2check_binop_mul+0x6c>
pop    %rbx
pop    %r14
pop    %rbp
ret
cmp    %ebx,%eax
jle    1183 <map2check_binop_mul+0x63>
mov    %ebp,%edi
mov    %r14,%rsi
pop    %rbx
pop    %r14
pop    %rbp
jmp    1030 <overflowError@plt>

LLVM IR (-O0):
@INT_MAX = global i32 0
@INT_MIN = global i32 0
define void @map2check_binop_mul(i32 %0, i32 %1, i32 %2, i32 %3, i8* %4) {
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i8
%12 = alloca i8
%13 = alloca i32
%14 = alloca i32
store i32 %0, i32* %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i8* %4, i8** %10
%15 = load i32, i32* %6
%16 = icmp eq i32 %15, 0
br i1 %16, label %20, label %17
17: ; preds = %5
%18 = load i32, i32* %7
%19 = icmp eq i32 %18, 0
br i1 %19, label %20, label %21
20: ; preds = %17, %5
br label %101
21: ; preds = %17
%22 = load i32, i32* %6
%23 = icmp eq i32 %22, 1
br i1 %23, label %27, label %24
24: ; preds = %21
%25 = load i32, i32* %7
%26 = icmp eq i32 %25, 1
br i1 %26, label %27, label %28
27: ; preds = %24, %21
br label %101
28: ; preds = %24
%29 = load i32, i32* %6
%30 = icmp sge i32 %29, 0
%31 = zext i1 %30 to i32
%32 = trunc i32 %31 to i8
store i8 %32, i8* %11
%33 = load i32, i32* %7
%34 = icmp sge i32 %33, 0
%35 = zext i1 %34 to i32
%36 = trunc i32 %35 to i8
store i8 %36, i8* %12
%37 = load i8, i8* %11
%38 = sext i8 %37 to i32
%39 = icmp ne i32 %38, 0
br i1 %39, label %40, label %44
40: ; preds = %28
%41 = load i8, i8* %12
%42 = sext i8 %41 to i32
%43 = icmp ne i32 %42, 0
br i1 %43, label %50, label %44
44: ; preds = %40, %28
%45 = load i8, i8* %11
%46 = icmp ne i8 %45, 0
br i1 %46, label %75, label %47
47: ; preds = %44
%48 = load i8, i8* %12
%49 = icmp ne i8 %48, 0
br i1 %49, label %75, label %50
50: ; preds = %47, %40
%51 = load i32, i32* @INT_MAX
%52 = load i32, i32* %6
%53 = sdiv i32 %51, %52
store i32 %53, i32* %13
%54 = load i8, i8* %11
%55 = sext i8 %54 to i32
switch i32 %55, label %74 [
i32 1, label %56
i32 0, label %65
]
56: ; preds = %50
%57 = load i32, i32* %13
%58 = load i32, i32* %7
%59 = icmp slt i32 %57, %58
br i1 %59, label %60, label %64
60: ; preds = %56
%61 = load i32, i32* %8
%62 = load i8*, i8** %10
%63 = call i32 @overflowError(i32 %61, i8* %62)
br label %64
64: ; preds = %60, %56
br label %74
65: ; preds = %50
%66 = load i32, i32* %7
%67 = load i32, i32* %13
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %73
69: ; preds = %65
%70 = load i32, i32* %8
%71 = load i8*, i8** %10
%72 = call i32 @overflowError(i32 %70, i8* %71)
br label %73
73: ; preds = %69, %65
br label %74
74: ; preds = %50, %73, %64
br label %101
75: ; preds = %47, %44
%76 = load i32, i32* @INT_MIN
%77 = load i32, i32* %6
%78 = sdiv i32 %76, %77
store i32 %78, i32* %14
%79 = load i8, i8* %11
%80 = sext i8 %79 to i32
switch i32 %80, label %100 [
i32 1, label %81
i32 0, label %90
]
81: ; preds = %75
%82 = load i32, i32* %14
%83 = load i32, i32* %7
%84 = icmp sgt i32 %82, %83
br i1 %84, label %85, label %89
85: ; preds = %81
%86 = load i32, i32* %8
%87 = load i8*, i8** %10
%88 = call i32 @overflowError(i32 %86, i8* %87)
br label %89
89: ; preds = %85, %81
br label %100
90: ; preds = %75
%91 = load i32, i32* %7
%92 = load i32, i32* %14
%93 = call i32 @absInteger(i32 %92)
%94 = icmp sgt i32 %91, %93
br i1 %94, label %95, label %99
95: ; preds = %90
%96 = load i32, i32* %8
%97 = load i8*, i8** %10
%98 = call i32 @overflowError(i32 %96, i8* %97)
br label %99
99: ; preds = %95, %90
br label %100
100: ; preds = %75, %99, %89
br label %101
101: ; preds = %20, %27, %100, %74
ret void
}

LLVM IR (-O2):
@INT_MAX = global i32 0
@INT_MIN = global i32 0
define void @map2check_binop_mul(i32 %0, i32 %1, i32 %2, i32 %3, i8* %4) {
%6 = icmp eq i32 %0, 0
%7 = icmp eq i32 %1, 0
%8 = or i1 %6, %7
br i1 %8, label %43, label %9
9: ; preds = %5
%10 = icmp eq i32 %0, 1
%11 = icmp eq i32 %1, 1
%12 = or i1 %10, %11
br i1 %12, label %43, label %13
13: ; preds = %9
%14 = lshr i32 %0, 31
%15 = trunc i32 %14 to i8
%16 = xor i8 %15, 1
%17 = lshr i32 %1, 31
%18 = trunc i32 %17 to i8
%19 = xor i8 %18, 1
%20 = icmp ne i8 %16, 0
%21 = icmp ne i8 %19, 0
%22 = and i1 %20, %21
%23 = or i8 %19, %16
%24 = icmp eq i8 %23, 0
%25 = or i1 %22, %24
br i1 %25, label %26, label %33
26: ; preds = %13
%27 = load i32, i32* @INT_MAX
%28 = sdiv i32 %27, %0
br i1 %20, label %29, label %31
29: ; preds = %26
%30 = icmp slt i32 %28, %1
br i1 %30, label %41, label %43
31: ; preds = %26
%32 = icmp sgt i32 %28, %1
br i1 %32, label %41, label %43
33: ; preds = %13
%34 = load i32, i32* @INT_MIN
%35 = sdiv i32 %34, %0
br i1 %20, label %36, label %38
36: ; preds = %33
%37 = icmp sgt i32 %35, %1
br i1 %37, label %41, label %43
38: ; preds = %33
%39 = tail call i32 @absInteger(i32 %35)
%40 = icmp slt i32 %39, %1
br i1 %40, label %41, label %43
41: ; preds = %38, %36, %31, %29
%42 = tail call i32 @overflowError(i32 %2, i8* %4)
br label %43
43: ; preds = %41, %31, %29, %38, %36, %9, %5
ret void
}