int NPGF(int *raf, int *deg, int ifa) {
  int permut[6][4] = {{0, 2, 1, 0}, {1, 2, 0, 1}, {2, 0, 1, 1},
                      {2, 1, 0, 0}, {0, 1, 2, 1}, {1, 0, 2, 0}};
  int i0 = permut[ifa][0];
  int i1 = permut[ifa][1];
  return raf[i0] * raf[i1] * (deg[i0] + 1) * (deg[i1] + 1);
}


x86 assembly (clang, -O0):
<NPGF>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
lea    -0x80(%rbp),%rdi
lea    0xecf(%rip),%rsi
mov    $0x60,%edx
call   1030 <memcpy@plt>
movslq -0x14(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    (%rax),%eax
mov    %eax,-0x84(%rbp)
movslq -0x14(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x4(%rax),%eax
mov    %eax,-0x88(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x88(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x84(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    -0x10(%rbp),%rcx
movslq -0x88(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<NPGF>:
movslq %edx,%rax
shl    $0x4,%rax
lea    0xef2(%rip),%rcx
movslq (%rax,%rcx,1),%rdx
movslq 0x4(%rax,%rcx,1),%rax
mov    (%rdi,%rax,4),%ecx
imul   (%rdi,%rdx,4),%ecx
mov    (%rsi,%rdx,4),%edx
add    $0x1,%edx
mov    (%rsi,%rax,4),%eax
add    $0x1,%eax
imul   %edx,%eax
imul   %ecx,%eax
ret

LLVM IR (-O0):
@__const.NPGF.permut = [6 x [4 x i32]] [[4 x i32] [i32 0, i32 2, i32 1, i32 0], [4 x i32] [i32 1, i32 2, i32 0, i32 1], [4 x i32] [i32 2, i32 0, i32 1, i32 1], [4 x i32] [i32 2, i32 1, i32 0, i32 0], [4 x i32] [i32 0, i32 1, i32 2, i32 1], [4 x i32] [i32 1, i32 0, i32 2, i32 0]]
define i32 @NPGF(i32* %0, i32* %1, i32 %2) {
%4 = alloca i32*
%5 = alloca i32*
%6 = alloca i32
%7 = alloca [6 x [4 x i32]]
%8 = alloca i32
%9 = alloca i32
store i32* %0, i32** %4
store i32* %1, i32** %5
store i32 %2, i32* %6
%10 = bitcast [6 x [4 x i32]]* %7 to i8*
%11 = load i32, i32* %6
%12 = sext i32 %11 to i64
%13 = getelementptr inbounds [6 x [4 x i32]], [6 x [4 x i32]]* %7, i64 0, i64 %12
%14 = getelementptr inbounds [4 x i32], [4 x i32]* %13, i64 0, i64 0
%15 = load i32, i32* %14
store i32 %15, i32* %8
%16 = load i32, i32* %6
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds [6 x [4 x i32]], [6 x [4 x i32]]* %7, i64 0, i64 %17
%19 = getelementptr inbounds [4 x i32], [4 x i32]* %18, i64 0, i64 1
%20 = load i32, i32* %19
store i32 %20, i32* %9
%21 = load i32*, i32** %4
%22 = load i32, i32* %8
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds i32, i32* %21, i64 %23
%25 = load i32, i32* %24
%26 = load i32*, i32** %4
%27 = load i32, i32* %9
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds i32, i32* %26, i64 %28
%30 = load i32, i32* %29
%31 = mul nsw i32 %25, %30
%32 = load i32*, i32** %5
%33 = load i32, i32* %8
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i32, i32* %32, i64 %34
%36 = load i32, i32* %35
%37 = add nsw i32 %36, 1
%38 = mul nsw i32 %31, %37
%39 = load i32*, i32** %5
%40 = load i32, i32* %9
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i32, i32* %39, i64 %41
%43 = load i32, i32* %42
%44 = add nsw i32 %43, 1
%45 = mul nsw i32 %38, %44
ret i32 %45
}

LLVM IR (-O2):
@__const.NPGF.permut = [6 x [4 x i32]] [[4 x i32] [i32 0, i32 2, i32 1, i32 0], [4 x i32] [i32 1, i32 2, i32 0, i32 1], [4 x i32] [i32 2, i32 0, i32 1, i32 1], [4 x i32] [i32 2, i32 1, i32 0, i32 0], [4 x i32] [i32 0, i32 1, i32 2, i32 1], [4 x i32] [i32 1, i32 0, i32 2, i32 0]]
define i32 @NPGF(i32* nocapture %0, i32* nocapture %1, i32 %2) {
%4 = sext i32 %2 to i64
%5 = getelementptr inbounds [6 x [4 x i32]], [6 x [4 x i32]]* @__const.NPGF.permut, i64 0, i64 %4, i64 0
%6 = load i32, i32* %5
%7 = getelementptr inbounds [6 x [4 x i32]], [6 x [4 x i32]]* @__const.NPGF.permut, i64 0, i64 %4, i64 1
%8 = load i32, i32* %7
%9 = sext i32 %6 to i64
%10 = getelementptr inbounds i32, i32* %0, i64 %9
%11 = load i32, i32* %10
%12 = sext i32 %8 to i64
%13 = getelementptr inbounds i32, i32* %0, i64 %12
%14 = load i32, i32* %13
%15 = mul nsw i32 %14, %11
%16 = getelementptr inbounds i32, i32* %1, i64 %9
%17 = load i32, i32* %16
%18 = add nsw i32 %17, 1
%19 = mul nsw i32 %15, %18
%20 = getelementptr inbounds i32, i32* %1, i64 %12
%21 = load i32, i32* %20
%22 = add nsw i32 %21, 1
%23 = mul nsw i32 %19, %22
ret i32 %23
}