#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 /*<<< orphan*/ CalcBands(int *, int const, int const, int);
int /*<<< orphan*/ Shellsort_int(int *, int);
int /*<<< orphan*/ cumSum(int const, int *, int, unsigned char *);
scalar_t__ modifyBands(int, int *, int);
int numberOfBands(int, int const, int const, double);
int UpdateFreqScale(unsigned char *v_k_master, int *h_num_bands, const int k0,
                    const int k2, const int freqScale, const int alterScale) {
  int b_p_o = 0;
  float warp = 0;
  int dk = 0;
  int two_regions = 0;
  int k1 = 0, i;
  int num_bands0;
  int num_bands1;
  int diff_tot[29 + 50];
  int *diff0 = diff_tot;
  int *diff1 = diff_tot + 29;
  int k2_achived;
  int k2_diff;
  int incr = 0;
  ;
  ;
  ;
  ;
  ;
  if (freqScale == 1) {
    ;
    b_p_o = 12;
  };
  ;
  if (freqScale == 2) {
    ;
    b_p_o = 10;
  };
  ;
  if (freqScale == 3) {
    ;
    b_p_o = 8;
  };
  if (freqScale > 0) {
    ;
    if (alterScale == 0) {
      ;
      warp = 1.0;
    } else {
      ;
      warp = 1.3f;
    };
    ;
    ;
    if (4 * k2 >= 9 * k0) {
      ;
      two_regions = 1;
      ;
      k1 = 2 * k0;
      ;
      num_bands0 = numberOfBands(b_p_o, k0, k1, 1.0);
      ;
      num_bands1 = numberOfBands(b_p_o, k1, k2, warp);
      ;
      CalcBands(diff0, k0, k1, num_bands0);
      ;
      Shellsort_int(diff0, num_bands0);
      ;
      if (diff0[0] == 0) {
        ;
        return (1);
      };
      cumSum(k0, diff0, num_bands0, v_k_master);
      ;
      CalcBands(diff1, k1, k2, num_bands1);
      ;
      Shellsort_int(diff1, num_bands1);
      ;
      ;
      ;
      if (diff0[num_bands0 - 1] > diff1[0]) {
        ;
        ;
        ;
        if (modifyBands(diff0[num_bands0 - 1], diff1, num_bands1)) {
          ;
          return (1);
        }
      };
      ;
      ;
      cumSum(k1, diff1, num_bands1, &v_k_master[num_bands0]);
      ;
      ;
      *h_num_bands = num_bands0 + num_bands1;
    } else {
      ;
      two_regions = 0;
      k1 = k2;
      ;
      num_bands0 = numberOfBands(b_p_o, k0, k1, 1.0);
      ;
      CalcBands(diff0, k0, k1, num_bands0);
      ;
      Shellsort_int(diff0, num_bands0);
      ;
      if (diff0[0] == 0) {
        ;
        return (1);
      };
      cumSum(k0, diff0, num_bands0, v_k_master);
      ;
      *h_num_bands = num_bands0;
    }
  } else {
    ;
    if (alterScale == 0) {
      ;
      dk = 1;
      ;
      ;
      ;
      num_bands0 = 2 * ((k2 - k0) / 2);
    } else {
      ;
      dk = 2;
      ;
      ;
      ;
      num_bands0 = 2 * (((k2 - k0) / dk + 1) / 2);
    };
    ;
    k2_achived = k0 + num_bands0 * dk;
    ;
    k2_diff = k2 - k2_achived;
    ;
    ;
    for (i = 0; i < num_bands0; i++) {
      ;
      diff_tot[i] = dk;
    };
    if (k2_diff < 0) {
      ;
      incr = 1;
      i = 0;
    };
    if (k2_diff > 0) {
      ;
      incr = -1;
      ;
      i = num_bands0 - 1;
    };
    ;
    while (k2_diff != 0) {
      ;
      ;
      diff_tot[i] = diff_tot[i] - incr;
      i = i + incr;
      ;
      k2_diff = k2_diff + incr;
    };
    cumSum(k0, diff_tot, num_bands0, v_k_master);
    ;
    *h_num_bands = num_bands0;
  };
  ;
  if (*h_num_bands < 1) {
    ;
    return (1);
  };
  return (0);
}


x86 assembly (clang, -O0):
<UpdateFreqScale>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1b0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
lea    -0x190(%rbp),%rax
mov    %rax,-0x198(%rbp)
lea    -0x190(%rbp),%rax
add    $0x74,%rax
mov    %rax,-0x1a0(%rbp)
movl   $0x0,-0x1ac(%rbp)
cmpl   $0x1,-0x24(%rbp)
jne    11d0 <UpdateFreqScale+0x80>
movl   $0xc,-0x2c(%rbp)
cmpl   $0x2,-0x24(%rbp)
jne    11e1 <UpdateFreqScale+0x91>
movl   $0xa,-0x2c(%rbp)
cmpl   $0x3,-0x24(%rbp)
jne    11f2 <UpdateFreqScale+0xa2>
movl   $0x8,-0x2c(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    140b <UpdateFreqScale+0x2bb>
cmpl   $0x0,-0x28(%rbp)
jne    1218 <UpdateFreqScale+0xc8>
movss  0xdf6(%rip),%xmm0
movss  %xmm0,-0x30(%rbp)
jmp    1225 <UpdateFreqScale+0xd5>
movss  0xde0(%rip),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x2,%eax
imul   $0x9,-0x1c(%rbp),%ecx
cmp    %ecx,%eax
jl     1381 <UpdateFreqScale+0x231>
movl   $0x1,-0x38(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x2c(%rbp),%edi
mov    -0x1c(%rbp),%esi
mov    -0x3c(%rbp),%edx
movsd  0xdb0(%rip),%xmm0
call   1070 <numberOfBands@plt>
mov    %eax,-0x44(%rbp)
mov    -0x2c(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x20(%rbp),%edx
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1070 <numberOfBands@plt>
mov    %eax,-0x48(%rbp)
mov    -0x198(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x3c(%rbp),%edx
mov    -0x44(%rbp),%ecx
call   1030 <CalcBands@plt>
mov    -0x198(%rbp),%rdi
mov    -0x44(%rbp),%esi
call   1040 <Shellsort_int@plt>
mov    -0x198(%rbp),%rax
cmpl   $0x0,(%rax)
jne    12ba <UpdateFreqScale+0x16a>
movl   $0x1,-0x4(%rbp)
jmp    1575 <UpdateFreqScale+0x425>
mov    -0x1c(%rbp),%edi
mov    -0x198(%rbp),%rsi
mov    -0x44(%rbp),%edx
mov    -0x10(%rbp),%rcx
call   1060 <cumSum@plt>
mov    -0x1a0(%rbp),%rdi
mov    -0x3c(%rbp),%esi
mov    -0x20(%rbp),%edx
mov    -0x48(%rbp),%ecx
call   1030 <CalcBands@plt>
mov    -0x1a0(%rbp),%rdi
mov    -0x48(%rbp),%esi
call   1040 <Shellsort_int@plt>
mov    -0x198(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x1a0(%rbp),%rcx
cmp    (%rcx),%eax
jle    1353 <UpdateFreqScale+0x203>
mov    -0x198(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x1a0(%rbp),%rsi
mov    -0x48(%rbp),%edx
call   1050 <modifyBands@plt>
cmp    $0x0,%rax
je     134e <UpdateFreqScale+0x1fe>
movl   $0x1,-0x4(%rbp)
jmp    1575 <UpdateFreqScale+0x425>
jmp    1353 <UpdateFreqScale+0x203>
mov    -0x3c(%rbp),%edi
mov    -0x1a0(%rbp),%rsi
mov    -0x48(%rbp),%edx
mov    -0x10(%rbp),%rcx
movslq -0x44(%rbp),%rax
add    %rax,%rcx
call   1060 <cumSum@plt>
mov    -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
jmp    1406 <UpdateFreqScale+0x2b6>
movl   $0x0,-0x38(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x2c(%rbp),%edi
mov    -0x1c(%rbp),%esi
mov    -0x3c(%rbp),%edx
movsd  0xc69(%rip),%xmm0
call   1070 <numberOfBands@plt>
mov    %eax,-0x44(%rbp)
mov    -0x198(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x3c(%rbp),%edx
mov    -0x44(%rbp),%ecx
call   1030 <CalcBands@plt>
mov    -0x198(%rbp),%rdi
mov    -0x44(%rbp),%esi
call   1040 <Shellsort_int@plt>
mov    -0x198(%rbp),%rax
cmpl   $0x0,(%rax)
jne    13e7 <UpdateFreqScale+0x297>
movl   $0x1,-0x4(%rbp)
jmp    1575 <UpdateFreqScale+0x425>
mov    -0x1c(%rbp),%edi
mov    -0x198(%rbp),%rsi
mov    -0x44(%rbp),%edx
mov    -0x10(%rbp),%rcx
call   1060 <cumSum@plt>
mov    -0x44(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
jmp    1555 <UpdateFreqScale+0x405>
cmpl   $0x0,-0x28(%rbp)
jne    1435 <UpdateFreqScale+0x2e5>
movl   $0x1,-0x34(%rbp)
mov    -0x20(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
shl    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1457 <UpdateFreqScale+0x307>
movl   $0x2,-0x34(%rbp)
mov    -0x20(%rbp),%eax
sub    -0x1c(%rbp),%eax
cltd
idivl  -0x34(%rbp)
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
shl    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x44(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x1a4(%rbp)
mov    -0x20(%rbp),%eax
sub    -0x1a4(%rbp),%eax
mov    %eax,-0x1a8(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    14a7 <UpdateFreqScale+0x357>
mov    -0x34(%rbp),%ecx
movslq -0x40(%rbp),%rax
mov    %ecx,-0x190(%rbp,%rax,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    147f <UpdateFreqScale+0x32f>
cmpl   $0x0,-0x1a8(%rbp)
jge    14c5 <UpdateFreqScale+0x375>
movl   $0x1,-0x1ac(%rbp)
movl   $0x0,-0x40(%rbp)
cmpl   $0x0,-0x1a8(%rbp)
jle    14e5 <UpdateFreqScale+0x395>
movl   $0xffffffff,-0x1ac(%rbp)
ff ff ff
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    14ea <UpdateFreqScale+0x39a>
cmpl   $0x0,-0x1a8(%rbp)
je     1536 <UpdateFreqScale+0x3e6>
movslq -0x40(%rbp),%rax
mov    -0x190(%rbp,%rax,4),%ecx
sub    -0x1ac(%rbp),%ecx
movslq -0x40(%rbp),%rax
mov    %ecx,-0x190(%rbp,%rax,4)
mov    -0x40(%rbp),%eax
add    -0x1ac(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x1a8(%rbp),%eax
add    -0x1ac(%rbp),%eax
mov    %eax,-0x1a8(%rbp)
jmp    14ea <UpdateFreqScale+0x39a>
mov    -0x1c(%rbp),%edi
lea    -0x190(%rbp),%rsi
mov    -0x44(%rbp),%edx
mov    -0x10(%rbp),%rcx
call   1060 <cumSum@plt>
mov    -0x44(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
cmpl   $0x1,(%rax)
jge    156e <UpdateFreqScale+0x41e>
movl   $0x1,-0x4(%rbp)
jmp    1575 <UpdateFreqScale+0x425>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<UpdateFreqScale>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %ecx,%ebx
mov    %edx,%r12d
mov    %rsi,%r14
mov    %rdi,%r15
xor    %eax,%eax
cmp    $0x1,%r8d
mov    $0xc,%ecx
cmovne %eax,%ecx
cmp    $0x2,%r8d
mov    $0xa,%eax
cmovne %ecx,%eax
cmp    $0x3,%r8d
mov    $0x8,%ebp
cmovne %eax,%ebp
test   %r8d,%r8d
jle    11f2 <UpdateFreqScale+0xa2>
lea    0x0(,%rbx,4),%eax
lea    (%r12,%r12,8),%ecx
cmp    %ecx,%eax
jge    1218 <UpdateFreqScale+0xc8>
movq   0xe62(%rip),%xmm0
mov    %ebp,%edi
mov    %r12d,%esi
mov    %ebx,%edx
call   1070 <numberOfBands@plt>
mov    %eax,%r13d
lea    0x20(%rsp),%rbp
mov    %rbp,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
mov    %eax,%ecx
call   1030 <CalcBands@plt>
mov    %rbp,%rdi
mov    %r13d,%esi
call   1040 <Shellsort_int@plt>
cmpl   $0x0,0x20(%rsp)
jne    14a9 <UpdateFreqScale+0x359>
mov    $0x1,%r15d
jmp    14c9 <UpdateFreqScale+0x379>
mov    %ebx,%edx
sub    %r12d,%edx
test   %r9d,%r9d
je     1323 <UpdateFreqScale+0x1d3>
mov    %edx,%eax
shr    $0x1f,%eax
add    %edx,%eax
sar    %eax
add    $0x1,%eax
mov    $0x2,%ecx
mov    %eax,%edx
jmp    1328 <UpdateFreqScale+0x1d8>
mov    %r15,0x8(%rsp)
mov    %r14,0x10(%rsp)
xor    %eax,%eax
test   %r9d,%r9d
sete   %al
lea    0xdcf(%rip),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x18(%rsp)
lea    (%r12,%r12,1),%r14d
movsd  0xdc8(%rip),%xmm0
mov    %ebp,%edi
mov    %r12d,%esi
mov    %r14d,%edx
call   1070 <numberOfBands@plt>
mov    %eax,%r15d
mov    %ebp,%edi
mov    %r14d,%esi
mov    %ebx,%edx
movq   0x18(%rsp),%xmm0
call   1070 <numberOfBands@plt>
mov    %eax,%r13d
lea    0x20(%rsp),%rbp
mov    %rbp,%rdi
mov    %r12d,%esi
mov    %r14d,%edx
mov    %r15d,%ecx
call   1030 <CalcBands@plt>
mov    %rbp,%rdi
mov    %r15d,%ebp
mov    %r15d,%esi
call   1040 <Shellsort_int@plt>
mov    $0x1,%r15d
cmpl   $0x0,0x20(%rsp)
je     14c9 <UpdateFreqScale+0x379>
lea    0x94(%rsp),%rax
lea    0x20(%rsp),%rsi
mov    %r12d,%edi
mov    %rax,%r12
mov    %ebp,%edx
mov    0x8(%rsp),%rcx
call   1060 <cumSum@plt>
mov    %r12,%rdi
mov    %r14d,%esi
mov    %ebx,%edx
mov    %r13d,%ecx
call   1030 <CalcBands@plt>
mov    %r12,%rdi
mov    %r13d,%esi
call   1040 <Shellsort_int@plt>
movslq %ebp,%rbx
mov    0x1c(%rsp,%rbx,4),%edi
cmp    0x94(%rsp),%edi
jle    1300 <UpdateFreqScale+0x1b0>
mov    %r12,%rsi
mov    %r13d,%edx
call   1050 <modifyBands@plt>
test   %rax,%rax
jne    14c9 <UpdateFreqScale+0x379>
mov    0x8(%rsp),%rcx
add    %rbx,%rcx
mov    %r14d,%edi
mov    %r12,%rsi
mov    %r13d,%edx
call   1060 <cumSum@plt>
add    %ebp,%r13d
mov    0x10(%rsp),%r14
jmp    14bc <UpdateFreqScale+0x36c>
mov    $0x1,%ecx
mov    %edx,%r13d
shr    $0x1f,%r13d
add    %edx,%r13d
and    $0xfffffffe,%r13d
mov    %r13d,%eax
imul   %ecx,%eax
add    %r12d,%eax
sub    %eax,%ebx
xor    %eax,%eax
cmp    $0x2,%edx
jl     146d <UpdateFreqScale+0x31d>
cmp    $0x2,%r13d
mov    $0x1,%eax
cmovge %r13d,%eax
cmp    $0x8,%eax
jae    1365 <UpdateFreqScale+0x215>
xor    %edx,%edx
jmp    1460 <UpdateFreqScale+0x310>
mov    %eax,%edx
and    $0x7ffffff8,%edx
movd   %ecx,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rdx),%rbp
mov    %rbp,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x7,%esi
cmp    $0x38,%rbp
jae    1397 <UpdateFreqScale+0x247>
xor    %ebp,%ebp
jmp    142c <UpdateFreqScale+0x2dc>
and    $0xfffffffffffffff8,%rdi
xor    %ebp,%ebp
nopl   (%rax)
movdqa %xmm0,0x20(%rsp,%rbp,4)
movdqa %xmm0,0x30(%rsp,%rbp,4)
movdqa %xmm0,0x40(%rsp,%rbp,4)
movdqa %xmm0,0x50(%rsp,%rbp,4)
movdqa %xmm0,0x60(%rsp,%rbp,4)
movdqa %xmm0,0x70(%rsp,%rbp,4)
movdqa %xmm0,0x80(%rsp,%rbp,4)
movdqa %xmm0,0x90(%rsp,%rbp,4)
movdqa %xmm0,0xa0(%rsp,%rbp,4)
movdqa %xmm0,0xb0(%rsp,%rbp,4)
movdqa %xmm0,0xc0(%rsp,%rbp,4)
movdqa %xmm0,0xd0(%rsp,%rbp,4)
movdqa %xmm0,0xe0(%rsp,%rbp,4)
movdqa %xmm0,0xf0(%rsp,%rbp,4)
movdqa %xmm0,0x100(%rsp,%rbp,4)
movdqa %xmm0,0x110(%rsp,%rbp,4)
add    $0x40,%rbp
add    $0xfffffffffffffff8,%rdi
jne    13a0 <UpdateFreqScale+0x250>
test   %rsi,%rsi
je     1454 <UpdateFreqScale+0x304>
lea    (%rsp,%rbp,4),%rdi
add    $0x30,%rdi
shl    $0x5,%rsi
xor    %ebp,%ebp
nop
movdqa %xmm0,-0x10(%rdi,%rbp,1)
movdqa %xmm0,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    1440 <UpdateFreqScale+0x2f0>
cmp    %rax,%rdx
je     146d <UpdateFreqScale+0x31d>
nopl   0x0(%rax)
mov    %ecx,0x20(%rsp,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1460 <UpdateFreqScale+0x310>
mov    %ebx,%edx
shr    $0x1f,%edx
mov    $0xffffffff,%ecx
test   %ebx,%ebx
cmovle %edx,%ecx
je     14a9 <UpdateFreqScale+0x359>
lea    -0x1(%r13),%edx
xor    %esi,%esi
test   %ebx,%ebx
cmovs  %esi,%eax
cmovg  %edx,%eax
movslq %eax,%rdx
movslq %ecx,%rax
lea    (%rsp,%rdx,4),%rdx
add    $0x20,%rdx
shl    $0x2,%rax
xchg   %ax,%ax
sub    %ecx,(%rdx)
add    %rax,%rdx
add    %ecx,%ebx
jne    14a0 <UpdateFreqScale+0x350>
lea    0x20(%rsp),%rsi
mov    %r12d,%edi
mov    %r13d,%edx
mov    %r15,%rcx
call   1060 <cumSum@plt>
mov    %r13d,(%r14)
xor    %r15d,%r15d
test   %r13d,%r13d
setle  %r15b
mov    %r15d,%eax
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @UpdateFreqScale(i8* %0, i32* %1, i32 %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i32*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca float
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca [79 x i32]
%23 = alloca i32*
%24 = alloca i32*
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
store i8* %0, i8** %8
store i32* %1, i32** %9
store i32 %2, i32* %10
store i32 %3, i32* %11
store i32 %4, i32* %12
store i32 %5, i32* %13
store i32 0, i32* %14
store float 0.000000e+00, float* %15
store i32 0, i32* %16
store i32 0, i32* %17
store i32 0, i32* %18
%28 = getelementptr inbounds [79 x i32], [79 x i32]* %22, i64 0, i64 0
store i32* %28, i32** %23
%29 = getelementptr inbounds [79 x i32], [79 x i32]* %22, i64 0, i64 0
%30 = getelementptr inbounds i32, i32* %29, i64 29
store i32* %30, i32** %24
store i32 0, i32* %27
%31 = load i32, i32* %12
%32 = icmp eq i32 %31, 1
br i1 %32, label %33, label %34
33: ; preds = %6
store i32 12, i32* %14
br label %34
34: ; preds = %33, %6
%35 = load i32, i32* %12
%36 = icmp eq i32 %35, 2
br i1 %36, label %37, label %38
37: ; preds = %34
store i32 10, i32* %14
br label %38
38: ; preds = %37, %34
%39 = load i32, i32* %12
%40 = icmp eq i32 %39, 3
br i1 %40, label %41, label %42
41: ; preds = %38
store i32 8, i32* %14
br label %42
42: ; preds = %41, %38
%43 = load i32, i32* %12
%44 = icmp sgt i32 %43, 0
br i1 %44, label %45, label %160
45: ; preds = %42
%46 = load i32, i32* %13
%47 = icmp eq i32 %46, 0
br i1 %47, label %48, label %49
48: ; preds = %45
store float 1.000000e+00, float* %15
br label %50
49: ; preds = %45
store float 0x3FF4CCCCC0000000, float* %15
br label %50
50: ; preds = %49, %48
%51 = load i32, i32* %11
%52 = mul nsw i32 4, %51
%53 = load i32, i32* %10
%54 = mul nsw i32 9, %53
%55 = icmp sge i32 %52, %54
br i1 %55, label %56, label %132
56: ; preds = %50
store i32 1, i32* %17
%57 = load i32, i32* %10
%58 = mul nsw i32 2, %57
store i32 %58, i32* %18
%59 = load i32, i32* %14
%60 = load i32, i32* %10
%61 = load i32, i32* %18
%62 = call i32 @numberOfBands(i32 %59, i32 %60, i32 %61, double 1.000000e+00)
store i32 %62, i32* %20
%63 = load i32, i32* %14
%64 = load i32, i32* %18
%65 = load i32, i32* %11
%66 = load float, float* %15
%67 = fpext float %66 to double
%68 = call i32 @numberOfBands(i32 %63, i32 %64, i32 %65, double %67)
store i32 %68, i32* %21
%69 = load i32*, i32** %23
%70 = load i32, i32* %10
%71 = load i32, i32* %18
%72 = load i32, i32* %20
%73 = call i32 @CalcBands(i32* %69, i32 %70, i32 %71, i32 %72)
%74 = load i32*, i32** %23
%75 = load i32, i32* %20
%76 = call i32 @Shellsort_int(i32* %74, i32 %75)
%77 = load i32*, i32** %23
%78 = getelementptr inbounds i32, i32* %77, i64 0
%79 = load i32, i32* %78
%80 = icmp eq i32 %79, 0
br i1 %80, label %81, label %82
81: ; preds = %56
store i32 1, i32* %7
br label %243
82: ; preds = %56
%83 = load i32, i32* %10
%84 = load i32*, i32** %23
%85 = load i32, i32* %20
%86 = load i8*, i8** %8
%87 = call i32 @cumSum(i32 %83, i32* %84, i32 %85, i8* %86)
%88 = load i32*, i32** %24
%89 = load i32, i32* %18
%90 = load i32, i32* %11
%91 = load i32, i32* %21
%92 = call i32 @CalcBands(i32* %88, i32 %89, i32 %90, i32 %91)
%93 = load i32*, i32** %24
%94 = load i32, i32* %21
%95 = call i32 @Shellsort_int(i32* %93, i32 %94)
%96 = load i32*, i32** %23
%97 = load i32, i32* %20
%98 = sub nsw i32 %97, 1
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i32, i32* %96, i64 %99
%101 = load i32, i32* %100
%102 = load i32*, i32** %24
%103 = getelementptr inbounds i32, i32* %102, i64 0
%104 = load i32, i32* %103
%105 = icmp sgt i32 %101, %104
br i1 %105, label %106, label %119
106: ; preds = %82
%107 = load i32*, i32** %23
%108 = load i32, i32* %20
%109 = sub nsw i32 %108, 1
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds i32, i32* %107, i64 %110
%112 = load i32, i32* %111
%113 = load i32*, i32** %24
%114 = load i32, i32* %21
%115 = call i64 @modifyBands(i32 %112, i32* %113, i32 %114)
%116 = icmp ne i64 %115, 0
br i1 %116, label %117, label %118
117: ; preds = %106
store i32 1, i32* %7
br label %243
118: ; preds = %106
br label %119
119: ; preds = %118, %82
%120 = load i32, i32* %18
%121 = load i32*, i32** %24
%122 = load i32, i32* %21
%123 = load i8*, i8** %8
%124 = load i32, i32* %20
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i8, i8* %123, i64 %125
%127 = call i32 @cumSum(i32 %120, i32* %121, i32 %122, i8* %126)
%128 = load i32, i32* %20
%129 = load i32, i32* %21
%130 = add nsw i32 %128, %129
%131 = load i32*, i32** %9
store i32 %130, i32* %131
br label %159
132: ; preds = %50
store i32 0, i32* %17
%133 = load i32, i32* %11
store i32 %133, i32* %18
%134 = load i32, i32* %14
%135 = load i32, i32* %10
%136 = load i32, i32* %18
%137 = call i32 @numberOfBands(i32 %134, i32 %135, i32 %136, double 1.000000e+00)
store i32 %137, i32* %20
%138 = load i32*, i32** %23
%139 = load i32, i32* %10
%140 = load i32, i32* %18
%141 = load i32, i32* %20
%142 = call i32 @CalcBands(i32* %138, i32 %139, i32 %140, i32 %141)
%143 = load i32*, i32** %23
%144 = load i32, i32* %20
%145 = call i32 @Shellsort_int(i32* %143, i32 %144)
%146 = load i32*, i32** %23
%147 = getelementptr inbounds i32, i32* %146, i64 0
%148 = load i32, i32* %147
%149 = icmp eq i32 %148, 0
br i1 %149, label %150, label %151
150: ; preds = %132
store i32 1, i32* %7
br label %243
151: ; preds = %132
%152 = load i32, i32* %10
%153 = load i32*, i32** %23
%154 = load i32, i32* %20
%155 = load i8*, i8** %8
%156 = call i32 @cumSum(i32 %152, i32* %153, i32 %154, i8* %155)
%157 = load i32, i32* %20
%158 = load i32*, i32** %9
store i32 %157, i32* %158
br label %159
159: ; preds = %151, %119
br label %237
160: ; preds = %42
%161 = load i32, i32* %13
%162 = icmp eq i32 %161, 0
br i1 %162, label %163, label %169
163: ; preds = %160
store i32 1, i32* %16
%164 = load i32, i32* %11
%165 = load i32, i32* %10
%166 = sub nsw i32 %164, %165
%167 = sdiv i32 %166, 2
%168 = mul nsw i32 2, %167
store i32 %168, i32* %20
br label %178
169: ; preds = %160
store i32 2, i32* %16
%170 = load i32, i32* %11
%171 = load i32, i32* %10
%172 = sub nsw i32 %170, %171
%173 = load i32, i32* %16
%174 = sdiv i32 %172, %173
%175 = add nsw i32 %174, 1
%176 = sdiv i32 %175, 2
%177 = mul nsw i32 2, %176
store i32 %177, i32* %20
br label %178
178: ; preds = %169, %163
%179 = load i32, i32* %10
%180 = load i32, i32* %20
%181 = load i32, i32* %16
%182 = mul nsw i32 %180, %181
%183 = add nsw i32 %179, %182
store i32 %183, i32* %25
%184 = load i32, i32* %11
%185 = load i32, i32* %25
%186 = sub nsw i32 %184, %185
store i32 %186, i32* %26
store i32 0, i32* %19
br label %187
187: ; preds = %196, %178
%188 = load i32, i32* %19
%189 = load i32, i32* %20
%190 = icmp slt i32 %188, %189
br i1 %190, label %191, label %199
191: ; preds = %187
%192 = load i32, i32* %16
%193 = load i32, i32* %19
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds [79 x i32], [79 x i32]* %22, i64 0, i64 %194
store i32 %192, i32* %195
br label %196
196: ; preds = %191
%197 = load i32, i32* %19
%198 = add nsw i32 %197, 1
store i32 %198, i32* %19
br label %187
199: ; preds = %187
%200 = load i32, i32* %26
%201 = icmp slt i32 %200, 0
br i1 %201, label %202, label %203
202: ; preds = %199
store i32 1, i32* %27
store i32 0, i32* %19
br label %203
203: ; preds = %202, %199
%204 = load i32, i32* %26
%205 = icmp sgt i32 %204, 0
br i1 %205, label %206, label %209
206: ; preds = %203
store i32 -1, i32* %27
%207 = load i32, i32* %20
%208 = sub nsw i32 %207, 1
store i32 %208, i32* %19
br label %209
209: ; preds = %206, %203
br label %210
210: ; preds = %213, %209
%211 = load i32, i32* %26
%212 = icmp ne i32 %211, 0
br i1 %212, label %213, label %229
213: ; preds = %210
%214 = load i32, i32* %19
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds [79 x i32], [79 x i32]* %22, i64 0, i64 %215
%217 = load i32, i32* %216
%218 = load i32, i32* %27
%219 = sub nsw i32 %217, %218
%220 = load i32, i32* %19
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds [79 x i32], [79 x i32]* %22, i64 0, i64 %221
store i32 %219, i32* %222
%223 = load i32, i32* %19
%224 = load i32, i32* %27
%225 = add nsw i32 %223, %224
store i32 %225, i32* %19
%226 = load i32, i32* %26
%227 = load i32, i32* %27
%228 = add nsw i32 %226, %227
store i32 %228, i32* %26
br label %210
229: ; preds = %210
%230 = load i32, i32* %10
%231 = getelementptr inbounds [79 x i32], [79 x i32]* %22, i64 0, i64 0
%232 = load i32, i32* %20
%233 = load i8*, i8** %8
%234 = call i32 @cumSum(i32 %230, i32* %231, i32 %232, i8* %233)
%235 = load i32, i32* %20
%236 = load i32*, i32** %9
store i32 %235, i32* %236
br label %237
237: ; preds = %229, %159
%238 = load i32*, i32** %9
%239 = load i32, i32* %238
%240 = icmp slt i32 %239, 1
br i1 %240, label %241, label %242
241: ; preds = %237
store i32 1, i32* %7
br label %243
242: ; preds = %237
store i32 0, i32* %7
br label %243
243: ; preds = %242, %241, %150, %117, %81
%244 = load i32, i32* %7
ret i32 %244
}

LLVM IR (-O2):
define i32 @UpdateFreqScale(i8* %0, i32* nocapture %1, i32 %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca [79 x i32]
%8 = bitcast [79 x i32]* %7 to i8*
%9 = getelementptr inbounds [79 x i32], [79 x i32]* %7, i64 0, i64 0
%10 = getelementptr inbounds [79 x i32], [79 x i32]* %7, i64 0, i64 29
%11 = icmp eq i32 %4, 1
%12 = select i1 %11, i32 12, i32 0
%13 = icmp eq i32 %4, 2
%14 = select i1 %13, i32 10, i32 %12
%15 = icmp eq i32 %4, 3
%16 = select i1 %15, i32 8, i32 %14
%17 = icmp sgt i32 %4, 0
br i1 %17, label %18, label %58
18: ; preds = %6
%19 = shl nsw i32 %3, 2
%20 = mul nsw i32 %2, 9
%21 = icmp slt i32 %19, %20
br i1 %21, label %50, label %22
22: ; preds = %18
%23 = icmp eq i32 %5, 0
%24 = select i1 %23, double 1.000000e+00, double 0x3FF4CCCCC0000000
%25 = shl nsw i32 %2, 1
%26 = tail call i32 @numberOfBands(i32 %16, i32 %2, i32 %25, double 1.000000e+00)
%27 = tail call i32 @numberOfBands(i32 %16, i32 %25, i32 %3, double %24)
%28 = call i32 @CalcBands(i32* %9, i32 %2, i32 %25, i32 %26)
%29 = call i32 @Shellsort_int(i32* %9, i32 %26)
%30 = load i32, i32* %9
%31 = icmp eq i32 %30, 0
br i1 %31, label %185, label %32
32: ; preds = %22
%33 = call i32 @cumSum(i32 %2, i32* %9, i32 %26, i8* %0)
%34 = call i32 @CalcBands(i32* %10, i32 %25, i32 %3, i32 %27)
%35 = call i32 @Shellsort_int(i32* %10, i32 %27)
%36 = add nsw i32 %26, -1
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds [79 x i32], [79 x i32]* %7, i64 0, i64 %37
%39 = load i32, i32* %38
%40 = load i32, i32* %10
%41 = icmp sgt i32 %39, %40
br i1 %41, label %42, label %45
42: ; preds = %32
%43 = call i64 @modifyBands(i32 %39, i32* %10, i32 %27)
%44 = icmp eq i64 %43, 0
br i1 %44, label %45, label %185
45: ; preds = %42, %32
%46 = sext i32 %26 to i64
%47 = getelementptr inbounds i8, i8* %0, i64 %46
%48 = call i32 @cumSum(i32 %25, i32* %10, i32 %27, i8* %47)
%49 = add nsw i32 %27, %26
br label %181
50: ; preds = %18
%51 = tail call i32 @numberOfBands(i32 %16, i32 %2, i32 %3, double 1.000000e+00)
%52 = call i32 @CalcBands(i32* %9, i32 %2, i32 %3, i32 %51)
%53 = call i32 @Shellsort_int(i32* %9, i32 %51)
%54 = load i32, i32* %9
%55 = icmp eq i32 %54, 0
br i1 %55, label %185, label %56
56: ; preds = %50
%57 = call i32 @cumSum(i32 %2, i32* %9, i32 %51, i8* %0)
br label %181
58: ; preds = %6
%59 = icmp eq i32 %5, 0
%60 = sub nsw i32 %3, %2
br i1 %59, label %64, label %61
61: ; preds = %58
%62 = sdiv i32 %60, 2
%63 = add nsw i32 %62, 1
br label %64
64: ; preds = %58, %61
%65 = phi i32 [ %63, %61 ], [ %60, %58 ]
%66 = phi i32 [ 2, %61 ], [ 1, %58 ]
%67 = sdiv i32 %65, 2
%68 = shl nsw i32 %67, 1
%69 = mul nsw i32 %68, %66
%70 = add i32 %69, %2
%71 = sub i32 %3, %70
%72 = icmp sgt i32 %65, 1
br i1 %72, label %73, label %157
73: ; preds = %64
%74 = call i32 @llvm.smax.i32(i32 %68, i32 1)
%75 = zext i32 %74 to i64
%76 = icmp ult i32 %74, 8
br i1 %76, label %150, label %77
77: ; preds = %73
%78 = and i64 %75, 2147483640
%79 = insertelement <4 x i32> poison, i32 %66, i64 0
%80 = shufflevector <4 x i32> %79, <4 x i32> poison, <4 x i32> zeroinitializer
%81 = insertelement <4 x i32> poison, i32 %66, i64 0
%82 = shufflevector <4 x i32> %81, <4 x i32> poison, <4 x i32> zeroinitializer
%83 = add nsw i64 %78, -8
%84 = lshr exact i64 %83, 3
%85 = add nuw nsw i64 %84, 1
%86 = and i64 %85, 7
%87 = icmp ult i64 %83, 56
br i1 %87, label %135, label %88
88: ; preds = %77
%89 = and i64 %85, 4611686018427387896
br label %90
90: ; preds = %90, %88
%91 = phi i64 [ 0, %88 ], [ %132, %90 ]
%92 = phi i64 [ 0, %88 ], [ %133, %90 ]
%93 = getelementptr inbounds [79 x i32], [79 x i32]* %7, i64 0, i64 %91
%94 = bitcast i32* %93 to <4 x i32>*
store <4 x i32> %80, <4 x i32>* %94
%95 = getelementptr inbounds i32, i32* %93, i64 4
%96 = bitcast i32* %95 to <4 x i32>*
store <4 x i32> %82, <4 x i32>* %96
%97 = or i64 %91, 8
%98 = getelementptr inbounds [79 x i32], [79 x i32]* %7, i64 0, i64 %97
%99 = bitcast i32* %98 to <4 x i32>*
store <4 x i32> %80, <4 x i32>* %99
%100 = getelementptr inbounds i32, i32* %98, i64 4
%101 = bitcast i32* %100 to <4 x i32>*
store <4 x i32> %82, <4 x i32>* %101
%102 = or i64 %91, 16
%103 = getelementptr inbounds [79 x i32], [79 x i32]* %7, i64 0, i64 %102
%104 = bitcast i32* %103 to <4 x i32>*
store <4 x i32> %80, <4 x i32>* %104
%105 = getelementptr inbounds i32, i32* %103, i64 4
%106 = bitcast i32* %105 to <4 x i32>*
store <4 x i32> %82, <4 x i32>* %106
%107 = or i64 %91, 24
%108 = getelementptr inbounds [79 x i32], [79 x i32]* %7, i64 0, i64 %107
%109 = bitcast i32* %108 to <4 x i32>*
store <4 x i32> %80, <4 x i32>* %109
%110 = getelementptr inbounds i32, i32* %108, i64 4
%111 = bitcast i32* %110 to <4 x i32>*
store <4 x i32> %82, <4 x i32>* %111
%112 = or i64 %91, 32
%113 = getelementptr inbounds [79 x i32], [79 x i32]* %7, i64 0, i64 %112
%114 = bitcast i32* %113 to <4 x i32>*
store <4 x i32> %80, <4 x i32>* %114
%115 = getelementptr inbounds i32, i32* %113, i64 4
%116 = bitcast i32* %115 to <4 x i32>*
store <4 x i32> %82, <4 x i32>* %116
%117 = or i64 %91, 40
%118 = getelementptr inbounds [79 x i32], [79 x i32]* %7, i64 0, i64 %117
%119 = bitcast i32* %118 to <4 x i32>*
store <4 x i32> %80, <4 x i32>* %119
%120 = getelementptr inbounds i32, i32* %118, i64 4
%121 = bitcast i32* %120 to <4 x i32>*
store <4 x i32> %82, <4 x i32>* %121
%122 = or i64 %91, 48
%123 = getelementptr inbounds [79 x i32], [79 x i32]* %7, i64 0, i64 %122
%124 = bitcast i32* %123 to <4 x i32>*
store <4 x i32> %80, <4 x i32>* %124
%125 = getelementptr inbounds i32, i32* %123, i64 4
%126 = bitcast i32* %125 to <4 x i32>*
store <4 x i32> %82, <4 x i32>* %126
%127 = or i64 %91, 56
%128 = getelementptr inbounds [79 x i32], [79 x i32]* %7, i64 0, i64 %127
%129 = bitcast i32* %128 to <4 x i32>*
store <4 x i32> %80, <4 x i32>* %129
%130 = getelementptr inbounds i32, i32* %128, i64 4
%131 = bitcast i32* %130 to <4 x i32>*
store <4 x i32> %82, <4 x i32>* %131
%132 = add nuw i64 %91, 64
%133 = add nuw i64 %92, 8
%134 = icmp eq i64 %133, %89
br i1 %134, label %135, label %90
135: ; preds = %90, %77
%136 = phi i64 [ 0, %77 ], [ %132, %90 ]
%137 = icmp eq i64 %86, 0
br i1 %137, label %148, label %138
138: ; preds = %135, %138
%139 = phi i64 [ %145, %138 ], [ %136, %135 ]
%140 = phi i64 [ %146, %138 ], [ 0, %135 ]
%141 = getelementptr inbounds [79 x i32], [79 x i32]* %7, i64 0, i64 %139
%142 = bitcast i32* %141 to <4 x i32>*
store <4 x i32> %80, <4 x i32>* %142
%143 = getelementptr inbounds i32, i32* %141, i64 4
%144 = bitcast i32* %143 to <4 x i32>*
store <4 x i32> %82, <4 x i32>* %144
%145 = add nuw i64 %139, 8
%146 = add i64 %140, 1
%147 = icmp eq i64 %146, %86
br i1 %147, label %148, label %138
148: ; preds = %138, %135
%149 = icmp eq i64 %78, %75
br i1 %149, label %157, label %150
150: ; preds = %73, %148
%151 = phi i64 [ 0, %73 ], [ %78, %148 ]
br label %152
152: ; preds = %150, %152
%153 = phi i64 [ %155, %152 ], [ %151, %150 ]
%154 = getelementptr inbounds [79 x i32], [79 x i32]* %7, i64 0, i64 %153
store i32 %66, i32* %154
%155 = add nuw nsw i64 %153, 1
%156 = icmp eq i64 %155, %75
br i1 %156, label %157, label %152
157: ; preds = %152, %148, %64
%158 = phi i32 [ 0, %64 ], [ %74, %148 ], [ %74, %152 ]
%159 = lshr i32 %71, 31
%160 = icmp sgt i32 %71, 0
%161 = select i1 %160, i32 -1, i32 %159
%162 = icmp eq i32 %71, 0
br i1 %162, label %179, label %163
163: ; preds = %157
%164 = add nsw i32 %68, -1
%165 = icmp slt i32 %71, 0
%166 = select i1 %165, i32 0, i32 %158
%167 = select i1 %160, i32 %164, i32 %166
%168 = sext i32 %167 to i64
%169 = sext i32 %161 to i64
br label %170
170: ; preds = %163, %170
%171 = phi i64 [ %168, %163 ], [ %176, %170 ]
%172 = phi i32 [ %71, %163 ], [ %177, %170 ]
%173 = getelementptr inbounds [79 x i32], [79 x i32]* %7, i64 0, i64 %171
%174 = load i32, i32* %173
%175 = sub nsw i32 %174, %161
store i32 %175, i32* %173
%176 = add i64 %171, %169
%177 = add nsw i32 %172, %161
%178 = icmp eq i32 %177, 0
br i1 %178, label %179, label %170
179: ; preds = %170, %157
%180 = call i32 @cumSum(i32 %2, i32* %9, i32 %68, i8* %0)
br label %181
181: ; preds = %45, %56, %179
%182 = phi i32 [ %49, %45 ], [ %51, %56 ], [ %68, %179 ]
store i32 %182, i32* %1
%183 = icmp slt i32 %182, 1
%184 = zext i1 %183 to i32
br label %185
185: ; preds = %181, %50, %42, %22
%186 = phi i32 [ 1, %22 ], [ 1, %42 ], [ 1, %50 ], [ %184, %181 ]
ret i32 %186
}