#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 */

/* Variables and functions */
unsigned long __ffsl(long);
unsigned long find_next_bit(unsigned long *addr, unsigned long size,
                            unsigned long offset) {
  long mask;
  int offs;
  int bit;
  int pos;
  if (offset >= size)
    return (size);
  pos = offset / 64;
  offs = offset % 64;
  bit = 64 * pos;
  addr += pos;
  if (offs) {
    mask = (*addr) & ~(~0UL >> (64 - (offs)));
    if (mask)
      return (bit + __ffsl(mask));
    if (size - bit <= 64)
      return (size);
    bit += 64;
    addr++;
  }
  for (size -= bit; size >= 64; size -= 64, bit += 64, addr++) {
    if (*addr == 0)
      continue;
    return (bit + __ffsl(*addr));
  }
  if (size) {
    mask = (*addr) & (~0UL >> (64 - (size)));
    if (mask)
      bit += __ffsl(mask);
    else
      bit += size;
  }
  return (bit);
}


x86 assembly (clang, -O0):
<find_next_bit>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x18(%rbp),%rax
jb     113f <find_next_bit+0x2f>
mov    -0x18(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    12f6 <find_next_bit+0x1e6>
mov    -0x20(%rbp),%rax
shr    $0x6,%rax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%rax
and    $0x3f,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x34(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x30(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     120c <find_next_bit+0xfc>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    $0x40,%ecx
sub    -0x2c(%rbp),%ecx
mov    %ecx,%ecx
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
mov    %rdx,%rcx
xor    $0xffffffffffffffff,%rcx
and    %rcx,%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     11d5 <find_next_bit+0xc5>
movslq -0x30(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x28(%rbp),%rdi
call   1030 <__ffsl@plt>
mov    %rax,%rcx
mov    -0x40(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
jmp    12f6 <find_next_bit+0x1e6>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
sub    %rcx,%rax
cmp    $0x40,%rax
ja     11f7 <find_next_bit+0xe7>
mov    -0x18(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    12f6 <find_next_bit+0x1e6>
mov    -0x30(%rbp),%eax
add    $0x40,%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rbp)
movslq -0x30(%rbp),%rcx
mov    -0x18(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x40,-0x18(%rbp)
jb     1286 <find_next_bit+0x176>
mov    -0x10(%rbp),%rax
cmpq   $0x0,(%rax)
jne    1239 <find_next_bit+0x129>
jmp    1260 <find_next_bit+0x150>
movslq -0x30(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
call   1030 <__ffsl@plt>
mov    %rax,%rcx
mov    -0x48(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
jmp    12f6 <find_next_bit+0x1e6>
mov    -0x18(%rbp),%rax
sub    $0x40,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    $0x40,%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rbp)
jmp    121b <find_next_bit+0x10b>
cmpq   $0x0,-0x18(%rbp)
je     12ee <find_next_bit+0x1de>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    $0x40,%ecx
sub    -0x18(%rbp),%rcx
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
mov    %rdx,%rcx
and    %rcx,%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     12db <find_next_bit+0x1cb>
mov    -0x28(%rbp),%rdi
call   1030 <__ffsl@plt>
mov    %rax,%rcx
movslq -0x30(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x30(%rbp)
jmp    12e9 <find_next_bit+0x1d9>
mov    -0x18(%rbp),%rcx
movslq -0x30(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x30(%rbp)
jmp    12ee <find_next_bit+0x1de>
movslq -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<find_next_bit>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%rax
cmp    %rsi,%rdx
jae    11bf <find_next_bit+0xaf>
mov    %rdx,%r14
shr    $0x6,%r14
movslq %r14d,%rcx
shl    $0x6,%r14d
lea    (%rdi,%rcx,8),%rsi
and    $0x3f,%edx
je     116e <find_next_bit+0x5e>
neg    %dl
mov    $0xffffffffffffffff,%rdi
mov    %edx,%ecx
shr    %cl,%rdi
not    %rdi
movslq %r14d,%rbx
and    (%rsi),%rdi
je     115a <find_next_bit+0x4a>
call   1030 <__ffsl@plt>
add    %rbx,%rax
jmp    11bf <find_next_bit+0xaf>
mov    %rax,%rcx
sub    %rbx,%rcx
cmp    $0x41,%rcx
jb     11bf <find_next_bit+0xaf>
add    $0x40,%r14d
add    $0x8,%rsi
movslq %r14d,%rbx
sub    %rbx,%rax
cmp    $0x40,%rax
jb     119d <find_next_bit+0x8d>
nopw   0x0(%rax,%rax,1)
mov    (%rsi),%rdi
test   %rdi,%rdi
jne    1150 <find_next_bit+0x40>
add    $0xffffffffffffffc0,%rax
add    $0x8,%rsi
add    $0x40,%rbx
cmp    $0x3f,%rax
ja     1180 <find_next_bit+0x70>
mov    %ebx,%r14d
test   %rax,%rax
je     11bc <find_next_bit+0xac>
mov    (%rsi),%rdi
mov    %eax,%ecx
neg    %cl
shl    %cl,%rdi
shr    %cl,%rdi
test   %rdi,%rdi
je     11b9 <find_next_bit+0xa9>
call   1030 <__ffsl@plt>
add    %eax,%r14d
movslq %r14d,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define i64 @find_next_bit(i64* %0, i64 %1, i64 %2) {
%4 = alloca i64
%5 = alloca i64*
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
store i64* %0, i64** %5
store i64 %1, i64* %6
store i64 %2, i64* %7
%12 = load i64, i64* %7
%13 = load i64, i64* %6
%14 = icmp uge i64 %12, %13
br i1 %14, label %15, label %17
15: ; preds = %3
%16 = load i64, i64* %6
store i64 %16, i64* %4
br label %118
17: ; preds = %3
%18 = load i64, i64* %7
%19 = udiv i64 %18, 64
%20 = trunc i64 %19 to i32
store i32 %20, i32* %11
%21 = load i64, i64* %7
%22 = urem i64 %21, 64
%23 = trunc i64 %22 to i32
store i32 %23, i32* %9
%24 = load i32, i32* %11
%25 = mul nsw i32 64, %24
store i32 %25, i32* %10
%26 = load i32, i32* %11
%27 = load i64*, i64** %5
%28 = sext i32 %26 to i64
%29 = getelementptr inbounds i64, i64* %27, i64 %28
store i64* %29, i64** %5
%30 = load i32, i32* %9
%31 = icmp ne i32 %30, 0
br i1 %31, label %32, label %62
32: ; preds = %17
%33 = load i64*, i64** %5
%34 = load i64, i64* %33
%35 = load i32, i32* %9
%36 = sub nsw i32 64, %35
%37 = zext i32 %36 to i64
%38 = lshr i64 -1, %37
%39 = xor i64 %38, -1
%40 = and i64 %34, %39
store i64 %40, i64* %8
%41 = load i64, i64* %8
%42 = icmp ne i64 %41, 0
br i1 %42, label %43, label %49
43: ; preds = %32
%44 = load i32, i32* %10
%45 = sext i32 %44 to i64
%46 = load i64, i64* %8
%47 = call i64 @__ffsl(i64 %46)
%48 = add i64 %45, %47
store i64 %48, i64* %4
br label %118
49: ; preds = %32
%50 = load i64, i64* %6
%51 = load i32, i32* %10
%52 = sext i32 %51 to i64
%53 = sub i64 %50, %52
%54 = icmp ule i64 %53, 64
br i1 %54, label %55, label %57
55: ; preds = %49
%56 = load i64, i64* %6
store i64 %56, i64* %4
br label %118
57: ; preds = %49
%58 = load i32, i32* %10
%59 = add nsw i32 %58, 64
store i32 %59, i32* %10
%60 = load i64*, i64** %5
%61 = getelementptr inbounds i64, i64* %60, i32 1
store i64* %61, i64** %5
br label %62
62: ; preds = %57, %17
%63 = load i32, i32* %10
%64 = sext i32 %63 to i64
%65 = load i64, i64* %6
%66 = sub i64 %65, %64
store i64 %66, i64* %6
br label %67
67: ; preds = %82, %62
%68 = load i64, i64* %6
%69 = icmp uge i64 %68, 64
br i1 %69, label %70, label %89
70: ; preds = %67
%71 = load i64*, i64** %5
%72 = load i64, i64* %71
%73 = icmp eq i64 %72, 0
br i1 %73, label %74, label %75
74: ; preds = %70
br label %82
75: ; preds = %70
%76 = load i32, i32* %10
%77 = sext i32 %76 to i64
%78 = load i64*, i64** %5
%79 = load i64, i64* %78
%80 = call i64 @__ffsl(i64 %79)
%81 = add i64 %77, %80
store i64 %81, i64* %4
br label %118
82: ; preds = %74
%83 = load i64, i64* %6
%84 = sub i64 %83, 64
store i64 %84, i64* %6
%85 = load i32, i32* %10
%86 = add nsw i32 %85, 64
store i32 %86, i32* %10
%87 = load i64*, i64** %5
%88 = getelementptr inbounds i64, i64* %87, i32 1
store i64* %88, i64** %5
br label %67
89: ; preds = %67
%90 = load i64, i64* %6
%91 = icmp ne i64 %90, 0
br i1 %91, label %92, label %115
92: ; preds = %89
%93 = load i64*, i64** %5
%94 = load i64, i64* %93
%95 = load i64, i64* %6
%96 = sub i64 64, %95
%97 = lshr i64 -1, %96
%98 = and i64 %94, %97
store i64 %98, i64* %8
%99 = load i64, i64* %8
%100 = icmp ne i64 %99, 0
br i1 %100, label %101, label %108
101: ; preds = %92
%102 = load i64, i64* %8
%103 = call i64 @__ffsl(i64 %102)
%104 = load i32, i32* %10
%105 = sext i32 %104 to i64
%106 = add i64 %105, %103
%107 = trunc i64 %106 to i32
store i32 %107, i32* %10
br label %114
108: ; preds = %92
%109 = load i64, i64* %6
%110 = load i32, i32* %10
%111 = sext i32 %110 to i64
%112 = add i64 %111, %109
%113 = trunc i64 %112 to i32
store i32 %113, i32* %10
br label %114
114: ; preds = %108, %101
br label %115
115: ; preds = %114, %89
%116 = load i32, i32* %10
%117 = sext i32 %116 to i64
store i64 %117, i64* %4
br label %118
118: ; preds = %115, %75, %55, %43, %15
%119 = load i64, i64* %4
ret i64 %119
}

LLVM IR (-O2):
define i64 @find_next_bit(i64* nocapture %0, i64 %1, i64 %2) {
%4 = icmp ult i64 %2, %1
br i1 %4, label %5, label %75
5: ; preds = %3
%6 = lshr i64 %2, 6
%7 = trunc i64 %6 to i32
%8 = trunc i64 %2 to i32
%9 = and i32 %8, 63
%10 = shl nsw i32 %7, 6
%11 = shl i64 %6, 32
%12 = ashr exact i64 %11, 32
%13 = getelementptr inbounds i64, i64* %0, i64 %12
%14 = icmp eq i32 %9, 0
br i1 %14, label %33, label %15
15: ; preds = %5
%16 = load i64, i64* %13
%17 = sub nuw nsw i32 64, %9
%18 = zext i32 %17 to i64
%19 = lshr i64 -1, %18
%20 = xor i64 %19, -1
%21 = and i64 %16, %20
%22 = icmp eq i64 %21, 0
%23 = sext i32 %10 to i64
br i1 %22, label %27, label %24
24: ; preds = %15
%25 = tail call i64 @__ffsl(i64 %21)
%26 = add i64 %25, %23
br label %75
27: ; preds = %15
%28 = sub i64 %1, %23
%29 = icmp ult i64 %28, 65
br i1 %29, label %75, label %30
30: ; preds = %27
%31 = add nsw i32 %10, 64
%32 = getelementptr inbounds i64, i64* %13, i64 1
br label %33
33: ; preds = %30, %5
%34 = phi i64* [ %32, %30 ], [ %13, %5 ]
%35 = phi i32 [ %31, %30 ], [ %10, %5 ]
%36 = sext i32 %35 to i64
%37 = sub i64 %1, %36
%38 = icmp ugt i64 %37, 63
br i1 %38, label %39, label %54
39: ; preds = %33, %49
%40 = phi i32 [ %51, %49 ], [ %35, %33 ]
%41 = phi i64* [ %52, %49 ], [ %34, %33 ]
%42 = phi i64 [ %50, %49 ], [ %37, %33 ]
%43 = load i64, i64* %41
%44 = icmp eq i64 %43, 0
br i1 %44, label %49, label %45
45: ; preds = %39
%46 = sext i32 %40 to i64
%47 = tail call i64 @__ffsl(i64 %43)
%48 = add i64 %47, %46
br label %75
49: ; preds = %39
%50 = add i64 %42, -64
%51 = add nsw i32 %40, 64
%52 = getelementptr inbounds i64, i64* %41, i64 1
%53 = icmp ugt i64 %50, 63
br i1 %53, label %39, label %54
54: ; preds = %49, %33
%55 = phi i64 [ %37, %33 ], [ %50, %49 ]
%56 = phi i64* [ %34, %33 ], [ %52, %49 ]
%57 = phi i32 [ %35, %33 ], [ %51, %49 ]
%58 = icmp eq i64 %55, 0
br i1 %58, label %72, label %59
59: ; preds = %54
%60 = load i64, i64* %56
%61 = sub nuw nsw i64 64, %55
%62 = lshr i64 -1, %61
%63 = and i64 %60, %62
%64 = icmp eq i64 %63, 0
br i1 %64, label %69, label %65
65: ; preds = %59
%66 = tail call i64 @__ffsl(i64 %63)
%67 = trunc i64 %66 to i32
%68 = add i32 %57, %67
br label %72
69: ; preds = %59
%70 = trunc i64 %55 to i32
%71 = add i32 %57, %70
br label %72
72: ; preds = %65, %69, %54
%73 = phi i32 [ %68, %65 ], [ %71, %69 ], [ %57, %54 ]
%74 = sext i32 %73 to i64
br label %75
75: ; preds = %27, %3, %72, %45, %24
%76 = phi i64 [ %26, %24 ], [ %48, %45 ], [ %74, %72 ], [ %1, %3 ], [ %1, %27 ]
ret i64 %76
}