#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 uint32_t;

/* Variables and functions */
void ADCSequenceStepConfigure(uint32_t ui32Base, uint32_t ui32SequenceNum,
                              uint32_t ui32Step, uint32_t ui32Config) {
  uint32_t ui32Temp;
  ;
  ;

  ;
  ui32Base += (0x00000040) + ((0x00000060 - 0x00000040) * ui32SequenceNum);
  ui32Step *= 4;
  (*((volatile uint32_t *)(ui32Base + (0x00000040 - 0x00000040)))) =
      (((*((volatile uint32_t *)(ui32Base + (0x00000040 - 0x00000040)))) &
        ~(0x0000000f << ui32Step)) |
       ((ui32Config & 0x0f) << ui32Step));
  (*((volatile uint32_t *)(ui32Base + (0x00000058 - 0x00000040)))) =
      (((*((volatile uint32_t *)(ui32Base + (0x00000058 - 0x00000040)))) &
        ~(0x0000000f << ui32Step)) |
       (((ui32Config & 0xf00) >> 8) << ui32Step));
  (*((volatile uint32_t *)(ui32Base + (0x00000044 - 0x00000040)))) =
      (((*((volatile uint32_t *)(ui32Base + (0x00000044 - 0x00000040)))) &
        ~(0x0000000f << ui32Step)) |
       (((ui32Config & 0xf0) >> 4) << ui32Step));
  (*((volatile uint32_t *)(ui32Base + (0x0000005C - 0x00000040)))) =
      (((*((volatile uint32_t *)(ui32Base + (0x0000005C - 0x00000040)))) &
        ~(0x0000000f << ui32Step)) |
       (((ui32Config & 0xf00000) >> 20) << ui32Step));
  if (ui32Config & 0x000F0000) {
    ui32Temp = (*((volatile uint32_t *)(ui32Base + (0x00000054 - 0x00000040))));
    ui32Temp &= ~(0xF << ui32Step);
    ui32Temp |= (((ui32Config & 0x00070000) >> 16) << ui32Step);
    (*((volatile uint32_t *)(ui32Base + (0x00000054 - 0x00000040)))) = ui32Temp;
    (*((volatile uint32_t *)(ui32Base + (0x00000050 - 0x00000040)))) |=
        (1 << ui32Step);
  } else {
    (*((volatile uint32_t *)(ui32Base + (0x00000050 - 0x00000040)))) &=
        ~(1 << ui32Step);
  }
}


x86 assembly (clang, -O0):
<ADCSequenceStepConfigure>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    -0x8(%rbp),%eax
shl    $0x5,%eax
add    $0x40,%eax
add    -0x4(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0xc(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0xc(%rbp)
mov    -0x4(%rbp),%eax
add    $0x0,%eax
cltq
mov    (%rax),%eax
mov    -0xc(%rbp),%ecx
mov    $0xf,%edx
shl    %cl,%edx
mov    %edx,%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%eax
and    $0xf,%eax
mov    -0xc(%rbp),%ecx
shl    %cl,%eax
mov    -0x24(%rbp),%ecx
or     %eax,%ecx
mov    -0x4(%rbp),%eax
add    $0x0,%eax
cltq
mov    %ecx,(%rax)
mov    -0x4(%rbp),%eax
add    $0x18,%eax
cltq
mov    (%rax),%eax
mov    -0xc(%rbp),%ecx
mov    $0xf,%edx
shl    %cl,%edx
mov    %edx,%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%eax
and    $0xf00,%eax
sar    $0x8,%eax
mov    -0xc(%rbp),%ecx
shl    %cl,%eax
mov    -0x20(%rbp),%ecx
or     %eax,%ecx
mov    -0x4(%rbp),%eax
add    $0x18,%eax
cltq
mov    %ecx,(%rax)
mov    -0x4(%rbp),%eax
add    $0x4,%eax
cltq
mov    (%rax),%eax
mov    -0xc(%rbp),%ecx
mov    $0xf,%edx
shl    %cl,%edx
mov    %edx,%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
and    $0xf0,%eax
sar    $0x4,%eax
mov    -0xc(%rbp),%ecx
shl    %cl,%eax
mov    -0x1c(%rbp),%ecx
or     %eax,%ecx
mov    -0x4(%rbp),%eax
add    $0x4,%eax
cltq
mov    %ecx,(%rax)
mov    -0x4(%rbp),%eax
add    $0x1c,%eax
cltq
mov    (%rax),%eax
mov    -0xc(%rbp),%ecx
mov    $0xf,%edx
shl    %cl,%edx
mov    %edx,%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%eax
and    $0xf00000,%eax
sar    $0x14,%eax
mov    -0xc(%rbp),%ecx
shl    %cl,%eax
mov    -0x18(%rbp),%ecx
or     %eax,%ecx
mov    -0x4(%rbp),%eax
add    $0x1c,%eax
cltq
mov    %ecx,(%rax)
mov    -0x10(%rbp),%eax
and    $0xf0000,%eax
cmp    $0x0,%eax
je     1288 <ADCSequenceStepConfigure+0x188>
mov    -0x4(%rbp),%eax
add    $0x14,%eax
cltq
mov    (%rax),%eax
mov    %eax,-0x14(%rbp)
mov    -0xc(%rbp),%ecx
mov    $0xf,%eax
shl    %cl,%eax
xor    $0xffffffff,%eax
and    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%eax
and    $0x70000,%eax
sar    $0x10,%eax
mov    -0xc(%rbp),%ecx
shl    %cl,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x4(%rbp),%eax
add    $0x14,%eax
cltq
mov    %ecx,(%rax)
mov    -0xc(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    -0x4(%rbp),%eax
add    $0x10,%eax
cltq
mov    (%rax),%ecx
or     %edx,%ecx
mov    %ecx,(%rax)
jmp    12a3 <ADCSequenceStepConfigure+0x1a3>
mov    -0xc(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
xor    $0xffffffff,%edx
mov    -0x4(%rbp),%eax
add    $0x10,%eax
cltq
mov    (%rax),%ecx
and    %edx,%ecx
mov    %ecx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<ADCSequenceStepConfigure>:
mov    %ecx,%eax
mov    %edx,%ecx
shl    $0x5,%esi
lea    (%rdi,%rsi,1),%edx
add    $0x40,%edx
shl    $0x2,%ecx
movslq %edx,%r8
mov    $0xf,%esi
shl    %cl,%esi
not    %esi
mov    %eax,%edi
and    $0xf,%edi
shl    %cl,%edi
mov    (%r8),%edx
and    %esi,%edx
or     %edx,%edi
mov    %edi,(%r8)
mov    0x18(%r8),%edx
and    %esi,%edx
mov    %eax,%edi
shr    $0x8,%edi
and    $0xf,%edi
shl    %cl,%edi
or     %edx,%edi
mov    %edi,0x18(%r8)
mov    0x4(%r8),%edx
and    %esi,%edx
mov    %eax,%edi
shr    $0x4,%edi
and    $0xf,%edi
shl    %cl,%edi
or     %edx,%edi
mov    %edi,0x4(%r8)
mov    0x1c(%r8),%edx
mov    %eax,%edi
shr    $0x14,%edi
and    $0xf,%edi
shl    %cl,%edi
and    %esi,%edx
or     %edx,%edi
mov    %edi,0x1c(%r8)
test   $0xf0000,%eax
je     1194 <ADCSequenceStepConfigure+0x94>
and    0x14(%r8),%esi
shr    $0x10,%eax
and    $0x7,%eax
shl    %cl,%eax
or     %esi,%eax
mov    $0x1,%edx
shl    %cl,%edx
mov    %eax,0x14(%r8)
or     %edx,0x10(%r8)
ret
mov    $0xfffffffe,%eax
rol    %cl,%eax
and    %eax,0x10(%r8)
ret

LLVM IR (-O0):
define void @ADCSequenceStepConfigure(i32 %0, i32 %1, i32 %2, i32 %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
store i32 %0, i32* %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%10 = load i32, i32* %6
%11 = mul nsw i32 32, %10
%12 = add nsw i32 64, %11
%13 = load i32, i32* %5
%14 = add nsw i32 %13, %12
store i32 %14, i32* %5
%15 = load i32, i32* %7
%16 = mul nsw i32 %15, 4
store i32 %16, i32* %7
%17 = load i32, i32* %5
%18 = add nsw i32 %17, 0
%19 = sext i32 %18 to i64
%20 = inttoptr i64 %19 to i32*
%21 = load volatile i32, i32* %20
%22 = load i32, i32* %7
%23 = shl i32 15, %22
%24 = xor i32 %23, -1
%25 = and i32 %21, %24
%26 = load i32, i32* %8
%27 = and i32 %26, 15
%28 = load i32, i32* %7
%29 = shl i32 %27, %28
%30 = or i32 %25, %29
%31 = load i32, i32* %5
%32 = add nsw i32 %31, 0
%33 = sext i32 %32 to i64
%34 = inttoptr i64 %33 to i32*
store volatile i32 %30, i32* %34
%35 = load i32, i32* %5
%36 = add nsw i32 %35, 24
%37 = sext i32 %36 to i64
%38 = inttoptr i64 %37 to i32*
%39 = load volatile i32, i32* %38
%40 = load i32, i32* %7
%41 = shl i32 15, %40
%42 = xor i32 %41, -1
%43 = and i32 %39, %42
%44 = load i32, i32* %8
%45 = and i32 %44, 3840
%46 = ashr i32 %45, 8
%47 = load i32, i32* %7
%48 = shl i32 %46, %47
%49 = or i32 %43, %48
%50 = load i32, i32* %5
%51 = add nsw i32 %50, 24
%52 = sext i32 %51 to i64
%53 = inttoptr i64 %52 to i32*
store volatile i32 %49, i32* %53
%54 = load i32, i32* %5
%55 = add nsw i32 %54, 4
%56 = sext i32 %55 to i64
%57 = inttoptr i64 %56 to i32*
%58 = load volatile i32, i32* %57
%59 = load i32, i32* %7
%60 = shl i32 15, %59
%61 = xor i32 %60, -1
%62 = and i32 %58, %61
%63 = load i32, i32* %8
%64 = and i32 %63, 240
%65 = ashr i32 %64, 4
%66 = load i32, i32* %7
%67 = shl i32 %65, %66
%68 = or i32 %62, %67
%69 = load i32, i32* %5
%70 = add nsw i32 %69, 4
%71 = sext i32 %70 to i64
%72 = inttoptr i64 %71 to i32*
store volatile i32 %68, i32* %72
%73 = load i32, i32* %5
%74 = add nsw i32 %73, 28
%75 = sext i32 %74 to i64
%76 = inttoptr i64 %75 to i32*
%77 = load volatile i32, i32* %76
%78 = load i32, i32* %7
%79 = shl i32 15, %78
%80 = xor i32 %79, -1
%81 = and i32 %77, %80
%82 = load i32, i32* %8
%83 = and i32 %82, 15728640
%84 = ashr i32 %83, 20
%85 = load i32, i32* %7
%86 = shl i32 %84, %85
%87 = or i32 %81, %86
%88 = load i32, i32* %5
%89 = add nsw i32 %88, 28
%90 = sext i32 %89 to i64
%91 = inttoptr i64 %90 to i32*
store volatile i32 %87, i32* %91
%92 = load i32, i32* %8
%93 = and i32 %92, 983040
%94 = icmp ne i32 %93, 0
br i1 %94, label %95, label %126
95: ; preds = %4
%96 = load i32, i32* %5
%97 = add nsw i32 %96, 20
%98 = sext i32 %97 to i64
%99 = inttoptr i64 %98 to i32*
%100 = load volatile i32, i32* %99
store i32 %100, i32* %9
%101 = load i32, i32* %7
%102 = shl i32 15, %101
%103 = xor i32 %102, -1
%104 = load i32, i32* %9
%105 = and i32 %104, %103
store i32 %105, i32* %9
%106 = load i32, i32* %8
%107 = and i32 %106, 458752
%108 = ashr i32 %107, 16
%109 = load i32, i32* %7
%110 = shl i32 %108, %109
%111 = load i32, i32* %9
%112 = or i32 %111, %110
store i32 %112, i32* %9
%113 = load i32, i32* %9
%114 = load i32, i32* %5
%115 = add nsw i32 %114, 20
%116 = sext i32 %115 to i64
%117 = inttoptr i64 %116 to i32*
store volatile i32 %113, i32* %117
%118 = load i32, i32* %7
%119 = shl i32 1, %118
%120 = load i32, i32* %5
%121 = add nsw i32 %120, 16
%122 = sext i32 %121 to i64
%123 = inttoptr i64 %122 to i32*
%124 = load volatile i32, i32* %123
%125 = or i32 %124, %119
store volatile i32 %125, i32* %123
br label %136
126: ; preds = %4
%127 = load i32, i32* %7
%128 = shl i32 1, %127
%129 = xor i32 %128, -1
%130 = load i32, i32* %5
%131 = add nsw i32 %130, 16
%132 = sext i32 %131 to i64
%133 = inttoptr i64 %132 to i32*
%134 = load volatile i32, i32* %133
%135 = and i32 %134, %129
store volatile i32 %135, i32* %133
br label %136
136: ; preds = %126, %95
ret void
}

LLVM IR (-O2):
define void @ADCSequenceStepConfigure(i32 %0, i32 %1, i32 %2, i32 %3) {
%5 = shl nsw i32 %1, 5
%6 = add i32 %0, 64
%7 = add i32 %6, %5
%8 = shl nsw i32 %2, 2
%9 = sext i32 %7 to i64
%10 = inttoptr i64 %9 to i32*
%11 = load volatile i32, i32* %10
%12 = shl i32 15, %8
%13 = xor i32 %12, -1
%14 = and i32 %11, %13
%15 = and i32 %3, 15
%16 = shl i32 %15, %8
%17 = or i32 %14, %16
store volatile i32 %17, i32* %10
%18 = add nsw i32 %7, 24
%19 = sext i32 %18 to i64
%20 = inttoptr i64 %19 to i32*
%21 = load volatile i32, i32* %20
%22 = and i32 %21, %13
%23 = lshr i32 %3, 8
%24 = and i32 %23, 15
%25 = shl i32 %24, %8
%26 = or i32 %22, %25
store volatile i32 %26, i32* %20
%27 = add nsw i32 %7, 4
%28 = sext i32 %27 to i64
%29 = inttoptr i64 %28 to i32*
%30 = load volatile i32, i32* %29
%31 = and i32 %30, %13
%32 = lshr i32 %3, 4
%33 = and i32 %32, 15
%34 = shl i32 %33, %8
%35 = or i32 %31, %34
store volatile i32 %35, i32* %29
%36 = add nsw i32 %7, 28
%37 = sext i32 %36 to i64
%38 = inttoptr i64 %37 to i32*
%39 = load volatile i32, i32* %38
%40 = and i32 %39, %13
%41 = lshr i32 %3, 20
%42 = and i32 %41, 15
%43 = shl i32 %42, %8
%44 = or i32 %40, %43
store volatile i32 %44, i32* %38
%45 = and i32 %3, 983040
%46 = icmp eq i32 %45, 0
br i1 %46, label %63, label %47
47: ; preds = %4
%48 = add nsw i32 %7, 20
%49 = sext i32 %48 to i64
%50 = inttoptr i64 %49 to i32*
%51 = load volatile i32, i32* %50
%52 = and i32 %51, %13
%53 = lshr i32 %3, 16
%54 = and i32 %53, 7
%55 = shl i32 %54, %8
%56 = or i32 %52, %55
store volatile i32 %56, i32* %50
%57 = shl nuw i32 1, %8
%58 = add nsw i32 %7, 16
%59 = sext i32 %58 to i64
%60 = inttoptr i64 %59 to i32*
%61 = load volatile i32, i32* %60
%62 = or i32 %61, %57
store volatile i32 %62, i32* %60
br label %71
63: ; preds = %4
%64 = shl nuw i32 1, %8
%65 = xor i32 %64, -1
%66 = add nsw i32 %7, 16
%67 = sext i32 %66 to i64
%68 = inttoptr i64 %67 to i32*
%69 = load volatile i32, i32* %68
%70 = and i32 %69, %65
store volatile i32 %70, i32* %68
br label %71
71: ; preds = %63, %47
ret void
}