#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 unsigned long long uint8_t;
typedef int /*<<< orphan*/ uint64_t;

/* Variables and functions */
int /*<<< orphan*/ ext_shift(int /*<<< orphan*/, unsigned long long,
                             int /*<<< orphan*/ *);
int /*<<< orphan*/ printf(char *);
void shift_and_mark(uint64_t *source, uint64_t *target,
                    unsigned long long length, unsigned long long shift,
                    unsigned long long segoffset) {
  uint8_t bitoff = shift % (sizeof(uint64_t) * 8);
  unsigned long long offset = shift / (sizeof(uint64_t) * 8);
  uint64_t shifted[2];
  unsigned long long i;
  long long off_the_end;
  off_the_end = length + segoffset - offset - 1;
  if (off_the_end < 0)
    printf("Failure!!!!!\n");
  long long stop =
      (((length - 1) < (off_the_end)) ? (length - 1) : (off_the_end));
  const unsigned long long access_offset = offset - segoffset;
  const long long start_offset =
      (((0) > ((long long)segoffset - (long long)offset))
           ? (0)
           : ((long long)segoffset - (long long)offset));
  if (start_offset > 0) {
    i = start_offset - 1;
    ext_shift(source[i], bitoff, shifted);
    target[i + 1 + access_offset] |= shifted[1];
  }
  for (i = start_offset; i < stop; i++) {
    ext_shift(source[i], bitoff, shifted);
    target[i + access_offset] |= shifted[0];
    target[i + 1 + access_offset] |= shifted[1];
  }
  if (i + access_offset > 0) {
    i = stop;
    ext_shift(source[i], bitoff, shifted);
    target[i + access_offset] |= shifted[0];
  }
  return;
}


x86 assembly (clang, -O0):
<shift_and_mark>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x20(%rbp),%rax
and    $0x1f,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x5,%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
add    -0x28(%rbp),%rax
sub    -0x38(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x50(%rbp)
cmpq   $0x0,-0x50(%rbp)
jge    1182 <shift_and_mark+0x62>
lea    0xe83(%rip),%rdi
call   1030 <printf@plt>
mov    -0x18(%rbp),%rax
sub    $0x1,%rax
cmp    -0x50(%rbp),%rax
jae    11a5 <shift_and_mark+0x85>
mov    -0x18(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    11ad <shift_and_mark+0x8d>
mov    -0x50(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%rax
sub    -0x28(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x28(%rbp),%rcx
sub    -0x38(%rbp),%rcx
xor    %eax,%eax
cmp    %rcx,%rax
jle    11df <shift_and_mark+0xbf>
xor    %eax,%eax
mov    %rax,-0x78(%rbp)
jmp    11eb <shift_and_mark+0xcb>
mov    -0x28(%rbp),%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x68(%rbp)
cmpq   $0x0,-0x68(%rbp)
jle    123b <shift_and_mark+0x11b>
mov    -0x68(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x30(%rbp),%rsi
lea    -0x40(%rbp),%rdx
call   1040 <ext_shift@plt>
mov    -0x3c(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
add    $0x1,%rcx
add    -0x60(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x58(%rbp),%rax
jae    12a8 <shift_and_mark+0x188>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x30(%rbp),%rsi
lea    -0x40(%rbp),%rdx
call   1040 <ext_shift@plt>
mov    -0x40(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
add    -0x60(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
add    $0x1,%rcx
add    -0x60(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1243 <shift_and_mark+0x123>
mov    -0x48(%rbp),%rax
add    -0x60(%rbp),%rax
cmp    $0x0,%rax
jbe    12ef <shift_and_mark+0x1cf>
mov    -0x58(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x30(%rbp),%rsi
lea    -0x40(%rbp),%rdx
call   1040 <ext_shift@plt>
mov    -0x40(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
add    -0x60(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<shift_and_mark>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r8,%r13
mov    %rcx,%rbp
mov    %rdx,%r14
mov    %rsi,0x8(%rsp)
mov    %rdi,%r12
mov    %ebp,%r15d
and    $0x1f,%r15d
shr    $0x5,%rbp
lea    (%r8,%rdx,1),%rax
mov    %rbp,%rbx
not    %rbx
add    %rax,%rbx
jns    1165 <shift_and_mark+0x45>
lea    0xea0(%rip),%rdi
call   1030 <puts@plt>
add    $0xffffffffffffffff,%r14
cmp    %rbx,%r14
cmovae %rbx,%r14
mov    %rbp,%rax
sub    %r13,%rax
sub    %rbp,%r13
mov    %rax,%rbp
xor    %ebx,%ebx
test   %r13,%r13
cmovns %r13,%rbx
jle    11a7 <shift_and_mark+0x87>
mov    -0x4(%r12,%rbx,4),%edi
mov    %rsp,%rdx
mov    %r15,%rsi
call   1040 <ext_shift@plt>
mov    0x4(%rsp),%eax
lea    (%rbx,%rbp,1),%rcx
mov    0x8(%rsp),%rdx
or     %eax,(%rdx,%rcx,4)
cmp    %r14,%rbx
jae    11ef <shift_and_mark+0xcf>
mov    0x8(%rsp),%rax
mov    %rbp,0x10(%rsp)
lea    (%rax,%rbp,4),%rbp
mov    %rsp,%r13
nopl   (%rax)
mov    (%r12,%rbx,4),%edi
mov    %r15,%rsi
mov    %r13,%rdx
call   1040 <ext_shift@plt>
mov    (%rsp),%eax
or     %eax,0x0(%rbp,%rbx,4)
mov    0x4(%rsp),%eax
or     %eax,0x4(%rbp,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    11c0 <shift_and_mark+0xa0>
mov    %r14,%rbx
mov    0x10(%rsp),%rbp
add    %rbp,%rbx
je     1211 <shift_and_mark+0xf1>
mov    (%r12,%r14,4),%edi
mov    %rsp,%rdx
mov    %r15,%rsi
call   1040 <ext_shift@plt>
mov    (%rsp),%eax
add    %r14,%rbp
mov    0x8(%rsp),%rcx
or     %eax,(%rcx,%rbp,4)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [14 x i8] c"Failure!!!!!\0A\00"
define void @shift_and_mark(i32* %0, i32* %1, i64 %2, i64 %3, i64 %4) {
%6 = alloca i32*
%7 = alloca i32*
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca i64
%13 = alloca [2 x i32]
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
store i32* %0, i32** %6
store i32* %1, i32** %7
store i64 %2, i64* %8
store i64 %3, i64* %9
store i64 %4, i64* %10
%19 = load i64, i64* %9
%20 = urem i64 %19, 32
store i64 %20, i64* %11
%21 = load i64, i64* %9
%22 = udiv i64 %21, 32
store i64 %22, i64* %12
%23 = load i64, i64* %8
%24 = load i64, i64* %10
%25 = add i64 %23, %24
%26 = load i64, i64* %12
%27 = sub i64 %25, %26
%28 = sub i64 %27, 1
store i64 %28, i64* %15
%29 = load i64, i64* %15
%30 = icmp slt i64 %29, 0
br i1 %30, label %31, label %33
31: ; preds = %5
%32 = call i32 @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0))
br label %33
33: ; preds = %31, %5
%34 = load i64, i64* %8
%35 = sub i64 %34, 1
%36 = load i64, i64* %15
%37 = icmp ult i64 %35, %36
br i1 %37, label %38, label %41
38: ; preds = %33
%39 = load i64, i64* %8
%40 = sub i64 %39, 1
br label %43
41: ; preds = %33
%42 = load i64, i64* %15
br label %43
43: ; preds = %41, %38
%44 = phi i64 [ %40, %38 ], [ %42, %41 ]
store i64 %44, i64* %16
%45 = load i64, i64* %12
%46 = load i64, i64* %10
%47 = sub i64 %45, %46
store i64 %47, i64* %17
%48 = load i64, i64* %10
%49 = load i64, i64* %12
%50 = sub nsw i64 %48, %49
%51 = icmp sgt i64 0, %50
br i1 %51, label %52, label %53
52: ; preds = %43
br label %57
53: ; preds = %43
%54 = load i64, i64* %10
%55 = load i64, i64* %12
%56 = sub nsw i64 %54, %55
br label %57
57: ; preds = %53, %52
%58 = phi i64 [ 0, %52 ], [ %56, %53 ]
store i64 %58, i64* %18
%59 = load i64, i64* %18
%60 = icmp sgt i64 %59, 0
br i1 %60, label %61, label %81
61: ; preds = %57
%62 = load i64, i64* %18
%63 = sub nsw i64 %62, 1
store i64 %63, i64* %14
%64 = load i32*, i32** %6
%65 = load i64, i64* %14
%66 = getelementptr inbounds i32, i32* %64, i64 %65
%67 = load i32, i32* %66
%68 = load i64, i64* %11
%69 = getelementptr inbounds [2 x i32], [2 x i32]* %13, i64 0, i64 0
%70 = call i32 @ext_shift(i32 %67, i64 %68, i32* %69)
%71 = getelementptr inbounds [2 x i32], [2 x i32]* %13, i64 0, i64 1
%72 = load i32, i32* %71
%73 = load i32*, i32** %7
%74 = load i64, i64* %14
%75 = add i64 %74, 1
%76 = load i64, i64* %17
%77 = add i64 %75, %76
%78 = getelementptr inbounds i32, i32* %73, i64 %77
%79 = load i32, i32* %78
%80 = or i32 %79, %72
store i32 %80, i32* %78
br label %81
81: ; preds = %61, %57
%82 = load i64, i64* %18
store i64 %82, i64* %14
br label %83
83: ; preds = %114, %81
%84 = load i64, i64* %14
%85 = load i64, i64* %16
%86 = icmp ult i64 %84, %85
br i1 %86, label %87, label %117
87: ; preds = %83
%88 = load i32*, i32** %6
%89 = load i64, i64* %14
%90 = getelementptr inbounds i32, i32* %88, i64 %89
%91 = load i32, i32* %90
%92 = load i64, i64* %11
%93 = getelementptr inbounds [2 x i32], [2 x i32]* %13, i64 0, i64 0
%94 = call i32 @ext_shift(i32 %91, i64 %92, i32* %93)
%95 = getelementptr inbounds [2 x i32], [2 x i32]* %13, i64 0, i64 0
%96 = load i32, i32* %95
%97 = load i32*, i32** %7
%98 = load i64, i64* %14
%99 = load i64, i64* %17
%100 = add i64 %98, %99
%101 = getelementptr inbounds i32, i32* %97, i64 %100
%102 = load i32, i32* %101
%103 = or i32 %102, %96
store i32 %103, i32* %101
%104 = getelementptr inbounds [2 x i32], [2 x i32]* %13, i64 0, i64 1
%105 = load i32, i32* %104
%106 = load i32*, i32** %7
%107 = load i64, i64* %14
%108 = add i64 %107, 1
%109 = load i64, i64* %17
%110 = add i64 %108, %109
%111 = getelementptr inbounds i32, i32* %106, i64 %110
%112 = load i32, i32* %111
%113 = or i32 %112, %105
store i32 %113, i32* %111
br label %114
114: ; preds = %87
%115 = load i64, i64* %14
%116 = add i64 %115, 1
store i64 %116, i64* %14
br label %83
117: ; preds = %83
%118 = load i64, i64* %14
%119 = load i64, i64* %17
%120 = add i64 %118, %119
%121 = icmp ugt i64 %120, 0
br i1 %121, label %122, label %140
122: ; preds = %117
%123 = load i64, i64* %16
store i64 %123, i64* %14
%124 = load i32*, i32** %6
%125 = load i64, i64* %14
%126 = getelementptr inbounds i32, i32* %124, i64 %125
%127 = load i32, i32* %126
%128 = load i64, i64* %11
%129 = getelementptr inbounds [2 x i32], [2 x i32]* %13, i64 0, i64 0
%130 = call i32 @ext_shift(i32 %127, i64 %128, i32* %129)
%131 = getelementptr inbounds [2 x i32], [2 x i32]* %13, i64 0, i64 0
%132 = load i32, i32* %131
%133 = load i32*, i32** %7
%134 = load i64, i64* %14
%135 = load i64, i64* %17
%136 = add i64 %134, %135
%137 = getelementptr inbounds i32, i32* %133, i64 %136
%138 = load i32, i32* %137
%139 = or i32 %138, %132
store i32 %139, i32* %137
br label %140
140: ; preds = %122, %117
ret void
}

LLVM IR (-O2):
@str = [13 x i8] c"Failure!!!!!\00"
define void @shift_and_mark(i32* nocapture %0, i32* nocapture %1, i64 %2, i64 %3, i64 %4) {
%6 = alloca [2 x i32]
%7 = and i64 %3, 31
%8 = lshr i64 %3, 5
%9 = bitcast [2 x i32]* %6 to i8*
%10 = add i64 %4, %2
%11 = xor i64 %8, -1
%12 = add i64 %10, %11
%13 = icmp slt i64 %12, 0
br i1 %13, label %14, label %16
14: ; preds = %5
%15 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @str, i64 0, i64 0))
br label %16
16: ; preds = %14, %5
%17 = add i64 %2, -1
%18 = icmp ult i64 %17, %12
%19 = select i1 %18, i64 %17, i64 %12
%20 = sub i64 %8, %4
%21 = sub nsw i64 %4, %8
%22 = icmp sgt i64 %21, 0
%23 = select i1 %22, i64 %21, i64 0
br i1 %22, label %24, label %36
24: ; preds = %16
%25 = add nsw i64 %23, -1
%26 = getelementptr inbounds i32, i32* %0, i64 %25
%27 = load i32, i32* %26
%28 = getelementptr inbounds [2 x i32], [2 x i32]* %6, i64 0, i64 0
%29 = call i32 @ext_shift(i32 %27, i64 %7, i32* %28)
%30 = getelementptr inbounds [2 x i32], [2 x i32]* %6, i64 0, i64 1
%31 = load i32, i32* %30
%32 = add i64 %23, %20
%33 = getelementptr inbounds i32, i32* %1, i64 %32
%34 = load i32, i32* %33
%35 = or i32 %34, %31
store i32 %35, i32* %33
br label %36
36: ; preds = %24, %16
%37 = icmp ult i64 %23, %19
br i1 %37, label %38, label %58
38: ; preds = %36
%39 = getelementptr inbounds [2 x i32], [2 x i32]* %6, i64 0, i64 0
%40 = getelementptr inbounds [2 x i32], [2 x i32]* %6, i64 0, i64 1
br label %41
41: ; preds = %38, %41
%42 = phi i64 [ %23, %38 ], [ %52, %41 ]
%43 = getelementptr inbounds i32, i32* %0, i64 %42
%44 = load i32, i32* %43
%45 = call i32 @ext_shift(i32 %44, i64 %7, i32* %39)
%46 = load i32, i32* %39
%47 = add i64 %42, %20
%48 = getelementptr inbounds i32, i32* %1, i64 %47
%49 = load i32, i32* %48
%50 = or i32 %49, %46
store i32 %50, i32* %48
%51 = load i32, i32* %40
%52 = add nuw i64 %42, 1
%53 = add i64 %52, %20
%54 = getelementptr inbounds i32, i32* %1, i64 %53
%55 = load i32, i32* %54
%56 = or i32 %55, %51
store i32 %56, i32* %54
%57 = icmp eq i64 %52, %19
br i1 %57, label %58, label %41
58: ; preds = %41, %36
%59 = phi i64 [ %23, %36 ], [ %19, %41 ]
%60 = sub i64 0, %20
%61 = icmp eq i64 %59, %60
br i1 %61, label %72, label %62
62: ; preds = %58
%63 = getelementptr inbounds i32, i32* %0, i64 %19
%64 = load i32, i32* %63
%65 = getelementptr inbounds [2 x i32], [2 x i32]* %6, i64 0, i64 0
%66 = call i32 @ext_shift(i32 %64, i64 %7, i32* %65)
%67 = load i32, i32* %65
%68 = add i64 %19, %20
%69 = getelementptr inbounds i32, i32* %1, i64 %68
%70 = load i32, i32* %69
%71 = or i32 %70, %67
store i32 %71, i32* %69
br label %72
72: ; preds = %62, %58
ret void
}