#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 uint8_t;
struct bladerf {
  int dummy;
};

/* Variables and functions */
int /*<<< orphan*/ assert(int);
int get_vtune(struct bladerf *, int, int, int *);
int vtune_high_to_norm(struct bladerf *, int, int, int, int *);
int vtune_low_to_norm(struct bladerf *, int, int, int, int *);
int vtune_norm_to_high(struct bladerf *, int, int, int, int *);
int wait_for_vtune_value(struct bladerf *, int, int, int *, int);
int write_vcocap(struct bladerf *, int, int, int);
int tune_vcocap(struct bladerf *dev, uint8_t vcocap_est, uint8_t base,
                uint8_t vcocap_reg_state, uint8_t *vcocap_result) {
  int status;
  uint8_t vcocap = vcocap_est;
  uint8_t vtune;
  uint8_t vtune_high_limit;
  uint8_t vtune_low_limit;
  do {
  } while (0);
  vtune_high_limit = 0x3f;
  vtune_low_limit = 0;
  status = get_vtune(dev, base, 50, &vtune);
  if (status != 0) {
    return status;
  }
  switch (vtune) {
  case 0x02:
    do {
      do {
      } while (0);
    } while (0);
    status = vtune_high_to_norm(dev, base, vcocap, vcocap_reg_state,
                                &vtune_high_limit);
    break;
  case 0x00:
    do {
      do {
      } while (0);
    } while (0);
    status = vtune_norm_to_high(dev, base, vcocap, vcocap_reg_state,
                                &vtune_high_limit);
    break;
  case 0x01:
    do {
      do {
      } while (0);
    } while (0);
    status = vtune_low_to_norm(dev, base, vcocap, vcocap_reg_state,
                               &vtune_low_limit);
    break;
  }
  if (status != 0) {
    return status;
  } else if (vtune_high_limit != 0x3f) {
    switch (vtune) {
    case 0x02:
    case 0x00:
      if (((int)vtune_high_limit + 12) < 0x3f) {
        vcocap = vtune_high_limit + 12;
      } else {
        vcocap = 0x3f;
        do {
          do {
          } while (0);
        } while (0);
      }
      break;
    default:
      assert(!"Invalid state");
      return (-1);
    }
    status = write_vcocap(dev, base, vcocap, vcocap_reg_state);
    if (status != 0) {
      return status;
    }
    do {
      do {
      } while (0);
    } while (0);
    status = wait_for_vtune_value(dev, base, 0x01, &vcocap, vcocap_reg_state);
    if (status == 0) {
      do {
        do {
        } while (0);
      } while (0);
      status = vtune_low_to_norm(dev, base, vcocap, vcocap_reg_state,
                                 &vtune_low_limit);
    }
  } else {
    switch (vtune) {
    case 0x01:
    case 0x00:
      if (((int)vtune_low_limit - 12) > 0) {
        vcocap = vtune_low_limit - 12;
      } else {
        vcocap = 0;
        do {
          do {
          } while (0);
        } while (0);
      }
      break;
    default:
      assert(!"Invalid state");
      return (-1);
    }
    status = write_vcocap(dev, base, vcocap, vcocap_reg_state);
    if (status != 0) {
      return status;
    }
    do {
      do {
      } while (0);
    } while (0);
    status = wait_for_vtune_value(dev, base, 0x02, &vcocap, vcocap_reg_state);
    if (status == 0) {
      do {
        do {
        } while (0);
      } while (0);
      status = vtune_high_to_norm(dev, base, vcocap, vcocap_reg_state,
                                  &vtune_high_limit);
    }
  }
  if (status == 0) {
    vcocap = vtune_high_limit + (vtune_low_limit - vtune_high_limit) / 2;
    do {
      do {
      } while (0);
    } while (0);
    do {
      do {
      } while (0);
    } while (0);
    do {
      do {
      } while (0);
    } while (0);
    do {
      do {
      } while (0);
    } while (0);
    status = write_vcocap(dev, base, vcocap, vcocap_reg_state);
    if (status != 0) {
      return status;
    }
    *vcocap_result = vcocap;
    status = get_vtune(dev, base, 25, &vtune);
    if (status != 0) {
      return status;
    };
    if (vtune != 0x00) {
      status = (-1);
      do {
        do {
        } while (0);
      } while (0);
    }
  }
  return status;
}


x86 assembly (clang, -O0):
<tune_vcocap>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1194 <tune_vcocap+0x24>
movl   $0x3f,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    $0x32,%edx
lea    -0x34(%rbp),%rcx
call   1040 <get_vtune@plt>
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     11cf <tune_vcocap+0x5f>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    15ac <tune_vcocap+0x43c>
mov    -0x34(%rbp),%eax
mov    %eax,-0x40(%rbp)
test   %eax,%eax
je     1236 <tune_vcocap+0xc6>
jmp    11e2 <tune_vcocap+0x72>
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
je     1268 <tune_vcocap+0xf8>
jmp    11f3 <tune_vcocap+0x83>
mov    -0x40(%rbp),%eax
sub    $0x2,%eax
jne    1295 <tune_vcocap+0x125>
jmp    1204 <tune_vcocap+0x94>
jmp    1209 <tune_vcocap+0x99>
jmp    120e <tune_vcocap+0x9e>
jmp    1213 <tune_vcocap+0xa3>
jmp    1218 <tune_vcocap+0xa8>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x30(%rbp),%edx
mov    -0x1c(%rbp),%ecx
lea    -0x38(%rbp),%r8
call   1070 <vtune_high_to_norm@plt>
mov    %eax,-0x2c(%rbp)
jmp    1295 <tune_vcocap+0x125>
jmp    123b <tune_vcocap+0xcb>
jmp    1240 <tune_vcocap+0xd0>
jmp    1245 <tune_vcocap+0xd5>
jmp    124a <tune_vcocap+0xda>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x30(%rbp),%edx
mov    -0x1c(%rbp),%ecx
lea    -0x38(%rbp),%r8
call   1060 <vtune_norm_to_high@plt>
mov    %eax,-0x2c(%rbp)
jmp    1295 <tune_vcocap+0x125>
jmp    126d <tune_vcocap+0xfd>
jmp    1272 <tune_vcocap+0x102>
jmp    1277 <tune_vcocap+0x107>
jmp    127c <tune_vcocap+0x10c>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x30(%rbp),%edx
mov    -0x1c(%rbp),%ecx
lea    -0x3c(%rbp),%r8
call   1080 <vtune_low_to_norm@plt>
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     12aa <tune_vcocap+0x13a>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    15ac <tune_vcocap+0x43c>
cmpl   $0x3f,-0x38(%rbp)
je     13ad <tune_vcocap+0x23d>
mov    -0x34(%rbp),%eax
test   $0xfffffffd,%eax
je     12c7 <tune_vcocap+0x157>
jmp    1304 <tune_vcocap+0x194>
mov    -0x38(%rbp),%eax
add    $0xc,%eax
cmp    $0x3f,%eax
jge    12e4 <tune_vcocap+0x174>
mov    -0x38(%rbp),%eax
add    $0xc,%eax
mov    %eax,-0x30(%rbp)
jmp    12ff <tune_vcocap+0x18f>
movl   $0x3f,-0x30(%rbp)
jmp    12f0 <tune_vcocap+0x180>
jmp    12f5 <tune_vcocap+0x185>
jmp    12fa <tune_vcocap+0x18a>
jmp    12ff <tune_vcocap+0x18f>
jmp    1317 <tune_vcocap+0x1a7>
xor    %edi,%edi
call   1030 <assert@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    15ac <tune_vcocap+0x43c>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x30(%rbp),%edx
mov    -0x1c(%rbp),%ecx
call   1050 <write_vcocap@plt>
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     1341 <tune_vcocap+0x1d1>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    15ac <tune_vcocap+0x43c>
jmp    1346 <tune_vcocap+0x1d6>
jmp    134b <tune_vcocap+0x1db>
jmp    1350 <tune_vcocap+0x1e0>
jmp    1355 <tune_vcocap+0x1e5>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%r8d
mov    $0x1,%edx
lea    -0x30(%rbp),%rcx
call   1090 <wait_for_vtune_value@plt>
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jne    13a8 <tune_vcocap+0x238>
jmp    1380 <tune_vcocap+0x210>
jmp    1385 <tune_vcocap+0x215>
jmp    138a <tune_vcocap+0x21a>
jmp    138f <tune_vcocap+0x21f>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x30(%rbp),%edx
mov    -0x1c(%rbp),%ecx
lea    -0x3c(%rbp),%r8
call   1080 <vtune_low_to_norm@plt>
mov    %eax,-0x2c(%rbp)
jmp    14a4 <tune_vcocap+0x334>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
ja     13fb <tune_vcocap+0x28b>
jmp    13be <tune_vcocap+0x24e>
mov    -0x3c(%rbp),%eax
sub    $0xc,%eax
cmp    $0x0,%eax
jle    13db <tune_vcocap+0x26b>
mov    -0x3c(%rbp),%eax
sub    $0xc,%eax
mov    %eax,-0x30(%rbp)
jmp    13f6 <tune_vcocap+0x286>
movl   $0x0,-0x30(%rbp)
jmp    13e7 <tune_vcocap+0x277>
jmp    13ec <tune_vcocap+0x27c>
jmp    13f1 <tune_vcocap+0x281>
jmp    13f6 <tune_vcocap+0x286>
jmp    140e <tune_vcocap+0x29e>
xor    %edi,%edi
call   1030 <assert@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    15ac <tune_vcocap+0x43c>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x30(%rbp),%edx
mov    -0x1c(%rbp),%ecx
call   1050 <write_vcocap@plt>
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     1438 <tune_vcocap+0x2c8>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    15ac <tune_vcocap+0x43c>
jmp    143d <tune_vcocap+0x2cd>
jmp    1442 <tune_vcocap+0x2d2>
jmp    1447 <tune_vcocap+0x2d7>
jmp    144c <tune_vcocap+0x2dc>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%r8d
mov    $0x2,%edx
lea    -0x30(%rbp),%rcx
call   1090 <wait_for_vtune_value@plt>
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jne    149f <tune_vcocap+0x32f>
jmp    1477 <tune_vcocap+0x307>
jmp    147c <tune_vcocap+0x30c>
jmp    1481 <tune_vcocap+0x311>
jmp    1486 <tune_vcocap+0x316>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x30(%rbp),%edx
mov    -0x1c(%rbp),%ecx
lea    -0x38(%rbp),%r8
call   1070 <vtune_high_to_norm@plt>
mov    %eax,-0x2c(%rbp)
jmp    14a4 <tune_vcocap+0x334>
jmp    14a9 <tune_vcocap+0x339>
cmpl   $0x0,-0x2c(%rbp)
jne    15a6 <tune_vcocap+0x436>
mov    -0x38(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x44(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x30(%rbp)
jmp    14d6 <tune_vcocap+0x366>
jmp    14db <tune_vcocap+0x36b>
jmp    14e0 <tune_vcocap+0x370>
jmp    14e5 <tune_vcocap+0x375>
jmp    14ea <tune_vcocap+0x37a>
jmp    14ef <tune_vcocap+0x37f>
jmp    14f4 <tune_vcocap+0x384>
jmp    14f9 <tune_vcocap+0x389>
jmp    14fe <tune_vcocap+0x38e>
jmp    1503 <tune_vcocap+0x393>
jmp    1508 <tune_vcocap+0x398>
jmp    150d <tune_vcocap+0x39d>
jmp    1512 <tune_vcocap+0x3a2>
jmp    1517 <tune_vcocap+0x3a7>
jmp    151c <tune_vcocap+0x3ac>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x30(%rbp),%edx
mov    -0x1c(%rbp),%ecx
call   1050 <write_vcocap@plt>
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     1546 <tune_vcocap+0x3d6>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    15ac <tune_vcocap+0x43c>
mov    -0x30(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    $0x19,%edx
lea    -0x34(%rbp),%rcx
call   1040 <get_vtune@plt>
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     157c <tune_vcocap+0x40c>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    15ac <tune_vcocap+0x43c>
cmpl   $0x0,-0x34(%rbp)
je     15a1 <tune_vcocap+0x431>
movl   $0xffffffff,-0x2c(%rbp)
jmp    1592 <tune_vcocap+0x422>
jmp    1597 <tune_vcocap+0x427>
jmp    159c <tune_vcocap+0x42c>
jmp    15a1 <tune_vcocap+0x431>
jmp    15a6 <tune_vcocap+0x436>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tune_vcocap>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    %r8,%r14
mov    %ecx,%r15d
mov    %edx,%r12d
mov    %esi,%ebp
mov    %rdi,%rbx
mov    %esi,(%rsp)
movl   $0x3f,0x4(%rsp)
movl   $0x0,0x8(%rsp)
lea    0xc(%rsp),%rcx
mov    %edx,%esi
mov    $0x32,%edx
call   1040 <get_vtune@plt>
test   %eax,%eax
jne    1361 <tune_vcocap+0x1f1>
mov    0xc(%rsp),%eax
test   %eax,%eax
je     11eb <tune_vcocap+0x7b>
cmp    $0x1,%eax
je     120a <tune_vcocap+0x9a>
cmp    $0x2,%eax
jne    1355 <tune_vcocap+0x1e5>
lea    0x4(%rsp),%r8
mov    %rbx,%rdi
mov    %r12d,%esi
mov    %ebp,%edx
mov    %r15d,%ecx
call   1070 <vtune_high_to_norm@plt>
test   %eax,%eax
jne    1361 <tune_vcocap+0x1f1>
jmp    1227 <tune_vcocap+0xb7>
lea    0x4(%rsp),%r8
mov    %rbx,%rdi
mov    %r12d,%esi
mov    %ebp,%edx
mov    %r15d,%ecx
call   1060 <vtune_norm_to_high@plt>
test   %eax,%eax
jne    1361 <tune_vcocap+0x1f1>
jmp    1227 <tune_vcocap+0xb7>
lea    0x8(%rsp),%r8
mov    %rbx,%rdi
mov    %r12d,%esi
mov    %ebp,%edx
mov    %r15d,%ecx
call   1080 <vtune_low_to_norm@plt>
test   %eax,%eax
jne    1361 <tune_vcocap+0x1f1>
mov    0x4(%rsp),%eax
mov    0xc(%rsp),%ecx
cmp    $0x3f,%eax
jne    129b <tune_vcocap+0x12b>
cmp    $0x1,%ecx
ja     1355 <tune_vcocap+0x1e5>
mov    0x8(%rsp),%eax
lea    -0xc(%rax),%ecx
xor    %edx,%edx
cmp    $0xd,%eax
cmovge %ecx,%edx
mov    %edx,(%rsp)
mov    %rbx,%rdi
mov    %r12d,%esi
mov    %r15d,%ecx
call   1050 <write_vcocap@plt>
test   %eax,%eax
jne    1361 <tune_vcocap+0x1f1>
mov    %rsp,%rcx
mov    %rbx,%rdi
mov    %r12d,%esi
mov    $0x2,%edx
mov    %r15d,%r8d
call   1090 <wait_for_vtune_value@plt>
test   %eax,%eax
jne    1361 <tune_vcocap+0x1f1>
mov    (%rsp),%edx
lea    0x4(%rsp),%r8
mov    %rbx,%rdi
mov    %r12d,%esi
mov    %r15d,%ecx
call   1070 <vtune_high_to_norm@plt>
jmp    12fe <tune_vcocap+0x18e>
test   $0xfffffffd,%ecx
jne    1355 <tune_vcocap+0x1e5>
lea    0xc(%rax),%ecx
cmp    $0x33,%eax
mov    $0x3f,%edx
cmovl  %ecx,%edx
mov    %edx,(%rsp)
mov    %rbx,%rdi
mov    %r12d,%esi
mov    %r15d,%ecx
call   1050 <write_vcocap@plt>
test   %eax,%eax
jne    1361 <tune_vcocap+0x1f1>
mov    %rsp,%rcx
mov    %rbx,%rdi
mov    %r12d,%esi
mov    $0x1,%edx
mov    %r15d,%r8d
call   1090 <wait_for_vtune_value@plt>
test   %eax,%eax
jne    1361 <tune_vcocap+0x1f1>
mov    (%rsp),%edx
lea    0x8(%rsp),%r8
mov    %rbx,%rdi
mov    %r12d,%esi
mov    %r15d,%ecx
call   1080 <vtune_low_to_norm@plt>
test   %eax,%eax
jne    1361 <tune_vcocap+0x1f1>
mov    0x4(%rsp),%eax
mov    0x8(%rsp),%ecx
sub    %eax,%ecx
mov    %ecx,%edx
shr    $0x1f,%edx
add    %ecx,%edx
sar    %edx
add    %eax,%edx
mov    %edx,(%rsp)
mov    %rbx,%rdi
mov    %r12d,%esi
mov    %r15d,%ecx
call   1050 <write_vcocap@plt>
test   %eax,%eax
jne    1361 <tune_vcocap+0x1f1>
mov    (%rsp),%eax
mov    %eax,(%r14)
lea    0xc(%rsp),%rcx
mov    %rbx,%rdi
mov    %r12d,%esi
mov    $0x19,%edx
call   1040 <get_vtune@plt>
test   %eax,%eax
jne    1361 <tune_vcocap+0x1f1>
xor    %eax,%eax
cmp    0xc(%rsp),%eax
sbb    %eax,%eax
jmp    1361 <tune_vcocap+0x1f1>
xor    %edi,%edi
call   1030 <assert@plt>
mov    $0xffffffff,%eax
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
%struct.bladerf = type { i32 }
define i32 @tune_vcocap(%struct.bladerf* %0, i32 %1, i32 %2, i32 %3, i32* nocapture writeonly %4) {
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = bitcast i32* %6 to i8*
store i32 %1, i32* %6
%11 = bitcast i32* %7 to i8*
%12 = bitcast i32* %8 to i8*
%13 = bitcast i32* %9 to i8*
store i32 63, i32* %8
store i32 0, i32* %9
%14 = call i32 @get_vtune(%struct.bladerf* %0, i32 %2, i32 50, i32* %7)
%15 = icmp eq i32 %14, 0
br i1 %15, label %16, label %82
16: ; preds = %5
%17 = load i32, i32* %7
switch i32 %17, label %55 [
i32 2, label %18
i32 0, label %20
i32 1, label %22
]
18: ; preds = %16
%19 = call i32 @vtune_high_to_norm(%struct.bladerf* %0, i32 %2, i32 %1, i32 %3, i32* %8)
br label %24
20: ; preds = %16
%21 = call i32 @vtune_norm_to_high(%struct.bladerf* %0, i32 %2, i32 %1, i32 %3, i32* %8)
br label %24
22: ; preds = %16
%23 = call i32 @vtune_low_to_norm(%struct.bladerf* %0, i32 %2, i32 %1, i32 %3, i32* %9)
br label %24
24: ; preds = %22, %20, %18
%25 = phi i32 [ %23, %22 ], [ %21, %20 ], [ %19, %18 ]
%26 = icmp eq i32 %25, 0
br i1 %26, label %27, label %82
27: ; preds = %24
%28 = load i32, i32* %8
%29 = icmp eq i32 %28, 63
%30 = load i32, i32* %7
br i1 %29, label %46, label %31
31: ; preds = %27
switch i32 %30, label %38 [
i32 2, label %32
i32 0, label %32
]
32: ; preds = %31, %31
%33 = icmp slt i32 %28, 51
%34 = add nsw i32 %28, 12
%35 = select i1 %33, i32 %34, i32 63
store i32 %35, i32* %6
%36 = call i32 @write_vcocap(%struct.bladerf* %0, i32 %2, i32 %35, i32 %3)
%37 = icmp eq i32 %36, 0
br i1 %37, label %40, label %82
38: ; preds = %31
%39 = call i32 @assert(i32 0)
br label %82
40: ; preds = %32
%41 = call i32 @wait_for_vtune_value(%struct.bladerf* %0, i32 %2, i32 1, i32* %6, i32 %3)
%42 = icmp eq i32 %41, 0
br i1 %42, label %43, label %82
43: ; preds = %40
%44 = load i32, i32* %6
%45 = call i32 @vtune_low_to_norm(%struct.bladerf* %0, i32 %2, i32 %44, i32 %3, i32* %9)
br label %63
46: ; preds = %27
%47 = icmp ult i32 %30, 2
br i1 %47, label %48, label %55
48: ; preds = %46
%49 = load i32, i32* %9
%50 = icmp sgt i32 %49, 12
%51 = add nsw i32 %49, -12
%52 = select i1 %50, i32 %51, i32 0
store i32 %52, i32* %6
%53 = call i32 @write_vcocap(%struct.bladerf* %0, i32 %2, i32 %52, i32 %3)
%54 = icmp eq i32 %53, 0
br i1 %54, label %57, label %82
55: ; preds = %16, %46
%56 = call i32 @assert(i32 0)
br label %82
57: ; preds = %48
%58 = call i32 @wait_for_vtune_value(%struct.bladerf* %0, i32 %2, i32 2, i32* %6, i32 %3)
%59 = icmp eq i32 %58, 0
br i1 %59, label %60, label %82
60: ; preds = %57
%61 = load i32, i32* %6
%62 = call i32 @vtune_high_to_norm(%struct.bladerf* %0, i32 %2, i32 %61, i32 %3, i32* %8)
br label %63
63: ; preds = %43, %60
%64 = phi i32 [ %45, %43 ], [ %62, %60 ]
%65 = icmp eq i32 %64, 0
br i1 %65, label %66, label %82
66: ; preds = %63
%67 = load i32, i32* %8
%68 = load i32, i32* %9
%69 = sub nsw i32 %68, %67
%70 = sdiv i32 %69, 2
%71 = add nsw i32 %70, %67
store i32 %71, i32* %6
%72 = call i32 @write_vcocap(%struct.bladerf* %0, i32 %2, i32 %71, i32 %3)
%73 = icmp eq i32 %72, 0
br i1 %73, label %74, label %82
74: ; preds = %66
%75 = load i32, i32* %6
store i32 %75, i32* %4
%76 = call i32 @get_vtune(%struct.bladerf* %0, i32 %2, i32 25, i32* %7)
%77 = icmp eq i32 %76, 0
br i1 %77, label %78, label %82
78: ; preds = %74
%79 = load i32, i32* %7
%80 = icmp ne i32 %79, 0
%81 = sext i1 %80 to i32
br label %82
82: ; preds = %57, %40, %78, %63, %74, %66, %48, %32, %24, %5, %55, %38
%83 = phi i32 [ -1, %38 ], [ -1, %55 ], [ %14, %5 ], [ %25, %24 ], [ %36, %32 ], [ %53, %48 ], [ %72, %66 ], [ %76, %74 ], [ %64, %63 ], [ %81, %78 ], [ %58, %57 ], [ %41, %40 ]
ret i32 %83
}