float Glosbe(float Jp[3][3], unsigned char row, unsigned char col) {
  unsigned char i, j;
  unsigned char k = 0;
  float Temp[4];
  float ReturnVal;
  for (i = 0; i < 3; i++)
    for (j = 0; j < 3; j++) {
      if (i != row && j != col)
        Temp[k++] = Jp[i][j];
    }
  ReturnVal = (Temp[0] * Temp[3] - Temp[2] * Temp[1]);
  if ((row + col + 2) % 2 != 0)
    ReturnVal = -ReturnVal;
  return ReturnVal;
}


x86 assembly (clang, -O0):
<Glosbe>:
push   %rbp
mov    %rsp,%rbp
mov    %dl,%al
mov    %sil,%cl
mov    %rdi,-0x8(%rbp)
mov    %cl,-0x9(%rbp)
mov    %al,-0xa(%rbp)
movb   $0x0,-0xd(%rbp)
movb   $0x0,-0xb(%rbp)
movzbl -0xb(%rbp),%eax
cmp    $0x3,%eax
jge    11a9 <Glosbe+0xa9>
movb   $0x0,-0xc(%rbp)
movzbl -0xc(%rbp),%eax
cmp    $0x3,%eax
jge    1197 <Glosbe+0x97>
movzbl -0xb(%rbp),%eax
movzbl -0x9(%rbp),%ecx
cmp    %ecx,%eax
je     1185 <Glosbe+0x85>
movzbl -0xc(%rbp),%eax
movzbl -0xa(%rbp),%ecx
cmp    %ecx,%eax
je     1185 <Glosbe+0x85>
mov    -0x8(%rbp),%rax
movzbl -0xb(%rbp),%ecx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movzbl -0xc(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0xd(%rbp),%al
mov    %al,%cl
add    $0x1,%cl
mov    %cl,-0xd(%rbp)
movzbl %al,%eax
movss  %xmm0,-0x20(%rbp,%rax,4)
jmp    118a <Glosbe+0x8a>
mov    -0xc(%rbp),%al
add    $0x1,%al
mov    %al,-0xc(%rbp)
jmp    112c <Glosbe+0x2c>
jmp    119c <Glosbe+0x9c>
mov    -0xb(%rbp),%al
add    $0x1,%al
mov    %al,-0xb(%rbp)
jmp    111b <Glosbe+0x1b>
movss  -0x20(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x18(%rbp),%xmm1
mulss  -0x1c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
movzbl -0x9(%rbp),%eax
movzbl -0xa(%rbp),%ecx
add    %ecx,%eax
add    $0x2,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     120c <Glosbe+0x10c>
movss  -0x24(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<Glosbe>:
xor    %eax,%eax
test   %esi,%esi
je     1116 <Glosbe+0x16>
test   %dl,%dl
je     1116 <Glosbe+0x16>
movss  (%rdi),%xmm0
movss  %xmm0,-0x18(%rsp)
mov    $0x1,%al
test   %sil,%sil
je     1130 <Glosbe+0x30>
cmp    $0x1,%dl
je     1130 <Glosbe+0x30>
movss  0x4(%rdi),%xmm0
movzbl %al,%ecx
add    $0x1,%al
movss  %xmm0,-0x18(%rsp,%rcx,4)
test   %sil,%sil
je     114a <Glosbe+0x4a>
cmp    $0x2,%dl
je     114a <Glosbe+0x4a>
movss  0x8(%rdi),%xmm0
movzbl %al,%ecx
add    $0x1,%al
movss  %xmm0,-0x18(%rsp,%rcx,4)
cmp    $0x1,%sil
je     1164 <Glosbe+0x64>
test   %dl,%dl
je     1164 <Glosbe+0x64>
movss  0xc(%rdi),%xmm0
movzbl %al,%ecx
add    $0x1,%al
movss  %xmm0,-0x18(%rsp,%rcx,4)
cmp    $0x1,%sil
je     117f <Glosbe+0x7f>
cmp    $0x1,%dl
je     117f <Glosbe+0x7f>
movss  0x10(%rdi),%xmm0
movzbl %al,%ecx
add    $0x1,%al
movss  %xmm0,-0x18(%rsp,%rcx,4)
cmp    $0x1,%sil
je     119a <Glosbe+0x9a>
cmp    $0x2,%dl
je     119a <Glosbe+0x9a>
movss  0x14(%rdi),%xmm0
movzbl %al,%ecx
add    $0x1,%al
movss  %xmm0,-0x18(%rsp,%rcx,4)
cmp    $0x2,%sil
je     11b4 <Glosbe+0xb4>
test   %dl,%dl
je     11b4 <Glosbe+0xb4>
movss  0x18(%rdi),%xmm0
movzbl %al,%ecx
add    $0x1,%al
movss  %xmm0,-0x18(%rsp,%rcx,4)
cmp    $0x2,%sil
je     11cf <Glosbe+0xcf>
cmp    $0x1,%dl
je     11cf <Glosbe+0xcf>
movss  0x1c(%rdi),%xmm0
movzbl %al,%ecx
add    $0x1,%al
movss  %xmm0,-0x18(%rsp,%rcx,4)
cmp    $0x2,%sil
je     11e8 <Glosbe+0xe8>
cmp    $0x2,%dl
je     11e8 <Glosbe+0xe8>
movss  0x20(%rdi),%xmm0
movzbl %al,%eax
movss  %xmm0,-0x18(%rsp,%rax,4)
movss  -0x14(%rsp),%xmm1
mulss  -0x10(%rsp),%xmm1
movss  -0x18(%rsp),%xmm0
mulss  -0xc(%rsp),%xmm0
subss  %xmm1,%xmm0
movzbl %sil,%eax
movzbl %dl,%ecx
add    %eax,%ecx
test   $0x1,%cl
je     1219 <Glosbe+0x119>
xorps  0xde7(%rip),%xmm0
ret

LLVM IR (-O0):
define float @Glosbe([3 x float]* %0, i8 zeroext %1, i8 zeroext %2) {
%4 = alloca [3 x float]*
%5 = alloca i8
%6 = alloca i8
%7 = alloca i8
%8 = alloca i8
%9 = alloca i8
%10 = alloca [4 x float]
%11 = alloca float
store [3 x float]* %0, [3 x float]** %4
store i8 %1, i8* %5
store i8 %2, i8* %6
store i8 0, i8* %9
store i8 0, i8* %7
br label %12
12: ; preds = %51, %3
%13 = load i8, i8* %7
%14 = zext i8 %13 to i32
%15 = icmp slt i32 %14, 3
br i1 %15, label %16, label %54
16: ; preds = %12
store i8 0, i8* %8
br label %17
17: ; preds = %47, %16
%18 = load i8, i8* %8
%19 = zext i8 %18 to i32
%20 = icmp slt i32 %19, 3
br i1 %20, label %21, label %50
21: ; preds = %17
%22 = load i8, i8* %7
%23 = zext i8 %22 to i32
%24 = load i8, i8* %5
%25 = zext i8 %24 to i32
%26 = icmp ne i32 %23, %25
br i1 %26, label %27, label %46
27: ; preds = %21
%28 = load i8, i8* %8
%29 = zext i8 %28 to i32
%30 = load i8, i8* %6
%31 = zext i8 %30 to i32
%32 = icmp ne i32 %29, %31
br i1 %32, label %33, label %46
33: ; preds = %27
%34 = load [3 x float]*, [3 x float]** %4
%35 = load i8, i8* %7
%36 = zext i8 %35 to i64
%37 = getelementptr inbounds [3 x float], [3 x float]* %34, i64 %36
%38 = load i8, i8* %8
%39 = zext i8 %38 to i64
%40 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 %39
%41 = load float, float* %40
%42 = load i8, i8* %9
%43 = add i8 %42, 1
store i8 %43, i8* %9
%44 = zext i8 %42 to i64
%45 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 %44
store float %41, float* %45
br label %46
46: ; preds = %33, %27, %21
br label %47
47: ; preds = %46
%48 = load i8, i8* %8
%49 = add i8 %48, 1
store i8 %49, i8* %8
br label %17
50: ; preds = %17
br label %51
51: ; preds = %50
%52 = load i8, i8* %7
%53 = add i8 %52, 1
store i8 %53, i8* %7
br label %12
54: ; preds = %12
%55 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 0
%56 = load float, float* %55
%57 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 3
%58 = load float, float* %57
%59 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 2
%60 = load float, float* %59
%61 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 1
%62 = load float, float* %61
%63 = fmul float %60, %62
%64 = fneg float %63
%65 = call float @llvm.fmuladd.f32(float %56, float %58, float %64)
store float %65, float* %11
%66 = load i8, i8* %5
%67 = zext i8 %66 to i32
%68 = load i8, i8* %6
%69 = zext i8 %68 to i32
%70 = add nsw i32 %67, %69
%71 = add nsw i32 %70, 2
%72 = srem i32 %71, 2
%73 = icmp ne i32 %72, 0
br i1 %73, label %74, label %77
74: ; preds = %54
%75 = load float, float* %11
%76 = fneg float %75
store float %76, float* %11
br label %77
77: ; preds = %74, %54
%78 = load float, float* %11
ret float %78
}

LLVM IR (-O2):
define float @Glosbe([3 x float]* nocapture %0, i8 zeroext %1, i8 zeroext %2) {
%4 = alloca [4 x float]
%5 = bitcast [4 x float]* %4 to i8*
%6 = icmp eq i8 %1, 0
%7 = icmp eq i8 %2, 0
%8 = or i1 %6, %7
br i1 %8, label %13, label %9
9: ; preds = %3
%10 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 0, i64 0
%11 = load float, float* %10
%12 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 0, i64 0
store float %11, float* %12
br label %13
13: ; preds = %3, %9
%14 = phi i8 [ 1, %9 ], [ 0, %3 ]
%15 = icmp eq i8 %2, 1
%16 = or i1 %6, %15
br i1 %16, label %23, label %17
17: ; preds = %13
%18 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 0, i64 1
%19 = load float, float* %18
%20 = add nuw nsw i8 %14, 1
%21 = zext i8 %14 to i64
%22 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 0, i64 %21
store float %19, float* %22
br label %23
23: ; preds = %17, %13
%24 = phi i8 [ %20, %17 ], [ %14, %13 ]
%25 = icmp eq i8 %2, 2
%26 = or i1 %6, %25
br i1 %26, label %33, label %27
27: ; preds = %23
%28 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 0, i64 2
%29 = load float, float* %28
%30 = add nuw nsw i8 %24, 1
%31 = zext i8 %24 to i64
%32 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 0, i64 %31
store float %29, float* %32
br label %33
33: ; preds = %27, %23
%34 = phi i8 [ %30, %27 ], [ %24, %23 ]
%35 = icmp eq i8 %1, 1
%36 = or i1 %35, %7
br i1 %36, label %43, label %37
37: ; preds = %33
%38 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 1, i64 0
%39 = load float, float* %38
%40 = add nuw nsw i8 %34, 1
%41 = zext i8 %34 to i64
%42 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 0, i64 %41
store float %39, float* %42
br label %43
43: ; preds = %37, %33
%44 = phi i8 [ %40, %37 ], [ %34, %33 ]
%45 = or i1 %35, %15
br i1 %45, label %52, label %46
46: ; preds = %43
%47 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 1, i64 1
%48 = load float, float* %47
%49 = add nuw nsw i8 %44, 1
%50 = zext i8 %44 to i64
%51 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 0, i64 %50
store float %48, float* %51
br label %52
52: ; preds = %46, %43
%53 = phi i8 [ %49, %46 ], [ %44, %43 ]
%54 = or i1 %35, %25
br i1 %54, label %61, label %55
55: ; preds = %52
%56 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 1, i64 2
%57 = load float, float* %56
%58 = add nuw nsw i8 %53, 1
%59 = zext i8 %53 to i64
%60 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 0, i64 %59
store float %57, float* %60
br label %61
61: ; preds = %55, %52
%62 = phi i8 [ %58, %55 ], [ %53, %52 ]
%63 = icmp eq i8 %1, 2
%64 = or i1 %63, %7
br i1 %64, label %71, label %65
65: ; preds = %61
%66 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 2, i64 0
%67 = load float, float* %66
%68 = add nuw nsw i8 %62, 1
%69 = zext i8 %62 to i64
%70 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 0, i64 %69
store float %67, float* %70
br label %71
71: ; preds = %65, %61
%72 = phi i8 [ %68, %65 ], [ %62, %61 ]
%73 = or i1 %63, %15
br i1 %73, label %80, label %74
74: ; preds = %71
%75 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 2, i64 1
%76 = load float, float* %75
%77 = add nuw nsw i8 %72, 1
%78 = zext i8 %72 to i64
%79 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 0, i64 %78
store float %76, float* %79
br label %80
80: ; preds = %74, %71
%81 = phi i8 [ %77, %74 ], [ %72, %71 ]
%82 = or i1 %63, %25
br i1 %82, label %88, label %83
83: ; preds = %80
%84 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 2, i64 2
%85 = load float, float* %84
%86 = zext i8 %81 to i64
%87 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 0, i64 %86
store float %85, float* %87
br label %88
88: ; preds = %83, %80
%89 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 0, i64 0
%90 = load float, float* %89
%91 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 0, i64 3
%92 = load float, float* %91
%93 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 0, i64 2
%94 = load float, float* %93
%95 = getelementptr inbounds [4 x float], [4 x float]* %4, i64 0, i64 1
%96 = load float, float* %95
%97 = fneg float %94
%98 = fmul float %96, %97
%99 = tail call float @llvm.fmuladd.f32(float %90, float %92, float %98)
%100 = zext i8 %1 to i32
%101 = zext i8 %2 to i32
%102 = add nuw nsw i32 %101, %100
%103 = and i32 %102, 1
%104 = icmp eq i32 %103, 0
%105 = fneg float %99
%106 = select i1 %104, float %99, float %105
ret float %106
}