#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));
    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    12d4 <find_next_bit+0x1c4>
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     11ea <find_next_bit+0xda>
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    12d4 <find_next_bit+0x1c4>
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     1264 <find_next_bit+0x154>
mov    -0x10(%rbp),%rax
cmpq   $0x0,(%rax)
jne    1217 <find_next_bit+0x107>
jmp    123e <find_next_bit+0x12e>
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    12d4 <find_next_bit+0x1c4>
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    11f9 <find_next_bit+0xe9>
cmpq   $0x0,-0x18(%rbp)
je     12cc <find_next_bit+0x1bc>
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     12b9 <find_next_bit+0x1a9>
mov    -0x28(%rbp),%rdi
call   1030 <__ffsl@plt>
mov    %rax,%rcx
movslq -0x30(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x30(%rbp)
jmp    12c7 <find_next_bit+0x1b7>
mov    -0x18(%rbp),%rcx
movslq -0x30(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x30(%rbp)
jmp    12cc <find_next_bit+0x1bc>
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    11af <find_next_bit+0x9f>
mov    %rdx,%r14
shr    $0x6,%r14
movslq %r14d,%rcx
shl    $0x6,%r14d
lea    (%rdi,%rcx,8),%rsi
and    $0x3f,%edx
je     1162 <find_next_bit+0x52>
neg    %dl
mov    $0xffffffffffffffff,%rdi
mov    %edx,%ecx
shr    %cl,%rdi
not    %rdi
and    (%rsi),%rdi
je     115a <find_next_bit+0x4a>
movslq %r14d,%rbx
call   1030 <__ffsl@plt>
add    %rbx,%rax
jmp    11af <find_next_bit+0x9f>
add    $0x40,%r14d
add    $0x8,%rsi
movslq %r14d,%rbx
sub    %rbx,%rax
cmp    $0x40,%rax
jb     118d <find_next_bit+0x7d>
xchg   %ax,%ax
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     1170 <find_next_bit+0x60>
mov    %ebx,%r14d
test   %rax,%rax
je     11ac <find_next_bit+0x9c>
mov    (%rsi),%rdi
mov    %eax,%ecx
neg    %cl
shl    %cl,%rdi
shr    %cl,%rdi
test   %rdi,%rdi
je     11a9 <find_next_bit+0x99>
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 %110
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 %54
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 %110
49: ; preds = %32
%50 = load i32, i32* %10
%51 = add nsw i32 %50, 64
store i32 %51, i32* %10
%52 = load i64*, i64** %5
%53 = getelementptr inbounds i64, i64* %52, i32 1
store i64* %53, i64** %5
br label %54
54: ; preds = %49, %17
%55 = load i32, i32* %10
%56 = sext i32 %55 to i64
%57 = load i64, i64* %6
%58 = sub i64 %57, %56
store i64 %58, i64* %6
br label %59
59: ; preds = %74, %54
%60 = load i64, i64* %6
%61 = icmp uge i64 %60, 64
br i1 %61, label %62, label %81
62: ; preds = %59
%63 = load i64*, i64** %5
%64 = load i64, i64* %63
%65 = icmp eq i64 %64, 0
br i1 %65, label %66, label %67
66: ; preds = %62
br label %74
67: ; preds = %62
%68 = load i32, i32* %10
%69 = sext i32 %68 to i64
%70 = load i64*, i64** %5
%71 = load i64, i64* %70
%72 = call i64 @__ffsl(i64 %71)
%73 = add i64 %69, %72
store i64 %73, i64* %4
br label %110
74: ; preds = %66
%75 = load i64, i64* %6
%76 = sub i64 %75, 64
store i64 %76, i64* %6
%77 = load i32, i32* %10
%78 = add nsw i32 %77, 64
store i32 %78, i32* %10
%79 = load i64*, i64** %5
%80 = getelementptr inbounds i64, i64* %79, i32 1
store i64* %80, i64** %5
br label %59
81: ; preds = %59
%82 = load i64, i64* %6
%83 = icmp ne i64 %82, 0
br i1 %83, label %84, label %107
84: ; preds = %81
%85 = load i64*, i64** %5
%86 = load i64, i64* %85
%87 = load i64, i64* %6
%88 = sub i64 64, %87
%89 = lshr i64 -1, %88
%90 = and i64 %86, %89
store i64 %90, i64* %8
%91 = load i64, i64* %8
%92 = icmp ne i64 %91, 0
br i1 %92, label %93, label %100
93: ; preds = %84
%94 = load i64, i64* %8
%95 = call i64 @__ffsl(i64 %94)
%96 = load i32, i32* %10
%97 = sext i32 %96 to i64
%98 = add i64 %97, %95
%99 = trunc i64 %98 to i32
store i32 %99, i32* %10
br label %106
100: ; preds = %84
%101 = load i64, i64* %6
%102 = load i32, i32* %10
%103 = sext i32 %102 to i64
%104 = add i64 %103, %101
%105 = trunc i64 %104 to i32
store i32 %105, i32* %10
br label %106
106: ; preds = %100, %93
br label %107
107: ; preds = %106, %81
%108 = load i32, i32* %10
%109 = sext i32 %108 to i64
store i64 %109, i64* %4
br label %110
110: ; preds = %107, %67, %43, %15
%111 = load i64, i64* %4
ret i64 %111
}

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 %72
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 %30, 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
br i1 %22, label %27, label %23
23: ; preds = %15
%24 = sext i32 %10 to i64
%25 = tail call i64 @__ffsl(i64 %21)
%26 = add i64 %25, %24
br label %72
27: ; preds = %15
%28 = add nsw i32 %10, 64
%29 = getelementptr inbounds i64, i64* %13, i64 1
br label %30
30: ; preds = %27, %5
%31 = phi i64* [ %29, %27 ], [ %13, %5 ]
%32 = phi i32 [ %28, %27 ], [ %10, %5 ]
%33 = sext i32 %32 to i64
%34 = sub i64 %1, %33
%35 = icmp ugt i64 %34, 63
br i1 %35, label %36, label %51
36: ; preds = %30, %46
%37 = phi i32 [ %48, %46 ], [ %32, %30 ]
%38 = phi i64* [ %49, %46 ], [ %31, %30 ]
%39 = phi i64 [ %47, %46 ], [ %34, %30 ]
%40 = load i64, i64* %38
%41 = icmp eq i64 %40, 0
br i1 %41, label %46, label %42
42: ; preds = %36
%43 = sext i32 %37 to i64
%44 = tail call i64 @__ffsl(i64 %40)
%45 = add i64 %44, %43
br label %72
46: ; preds = %36
%47 = add i64 %39, -64
%48 = add nsw i32 %37, 64
%49 = getelementptr inbounds i64, i64* %38, i64 1
%50 = icmp ugt i64 %47, 63
br i1 %50, label %36, label %51
51: ; preds = %46, %30
%52 = phi i64 [ %34, %30 ], [ %47, %46 ]
%53 = phi i64* [ %31, %30 ], [ %49, %46 ]
%54 = phi i32 [ %32, %30 ], [ %48, %46 ]
%55 = icmp eq i64 %52, 0
br i1 %55, label %69, label %56
56: ; preds = %51
%57 = load i64, i64* %53
%58 = sub nuw nsw i64 64, %52
%59 = lshr i64 -1, %58
%60 = and i64 %57, %59
%61 = icmp eq i64 %60, 0
br i1 %61, label %66, label %62
62: ; preds = %56
%63 = tail call i64 @__ffsl(i64 %60)
%64 = trunc i64 %63 to i32
%65 = add i32 %54, %64
br label %69
66: ; preds = %56
%67 = trunc i64 %52 to i32
%68 = add i32 %54, %67
br label %69
69: ; preds = %62, %66, %51
%70 = phi i32 [ %65, %62 ], [ %68, %66 ], [ %54, %51 ]
%71 = sext i32 %70 to i64
br label %72
72: ; preds = %3, %69, %42, %23
%73 = phi i64 [ %26, %23 ], [ %45, %42 ], [ %71, %69 ], [ %1, %3 ]
ret i64 %73
}