#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 */
uint32_t inverse_adjust_seed_1(uint32_t seed) {
  return seed ^ (seed << 1) ^ (seed << 2) ^ (seed << 3) ^ (seed << 4) ^
         (seed << 5) ^ (seed << 6) ^ (seed << 7) ^ (seed << 8) ^ (seed << 9) ^
         (seed << 10) ^ (seed << 11) ^ (seed << 12) ^ (seed << 13) ^
         (seed << 14) ^ (seed << 15) ^ (seed << 16) ^ (seed << 17) ^
         (seed << 18) ^ (seed << 19) ^ (seed << 20) ^ (seed << 21) ^
         (seed << 22) ^ (seed << 23) ^ (seed << 24) ^ (seed << 25) ^
         (seed << 26) ^ (seed << 27) ^ (seed << 28) ^ (seed << 29) ^
         (seed << 30) ^ (seed << 31);
}


x86 assembly (clang, -O0):
<inverse_adjust_seed_1>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    -0x4(%rbp),%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x2,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x3,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x4,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x5,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x6,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x7,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x8,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x9,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0xa,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0xb,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0xc,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0xd,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0xe,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0xf,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x10,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x11,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x12,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x13,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x14,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x15,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x16,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x17,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x18,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x19,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x1a,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x1b,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x1c,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x1d,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x1e,%ecx
xor    %ecx,%eax
mov    -0x4(%rbp),%ecx
shl    $0x1f,%ecx
xor    %ecx,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<inverse_adjust_seed_1>:
lea    (%rdi,%rdi,1),%eax
xor    %edi,%eax
lea    0x0(,%rdi,4),%ecx
lea    0x0(,%rdi,8),%edx
xor    %ecx,%edx
xor    %eax,%edx
mov    %edi,%eax
shl    $0x4,%eax
mov    %edi,%ecx
shl    $0x5,%ecx
xor    %eax,%ecx
mov    %edi,%eax
shl    $0x6,%eax
xor    %ecx,%eax
xor    %edx,%eax
mov    %edi,%ecx
shl    $0x7,%ecx
mov    %edi,%edx
shl    $0x8,%edx
xor    %ecx,%edx
mov    %edi,%ecx
shl    $0x9,%ecx
xor    %edx,%ecx
mov    %edi,%edx
shl    $0xa,%edx
xor    %ecx,%edx
xor    %eax,%edx
mov    %edi,%eax
shl    $0xb,%eax
mov    %edi,%ecx
shl    $0xc,%ecx
xor    %eax,%ecx
mov    %edi,%eax
shl    $0xd,%eax
xor    %ecx,%eax
mov    %edi,%ecx
shl    $0xe,%ecx
xor    %eax,%ecx
mov    %edi,%esi
shl    $0xf,%esi
xor    %ecx,%esi
xor    %edx,%esi
mov    %edi,%eax
shl    $0x10,%eax
mov    %edi,%ecx
shl    $0x11,%ecx
xor    %eax,%ecx
mov    %edi,%eax
shl    $0x12,%eax
xor    %ecx,%eax
mov    %edi,%ecx
shl    $0x13,%ecx
xor    %eax,%ecx
mov    %edi,%edx
shl    $0x14,%edx
xor    %ecx,%edx
mov    %edi,%eax
shl    $0x15,%eax
xor    %edx,%eax
xor    %esi,%eax
mov    %edi,%ecx
shl    $0x16,%ecx
mov    %edi,%edx
shl    $0x17,%edx
xor    %ecx,%edx
mov    %edi,%ecx
shl    $0x18,%ecx
xor    %edx,%ecx
mov    %edi,%edx
shl    $0x19,%edx
xor    %ecx,%edx
mov    %edi,%ecx
shl    $0x1a,%ecx
xor    %edx,%ecx
mov    %edi,%edx
shl    $0x1b,%edx
xor    %ecx,%edx
mov    %edi,%ecx
shl    $0x1c,%ecx
xor    %edx,%ecx
xor    %eax,%ecx
mov    %edi,%edx
shl    $0x1d,%edx
mov    %edi,%eax
shl    $0x1e,%eax
xor    %edx,%eax
shl    $0x1f,%edi
xor    %edi,%eax
xor    %ecx,%eax
ret

LLVM IR (-O0):
define i32 @inverse_adjust_seed_1(i32 %0) {
%2 = alloca i32
store i32 %0, i32* %2
%3 = load i32, i32* %2
%4 = load i32, i32* %2
%5 = shl i32 %4, 1
%6 = xor i32 %3, %5
%7 = load i32, i32* %2
%8 = shl i32 %7, 2
%9 = xor i32 %6, %8
%10 = load i32, i32* %2
%11 = shl i32 %10, 3
%12 = xor i32 %9, %11
%13 = load i32, i32* %2
%14 = shl i32 %13, 4
%15 = xor i32 %12, %14
%16 = load i32, i32* %2
%17 = shl i32 %16, 5
%18 = xor i32 %15, %17
%19 = load i32, i32* %2
%20 = shl i32 %19, 6
%21 = xor i32 %18, %20
%22 = load i32, i32* %2
%23 = shl i32 %22, 7
%24 = xor i32 %21, %23
%25 = load i32, i32* %2
%26 = shl i32 %25, 8
%27 = xor i32 %24, %26
%28 = load i32, i32* %2
%29 = shl i32 %28, 9
%30 = xor i32 %27, %29
%31 = load i32, i32* %2
%32 = shl i32 %31, 10
%33 = xor i32 %30, %32
%34 = load i32, i32* %2
%35 = shl i32 %34, 11
%36 = xor i32 %33, %35
%37 = load i32, i32* %2
%38 = shl i32 %37, 12
%39 = xor i32 %36, %38
%40 = load i32, i32* %2
%41 = shl i32 %40, 13
%42 = xor i32 %39, %41
%43 = load i32, i32* %2
%44 = shl i32 %43, 14
%45 = xor i32 %42, %44
%46 = load i32, i32* %2
%47 = shl i32 %46, 15
%48 = xor i32 %45, %47
%49 = load i32, i32* %2
%50 = shl i32 %49, 16
%51 = xor i32 %48, %50
%52 = load i32, i32* %2
%53 = shl i32 %52, 17
%54 = xor i32 %51, %53
%55 = load i32, i32* %2
%56 = shl i32 %55, 18
%57 = xor i32 %54, %56
%58 = load i32, i32* %2
%59 = shl i32 %58, 19
%60 = xor i32 %57, %59
%61 = load i32, i32* %2
%62 = shl i32 %61, 20
%63 = xor i32 %60, %62
%64 = load i32, i32* %2
%65 = shl i32 %64, 21
%66 = xor i32 %63, %65
%67 = load i32, i32* %2
%68 = shl i32 %67, 22
%69 = xor i32 %66, %68
%70 = load i32, i32* %2
%71 = shl i32 %70, 23
%72 = xor i32 %69, %71
%73 = load i32, i32* %2
%74 = shl i32 %73, 24
%75 = xor i32 %72, %74
%76 = load i32, i32* %2
%77 = shl i32 %76, 25
%78 = xor i32 %75, %77
%79 = load i32, i32* %2
%80 = shl i32 %79, 26
%81 = xor i32 %78, %80
%82 = load i32, i32* %2
%83 = shl i32 %82, 27
%84 = xor i32 %81, %83
%85 = load i32, i32* %2
%86 = shl i32 %85, 28
%87 = xor i32 %84, %86
%88 = load i32, i32* %2
%89 = shl i32 %88, 29
%90 = xor i32 %87, %89
%91 = load i32, i32* %2
%92 = shl i32 %91, 30
%93 = xor i32 %90, %92
%94 = load i32, i32* %2
%95 = shl i32 %94, 31
%96 = xor i32 %93, %95
ret i32 %96
}

LLVM IR (-O2):
define i32 @inverse_adjust_seed_1(i32 %0) {
%2 = shl i32 %0, 1
%3 = xor i32 %2, %0
%4 = shl i32 %0, 2
%5 = xor i32 %3, %4
%6 = shl i32 %0, 3
%7 = xor i32 %5, %6
%8 = shl i32 %0, 4
%9 = xor i32 %7, %8
%10 = shl i32 %0, 5
%11 = xor i32 %9, %10
%12 = shl i32 %0, 6
%13 = xor i32 %11, %12
%14 = shl i32 %0, 7
%15 = xor i32 %13, %14
%16 = shl i32 %0, 8
%17 = xor i32 %15, %16
%18 = shl i32 %0, 9
%19 = xor i32 %17, %18
%20 = shl i32 %0, 10
%21 = xor i32 %19, %20
%22 = shl i32 %0, 11
%23 = xor i32 %21, %22
%24 = shl i32 %0, 12
%25 = xor i32 %23, %24
%26 = shl i32 %0, 13
%27 = xor i32 %25, %26
%28 = shl i32 %0, 14
%29 = xor i32 %27, %28
%30 = shl i32 %0, 15
%31 = xor i32 %29, %30
%32 = shl i32 %0, 16
%33 = xor i32 %31, %32
%34 = shl i32 %0, 17
%35 = xor i32 %33, %34
%36 = shl i32 %0, 18
%37 = xor i32 %35, %36
%38 = shl i32 %0, 19
%39 = xor i32 %37, %38
%40 = shl i32 %0, 20
%41 = xor i32 %39, %40
%42 = shl i32 %0, 21
%43 = xor i32 %41, %42
%44 = shl i32 %0, 22
%45 = xor i32 %43, %44
%46 = shl i32 %0, 23
%47 = xor i32 %45, %46
%48 = shl i32 %0, 24
%49 = xor i32 %47, %48
%50 = shl i32 %0, 25
%51 = xor i32 %49, %50
%52 = shl i32 %0, 26
%53 = xor i32 %51, %52
%54 = shl i32 %0, 27
%55 = xor i32 %53, %54
%56 = shl i32 %0, 28
%57 = xor i32 %55, %56
%58 = shl i32 %0, 29
%59 = xor i32 %57, %58
%60 = shl i32 %0, 30
%61 = xor i32 %59, %60
%62 = shl i32 %0, 31
%63 = xor i32 %61, %62
ret i32 %63
}