#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));
  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,-0x20(%rbp)
mov    -0x10(%rbp),%eax
and    $0xf,%eax
mov    -0xc(%rbp),%ecx
shl    %cl,%eax
mov    -0x20(%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,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
and    $0xf00,%eax
sar    $0x8,%eax
mov    -0xc(%rbp),%ecx
shl    %cl,%eax
mov    -0x1c(%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,-0x18(%rbp)
mov    -0x10(%rbp),%eax
and    $0xf0,%eax
sar    $0x4,%eax
mov    -0xc(%rbp),%ecx
shl    %cl,%eax
mov    -0x18(%rbp),%ecx
or     %eax,%ecx
mov    -0x4(%rbp),%eax
add    $0x4,%eax
cltq
mov    %ecx,(%rax)
mov    -0x10(%rbp),%eax
and    $0xf0000,%eax
cmp    $0x0,%eax
je     124b <ADCSequenceStepConfigure+0x14b>
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    1266 <ADCSequenceStepConfigure+0x166>
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,%r8d
mov    %edx,%ecx
shl    $0x5,%esi
lea    (%rdi,%rsi,1),%edx
add    $0x40,%edx
shl    $0x2,%ecx
movslq %edx,%rdx
mov    $0xf,%esi
shl    %cl,%esi
not    %esi
mov    (%rdx),%edi
and    %esi,%edi
mov    %r8d,%eax
and    $0xf,%eax
shl    %cl,%eax
or     %edi,%eax
mov    %eax,(%rdx)
mov    0x18(%rdx),%eax
and    %esi,%eax
mov    %r8d,%edi
shr    $0x8,%edi
and    $0xf,%edi
shl    %cl,%edi
or     %eax,%edi
mov    %edi,0x18(%rdx)
mov    0x4(%rdx),%eax
mov    %r8d,%edi
shr    $0x4,%edi
and    $0xf,%edi
shl    %cl,%edi
and    %esi,%eax
or     %eax,%edi
mov    %edi,0x4(%rdx)
test   $0xf0000,%r8d
je     1180 <ADCSequenceStepConfigure+0x80>
and    0x14(%rdx),%esi
shr    $0x10,%r8d
and    $0x7,%r8d
shl    %cl,%r8d
or     %esi,%r8d
mov    $0x1,%eax
shl    %cl,%eax
mov    %r8d,0x14(%rdx)
or     %eax,0x10(%rdx)
ret
mov    $0xfffffffe,%eax
rol    %cl,%eax
and    %eax,0x10(%rdx)
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* %8
%74 = and i32 %73, 983040
%75 = icmp ne i32 %74, 0
br i1 %75, label %76, label %107
76: ; preds = %4
%77 = load i32, i32* %5
%78 = add nsw i32 %77, 20
%79 = sext i32 %78 to i64
%80 = inttoptr i64 %79 to i32*
%81 = load volatile i32, i32* %80
store i32 %81, i32* %9
%82 = load i32, i32* %7
%83 = shl i32 15, %82
%84 = xor i32 %83, -1
%85 = load i32, i32* %9
%86 = and i32 %85, %84
store i32 %86, i32* %9
%87 = load i32, i32* %8
%88 = and i32 %87, 458752
%89 = ashr i32 %88, 16
%90 = load i32, i32* %7
%91 = shl i32 %89, %90
%92 = load i32, i32* %9
%93 = or i32 %92, %91
store i32 %93, i32* %9
%94 = load i32, i32* %9
%95 = load i32, i32* %5
%96 = add nsw i32 %95, 20
%97 = sext i32 %96 to i64
%98 = inttoptr i64 %97 to i32*
store volatile i32 %94, i32* %98
%99 = load i32, i32* %7
%100 = shl i32 1, %99
%101 = load i32, i32* %5
%102 = add nsw i32 %101, 16
%103 = sext i32 %102 to i64
%104 = inttoptr i64 %103 to i32*
%105 = load volatile i32, i32* %104
%106 = or i32 %105, %100
store volatile i32 %106, i32* %104
br label %117
107: ; preds = %4
%108 = load i32, i32* %7
%109 = shl i32 1, %108
%110 = xor i32 %109, -1
%111 = load i32, i32* %5
%112 = add nsw i32 %111, 16
%113 = sext i32 %112 to i64
%114 = inttoptr i64 %113 to i32*
%115 = load volatile i32, i32* %114
%116 = and i32 %115, %110
store volatile i32 %116, i32* %114
br label %117
117: ; preds = %107, %76
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 = and i32 %3, 983040
%37 = icmp eq i32 %36, 0
br i1 %37, label %54, label %38
38: ; preds = %4
%39 = add nsw i32 %7, 20
%40 = sext i32 %39 to i64
%41 = inttoptr i64 %40 to i32*
%42 = load volatile i32, i32* %41
%43 = and i32 %42, %13
%44 = lshr i32 %3, 16
%45 = and i32 %44, 7
%46 = shl i32 %45, %8
%47 = or i32 %43, %46
store volatile i32 %47, i32* %41
%48 = shl nuw i32 1, %8
%49 = add nsw i32 %7, 16
%50 = sext i32 %49 to i64
%51 = inttoptr i64 %50 to i32*
%52 = load volatile i32, i32* %51
%53 = or i32 %52, %48
store volatile i32 %53, i32* %51
br label %62
54: ; preds = %4
%55 = shl nuw i32 1, %8
%56 = xor i32 %55, -1
%57 = add nsw i32 %7, 16
%58 = sext i32 %57 to i64
%59 = inttoptr i64 %58 to i32*
%60 = load volatile i32, i32* %59
%61 = and i32 %60, %56
store volatile i32 %61, i32* %59
br label %62
62: ; preds = %54, %38
ret void
}