LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/algorithm-archivists[P]GathVL/src/encoders/video_encoder.cpp
// Function: video_encoder::encode(_cairo_surface*)
void video_encoder::encode(cairo_surface_t *image) {
    AVCodecContext *c = ostream.codec_ctx;
    AVFrame *frame = nullptr;

    cairo_surface_flush(image);
    uint8_t *data[1] = {(uint8_t*)cairo_image_surface_get_data(image)};
    int stride[1] = {cairo_image_surface_get_stride(image)};
    cairo_surface_mark_dirty(image);

    if (av_frame_make_writable(ostream.frame) < 0) {
        std::exit(1);
    }

    frame = ostream.frame;
    if (c->pix_fmt != AV_PIX_FMT_BGRA) {
        sws_scale(ostream.sws_ctx, data, stride, 0, c->height, frame->data,
                  frame->linesize);
    } else {
        av_image_fill_arrays(frame->data, frame->linesize, data[0], c->pix_fmt,
                             c->width, c->height, stride[0]);
    }

    ostream.frame->pts = ostream.next_pts++;

    write_frame(format_ctx, &ostream, ostream.frame);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5910
movq -0x10(%rbp), %rdi
callq 0x5280
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x54a0
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5320
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x53a0
cmpl $0x0, %eax
jge 0x38f3f
movl $0x1, %edi
callq 0x57d0
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1c, 0x88(%rax)
je 0x38f89
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x78(%rax), %r8d
movq -0x20(%rbp), %r9
movq -0x20(%rbp), %rax
addq $0x40, %rax
xorl %ecx, %ecx
movq %rax, (%rsp)
callq 0x5940
jmp 0x38fbe
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x40, %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x88(%rax), %ecx
movq -0x18(%rbp), %rax
movl 0x74(%rax), %r8d
movq -0x18(%rbp), %rax
movl 0x78(%rax), %r9d
movl -0x2c(%rbp), %eax
movl %eax, (%rsp)
callq 0x5340
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rdx
movq %rdx, %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movq 0x48(%rax), %rcx
movq %rdx, 0x88(%rcx)
movq 0x28(%rax), %rdi
movq %rax, %rsi
addq $0x30, %rsi
movq 0x48(%rax), %rdx
callq 0x39000
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/algorithm-archivists[P]GathVL/src/encoders/video_encoder.cpp
// Function: add_stream(output_stream*, AVFormatContext*, AVCodec**, AVCodecID)
static void add_stream(output_stream *ostream, AVFormatContext *format_ctx,
                       AVCodec **codec, enum AVCodecID codec_id) {
    AVCodecContext *codec_ctx;

    *codec = avcodec_find_encoder(codec_id);

    if (!(*codec)) {
        std::cout << "Could not find encoder for "
            << avcodec_get_name(codec_id) << std::endl;
        std::exit(1);
    }

    ostream->stream = avformat_new_stream(format_ctx, NULL);
    if (!ostream->stream) {
        std::cout << "Could not allocate stream" << std::endl;
        std::exit(1);
    }

    ostream->stream->id = format_ctx->nb_streams-1;
    codec_ctx = avcodec_alloc_context3(*codec);
    if (!codec_ctx) {
        std::cout << "Could not alloc an encoding context" << std::endl;
        std::exit(1);
    }
    ostream->codec_ctx = codec_ctx;

    if (format_ctx->oformat->flags & AVFMT_GLOBALHEADER) {
        codec_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x51c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x397e7
movq 0x157fe(%rip), %rdi     # 0x4efa8
leaq 0x40d9(%rip), %rsi      # 0x3d88a
callq 0x5780
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %edi
callq 0x5200
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x5780
movq %rax, %rdi
movq 0x157e8(%rip), %rsi     # 0x4efc0
callq 0x5960
movl $0x1, %edi
callq 0x57d0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x54e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x39834
movq 0x15799(%rip), %rdi     # 0x4efa8
leaq 0x4090(%rip), %rsi      # 0x3d8a6
callq 0x5780
movq %rax, %rdi
movq 0x1579b(%rip), %rsi     # 0x4efc0
callq 0x5960
movl $0x1, %edi
callq 0x57d0
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x5900
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3988b
movq 0x15742(%rip), %rdi     # 0x4efa8
leaq 0x4053(%rip), %rsi      # 0x3d8c0
callq 0x5780
movq %rax, %rdi
movq 0x15744(%rip), %rsi     # 0x4efc0
callq 0x5960
movl $0x1, %edi
callq 0x57d0
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x2c(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x398ba
movq -0x28(%rbp), %rax
movl 0x4c(%rax), %ecx
orl $0x400000, %ecx         # imm = 0x400000
movl %ecx, 0x4c(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/algorithm-archivists[P]GathVL/src/encoders/video_encoder.cpp
// Function: open_video(AVFormatContext*, AVCodec*, output_stream*, AVDictionary*)
static void open_video(AVFormatContext *format_ctx, AVCodec *codec,
                       output_stream *ostream, AVDictionary *opt_arg) {
    AVCodecContext *codec_ctx = ostream->codec_ctx;
    AVDictionary *opt = NULL;

    av_dict_copy(&opt, opt_arg, 0);

    int ret = avcodec_open2(codec_ctx, codec, &opt);
    av_dict_free(&opt);
    if (ret < 0) {
        std::cout << "Could not open video codec." << std::endl;
        std::exit(1);
    }

    ostream->frame = alloc_picture(codec_ctx->pix_fmt, codec_ctx->width,
                                   codec_ctx->height);
    if (!ostream->frame) {
        std::cout << "Could not allocate video frame" << std::endl;
        std::exit(1);
    }

    ret = avcodec_parameters_from_context(ostream->stream->codecpar,
                                          codec_ctx);
    if (ret < 0) {
        std::cout << "Could not copy the stream parameters" << std::endl;
        std::exit(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdi
xorl %edx, %edx
callq 0x5640
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x56f0
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5170
cmpl $0x0, -0x34(%rbp)
jge 0x3994a
movq 0x15683(%rip), %rdi     # 0x4efa8
leaq 0x3fb8(%rip), %rsi      # 0x3d8e4
callq 0x5780
movq %rax, %rdi
movq 0x15685(%rip), %rsi     # 0x4efc0
callq 0x5960
movl $0x1, %edi
callq 0x57d0
movq -0x28(%rbp), %rax
movl 0x88(%rax), %edi
movq -0x28(%rbp), %rax
movl 0x74(%rax), %esi
movq -0x28(%rbp), %rax
movl 0x78(%rax), %edx
callq 0x39af0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x399a9
movq 0x15624(%rip), %rdi     # 0x4efa8
leaq 0x3f75(%rip), %rsi      # 0x3d900
callq 0x5780
movq %rax, %rdi
movq 0x15626(%rip), %rsi     # 0x4efc0
callq 0x5960
movl $0x1, %edi
callq 0x57d0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0xd0(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x58b0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x399f5
movq 0x155d8(%rip), %rdi     # 0x4efa8
leaq 0x3f48(%rip), %rsi      # 0x3d91f
callq 0x5780
movq %rax, %rdi
movq 0x155da(%rip), %rsi     # 0x4efc0
callq 0x5960
movl $0x1, %edi
callq 0x57d0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/algorithm-archivists[P]GathVL/src/encoders/video_encoder.cpp
// Function: video_encoder::~video_encoder()
video_encoder::~video_encoder() {
    write_frame(format_ctx, &ostream, NULL);

    av_write_trailer(format_ctx);

    avcodec_free_context(&ostream.codec_ctx);
    av_frame_free(&ostream.frame);
    sws_freeContext(ostream.sws_ctx);

    if (!(format_ctx->oformat->flags & AVFMT_NOFILE)) {
        avio_closep(&format_ctx->pb);
    }

    avformat_free_context(format_ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x10(%rbp)
leaq 0x152ed(%rip), %rax     # 0x4ed08
movq %rax, (%rsi)
movq 0x28(%rsi), %rdi
addq $0x30, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x39000
jmp 0x39a31
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x5600
jmp 0x39a40
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x58e0
jmp 0x39a4f
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x5250
jmp 0x39a5e
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x5420
jmp 0x39a6d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movl 0x2c(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x39a99
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
addq $0x20, %rdi
callq 0x5610
jmp 0x39a97
jmp 0x39a99
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x52a0
jmp 0x39aa8
movq -0x10(%rbp), %rdi
callq 0x38e90
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x7250
nop
// File: /workspace/github_c_makefile_star2_O0/algorithm-archivists[P]GathVL/src/encoders/video_encoder.cpp
// Function: alloc_picture(AVPixelFormat, int, int)
static AVFrame *alloc_picture(enum AVPixelFormat pix_fmt, int width,
                              int height) {
    AVFrame *picture;

    picture = av_frame_alloc();
    if (!picture) {
        return NULL;
    }

    picture->format = pix_fmt;
    picture->width  = width;
    picture->height = height;

    if (av_frame_get_buffer(picture, 0) < 0) {
        std::cout << "Could not allocate frame data." << std::endl;
        std::exit(1);
    }

    return picture;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
callq 0x56b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x39b1b
movq $0x0, -0x8(%rbp)
jmp 0x39b7d
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x74(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x68(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x6c(%rax)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x5130
cmpl $0x0, %eax
jge 0x39b75
movq 0x15458(%rip), %rdi     # 0x4efa8
leaq 0x3ded(%rip), %rsi      # 0x3d944
callq 0x5780
movq %rax, %rdi
movq 0x1545a(%rip), %rsi     # 0x4efc0
callq 0x5960
movl $0x1, %edi
callq 0x57d0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/algorithm-archivists[P]GathVL/src/systems/system_unix.cpp
// Function: subprocess(char const*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
int subprocess(const char *program, const std::vector<std::string>& args) {
    std::vector<char *> argv;

    for (auto& str : args) {
        argv.push_back(&(char&)str.front());
    }
    argv.push_back(NULL);

    pid_t pid = fork();
    int status = 0;

    if (pid == 0) {
        int fd = open("/dev/null", O_WRONLY);
        dup2(fd, 1);
        dup2(fd, 2);
        close(fd);

        execv(program, argv.data());
        std::exit(127);
    } else {
        waitpid(pid, &status, 0);
        if (WIFEXITED(status) && (WEXITSTATUS(status) == 0)) {
            return 0;
        }
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x39d40
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x39d60
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x39d90
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x39dc0
testb $0x1, %al
jne 0x39be1
jmp 0x39c31
leaq -0x40(%rbp), %rdi
callq 0x39e00
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x5150
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x39e20
jmp 0x39c0a
jmp 0x39c0c
leaq -0x40(%rbp), %rdi
callq 0x39e50
jmp 0x39bce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x39e90
jmp 0x39d32
movq $0x0, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x39e20
jmp 0x39c48
callq 0x5920
movl %eax, -0x74(%rbp)
movl $0x0, -0x78(%rbp)
cmpl $0x0, -0x74(%rbp)
jne 0x39cd2
leaq 0x3d0f(%rip), %rdi      # 0x3d973
xorl %eax, %eax
movl $0x1, %esi
callq 0x5680
movl %eax, -0x84(%rbp)
jmp 0x39c78
movl -0x84(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %edi
movl $0x1, %esi
callq 0x5740
movl -0x7c(%rbp), %edi
movl $0x2, %esi
callq 0x5740
movl -0x7c(%rbp), %edi
callq 0x55b0
jmp 0x39ca5
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x39e70
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x53c0
movl $0x7f, %edi
callq 0x57d0
movl -0x74(%rbp), %edi
leaq -0x78(%rbp), %rsi
xorl %edx, %edx
callq 0x53d0
jmp 0x39ce2
movl -0x78(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x39d0d
movl -0x78(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl $0x0, %eax
jne 0x39d0d
movl $0x0, -0x4(%rbp)
movl $0x1, -0x80(%rbp)
jmp 0x39d1d
jmp 0x39d0f
movl $0x1, -0x4(%rbp)
movl $0x1, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x39e90
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x52d0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/ch6/eatyguy10.c
// Function: done
void done(const char *msg) {

  // Put the terminal back into a decent state.
  system("stty cooked echo");  // Undo init call to "stty raw".
  system("tput reset");        // Reset colors and clear screen.

  // Print the farewell message if there is one.
  if (msg) printf("%s\n", msg);

  exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2e88f(%rip), %rdi     # 0x34052
callq 0x5160
leaq 0x2e894(%rip), %rdi     # 0x34063
callq 0x5160
cmpq $0x0, -0x8(%rbp)
je 0x57ed
movq -0x8(%rbp), %rsi
leaq 0x2e888(%rip), %rdi     # 0x3406e
movb $0x0, %al
callq 0x5180
xorl %edi, %edi
callq 0x5470
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoomanist[P]carrot/yes.c
// Function: main
int 
main(int argc, char **argv)
{
	char msg[CHAR_MAX] ;
	if (argc == 1)
		strcpy(msg, "yes");
	else if (argc > 2)
		return 0;
	else if (argc == 2)
		strcpy(msg, argv[1]);
	for(;;){
		printf("%s\n", msg);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x1184
leaq -0x90(%rbp), %rdi
leaq 0xe87(%rip), %rsi       # 0x2004
callq 0x1030
jmp 0x11b3
cmpl $0x2, -0x8(%rbp)
jle 0x1195
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
cmpl $0x2, -0x8(%rbp)
jne 0x11af
leaq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1030
jmp 0x11b1
jmp 0x11b3
jmp 0x11b5
leaq -0x90(%rbp), %rsi
leaq 0xe45(%rip), %rdi       # 0x2008
movb $0x0, %al
callq 0x1040
jmp 0x11b5
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/bcast1.c
// Function: main
int
main(void)
{
    int i;
    long *target;
    long *source;
    int me, npes;

    shmem_init();
    me = shmem_my_pe();
    npes = shmem_n_pes();

    source = (long *) shmem_malloc(npes * sizeof(*source));
    for (i = 0; i < npes; i += 1) {
        source[i] = i + 1;
    }

    target = (long *) shmem_malloc(npes * sizeof(*target));
    for (i = 0; i < npes; i += 1) {
        target[i] = -999;
    }

    for (i = 0; i < SHMEM_BCAST_SYNC_SIZE; i += 1) {
        pSync[i] = SHMEM_SYNC_VALUE;
    }
    shmem_barrier_all();

    shmem_broadcast64(target, source, npes, 0, 0, 0, npes, pSync);

    for (i = 0; i < npes; i++) {
        printf("%-8d %ld\n", me, target[i]);
    }

    shmem_barrier_all();

    shmem_free(target);
    shmem_free(source);
    shmem_finalize();

    return 0;
}

// Assembly:
subq $0x38, %rsp
movl $0x0, 0x34(%rsp)
callq 0x1090
callq 0x1060
movl %eax, 0x1c(%rsp)
callq 0x1040
movl %eax, 0x18(%rsp)
movslq 0x18(%rsp), %rdi
shlq $0x3, %rdi
callq 0x1070
movq %rax, 0x20(%rsp)
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x122d
movl 0x30(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movq 0x20(%rsp), %rax
movslq 0x30(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x11fe
movslq 0x18(%rsp), %rdi
shlq $0x3, %rdi
callq 0x1070
movq %rax, 0x28(%rsp)
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x1271
movq 0x28(%rsp), %rax
movslq 0x30(%rsp), %rcx
movq $-0x3e7, (%rax,%rcx,8)  # imm = 0xFC19
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x1248
movl $0x0, 0x30(%rsp)
cmpl $0x2, 0x30(%rsp)
jge 0x12a1
movslq 0x30(%rsp), %rcx
leaq 0x2df4(%rip), %rax      # 0x4080
movq $-0x1, (%rax,%rcx,8)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x1279
callq 0x1080
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movslq 0x18(%rsp), %rdx
movl 0x18(%rsp), %r10d
xorl %r9d, %r9d
leaq 0x2dbc(%rip), %rax      # 0x4080
movl %r9d, %ecx
movl %r9d, %r8d
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x10b0
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x1317
movl 0x1c(%rsp), %esi
movq 0x28(%rsp), %rax
movslq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0xd01(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x12e0
callq 0x1080
movq 0x28(%rsp), %rdi
callq 0x10a0
movq 0x20(%rsp), %rdi
callq 0x10a0
callq 0x1050
xorl %eax, %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/accre[P]Cprogramming/dynamically_allocated_arrays.c
// Function: main
int main(int argc, char **argv)
{

   // Sometimes you can't predict the size
   // of an array at compile time, or you need
   // to grow or shrink the size of an array.
   //
   // Dynamically allocated arrays are great
   // for either of these purposes
   if ( argc != 2 ) {
      printf("Usage: dynamically_allocated_arrays arraySize\n");
      exit(0);
   }

   int n = atoi(argv[1]);

   // initialize an allocatable array of size n
   // malloc reserves a block of memory for the array.
   //
   // malloc needs to know the number of bytes you'd
   // like to reserve, which you can get by muliplying
   // the desired size of the array times sizeof(type)
   int * myDynamicArray = malloc( n * sizeof(int) );
   // it's good practice to check that the array was
   // allocated correctly. Doing this by checking for
   // a NULL pointer.
   if ( myDynamicArray == NULL ) {
      printf("Allocation failed, exiting!\n");
      exit(0);
   }

   // fill and access your dynamic array like any
   // other "normal" array
   int i;
   for ( i=0; i<n ; i++ ) { 
      myDynamicArray[i] = i * 9;
      printf("i: %d, myDynamicArray[i]: %d\n",i,myDynamicArray[i]);
   }

   // the memory for dynamically allocated arrays must 
   // be manually released before a program terminates.
   // Failure to do so can lead to memory leaks.
   free(myDynamicArray);

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x11b1
leaq 0xe61(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
xorl %edi, %edi
callq 0x1070
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1060
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1050
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x11ee
leaq 0xe53(%rip), %rdi       # 0x2033
movb $0x0, %al
callq 0x1040
xorl %edi, %edi
callq 0x1070
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1233
imull $0x9, -0x24(%rbp), %edx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0xe2f(%rip), %rdi       # 0x2050
movb $0x0, %al
callq 0x1040
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x11f5
movq -0x20(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/fieldarith.c
// Function: check
void check(const bam1_t *aln, const char *testname, const char *tag, int value)
{
    int32_t refvalue;
    uint8_t *aux = bam_aux_get(aln, tag);
    if (!aux) return;
    ntests++;
    refvalue = bam_aux2i(aux);
    if (value != refvalue) {
        fprintf(stderr, "%s FAIL for %s: computed %d != %d expected\n",
                testname, bam_get_qname(aln), value, refvalue);
        nfailures++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a000
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5ad1
jmp 0x5b2f
movl 0x1031cd(%rip), %eax    # 0x108ca4
addl $0x1, %eax
movl %eax, 0x1031c4(%rip)    # 0x108ca4
movq -0x28(%rbp), %rdi
callq 0x2d250
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
je 0x5b2f
movq 0xfe4e5(%rip), %rax     # 0x103fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movl -0x1c(%rbp), %r8d
movl -0x20(%rbp), %r9d
leaq 0xe04eb(%rip), %rsi     # 0xe6004
movb $0x0, %al
callq 0x46c0
movl 0x103182(%rip), %eax    # 0x108ca8
addl $0x1, %eax
movl %eax, 0x103179(%rip)    # 0x108ca8
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/fieldarith.c
// Function: main
int main(int argc, char **argv)
{
    sam_hdr_t *header;
    bam1_t *aln = bam_init1();
    int i;

    for (i = 1; i < argc; i++) {
        samFile *in = sam_open(argv[i], "r");
        if (in == NULL) { perror(argv[1]); return 1; }

        header = sam_hdr_read(in);
        while (sam_read1(in, header, aln) >= 0) {
            check(aln, "cigar2qlen", "XQ",
                  bam_cigar2qlen(aln->core.n_cigar, bam_get_cigar(aln)));
            check(aln, "cigar2rlen", "XR",
                  bam_cigar2rlen(aln->core.n_cigar, bam_get_cigar(aln)));
            check(aln, "endpos", "XE", bam_endpos(aln));
        }

        sam_hdr_destroy(header);
        sam_close(in);
    }

    bam_destroy1(aln);

    return (nfailures > 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1e650
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x5ca8
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xe35ce(%rip), %rsi     # 0xe9153
callq 0x9a90
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5bae
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x43b0
movl $0x1, -0x4(%rbp)
jmp 0x5cc3
movq -0x30(%rbp), %rdi
callq 0x23170
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x282b0
cmpl $0x0, %eax
jl 0x5c88
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movl 0x14(%rax), %edi
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x20(%rbp), %rax
movzwl 0x12(%rax), %eax
cltq
addq %rax, %rsi
callq 0x1f1e0
movq -0x48(%rbp), %rdi
movl %eax, %ecx
leaq 0xe0425(%rip), %rsi     # 0xe6030
leaq 0xe0429(%rip), %rdx     # 0xe603b
callq 0x5aa0
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movl 0x14(%rax), %edi
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x20(%rbp), %rax
movzwl 0x12(%rax), %eax
cltq
addq %rax, %rsi
callq 0x1f250
movq -0x40(%rbp), %rdi
movl %eax, %ecx
leaq 0xe03f1(%rip), %rsi     # 0xe603e
leaq 0xe03f5(%rip), %rdx     # 0xe6049
callq 0x5aa0
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1f2c0
movq -0x38(%rbp), %rdi
movl %eax, %ecx
leaq 0xe03d5(%rip), %rsi     # 0xe604c
leaq 0xe03d5(%rip), %rdx     # 0xe6053
callq 0x5aa0
jmp 0x5bbb
movq -0x18(%rbp), %rdi
callq 0x1d710
movq -0x30(%rbp), %rdi
callq 0xbbb0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5b66
movq -0x20(%rbp), %rdi
callq 0x1e890
cmpl $0x0, 0x102ff0(%rip)    # 0x108ca8
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryuichiueda[P]glueutils/src/ignerr.c
// Function: usage
void usage(void){
	fputs("ignerr: ignore exit status\n", stderr);
	fputs("usage: ignerr <command> [args]\n", stderr);
	fputs("\nCopyright (C) 2021 Ryuichi Ueda\n", stderr);
	fputs("Released under the MIT License.\n", stderr);
	fputs("https://github.com/ryuichiueda/glueutils\n", stderr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x2e6d(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xe6f(%rip), %rdi       # 0x2004
callq 0x1030
movq 0x2e57(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xe75(%rip), %rdi       # 0x2020
callq 0x1030
movq 0x2e41(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xe7f(%rip), %rdi       # 0x2040
callq 0x1030
movq 0x2e2b(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xe8b(%rip), %rdi       # 0x2062
callq 0x1030
movq 0x2e15(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xe96(%rip), %rdi       # 0x2083
callq 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryuichiueda[P]glueutils/src/ignerr.c
// Function: main
int main(int argc, char * argv[])
{
	if(argc < 2){
		usage();
		exit(1);
	}

	int pid = fork();
	if(pid == 0)//child 
		return -execvp(argv[1], &argv[1]);

	waitpid(pid, NULL, 0);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x122b
callq 0x1180
movl $0x1, %edi
callq 0x1060
callq 0x1070
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1259
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1050
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x126e
movl -0x14(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/dns.c
// Function: domain_node_swap
void domain_node_swap( rbnode* n1, rbnode* n2 )
{
    dns_node node, *node1, *node2;
    
    node1 = (dns_node*)n1;
    node2 = (dns_node*)n2;
    
    strcpy( node.domain, node1->domain );
    strcpy( node.ip, node1->ip );
    
    strcpy( node1->domain, node2->domain );
    strcpy( node1->ip, node2->ip );
    
    strcpy( node2->domain, node.domain );
    strcpy( node2->ip, node.ip );
    
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
leaq -0x140(%rbp), %rdi
addq $0x20, %rdi
movq -0x148(%rbp), %rsi
addq $0x20, %rsi
callq 0x2060
leaq -0x140(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
movq -0x148(%rbp), %rsi
addq $0x120, %rsi            # imm = 0x120
callq 0x2060
movq -0x148(%rbp), %rdi
addq $0x20, %rdi
movq -0x150(%rbp), %rsi
addq $0x20, %rsi
callq 0x2060
movq -0x148(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
movq -0x150(%rbp), %rsi
addq $0x120, %rsi            # imm = 0x120
callq 0x2060
movq -0x150(%rbp), %rdi
addq $0x20, %rdi
leaq -0x140(%rbp), %rsi
addq $0x20, %rsi
callq 0x2060
movq -0x150(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
leaq -0x140(%rbp), %rsi
addq $0x120, %rsi            # imm = 0x120
callq 0x2060
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/dns.c
// Function: fill_binary_ip
void fill_binary_ip( unsigned char bin[], char* ip )
{
    char tmp[20];
    char *p, *p1;
    
    strcpy( tmp, ip );
    p1 = tmp;
    
    p = strchr( p1, '.' );
    p[0] = 0;
    bin[0] = atoi( p1 );
    p1 = p+1;
    
    p = strchr( p1, '.' );
    p[0] = 0;
    bin[1] = atoi( p1 );
    p1 = p+1;

    p = strchr( p1, '.' );
    p[0] = 0;
    bin[2] = atoi( p1 );
    p1 = p+1;
    
    bin[3] = atoi( p1 );
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2060
leaq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movl $0x2e, %esi
callq 0x2110
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x40(%rbp), %rdi
callq 0x22b0
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movl $0x2e, %esi
callq 0x2110
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x40(%rbp), %rdi
callq 0x22b0
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movl $0x2e, %esi
callq 0x2110
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x40(%rbp), %rdi
callq 0x22b0
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x22b0
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/dns.c
// Function: check_domain_char
int check_domain_char( char* domain, int len )
{
    int i;
    
    for( i = 0; i < len; i++ )
    {
        if( isalnum( domain[i] ) )
            continue;
        
        switch( domain[i] )
        {
            case '_':
            case '-':
                break;
            
               default:
                return -1;
        }
    }
    
    return 0;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x386b
callq 0x2310
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x3833
jmp 0x3860
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
subl $0x2d, %eax
je 0x3853
jmp 0x3849
movl -0x1c(%rbp), %eax
subl $0x5f, %eax
jne 0x3855
jmp 0x3853
jmp 0x385e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3872
jmp 0x3860
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3806
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: rbtree_init
void rbtree_init( rbtree* tree, rbtree_node_cmp node_cmp, rbtree_value_cmp value_cmp, rbtree_node_swap swap )
{

    tree->root = NULL;
    tree->count = 0;
    tree->node_cmp = node_cmp;
    tree->value_cmp = value_cmp;
    tree->node_swap = swap;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: binary_node_insert
int binary_node_insert( rbtree* tree, rbnode* node, rbnode* newnode )
{
    int cmp;
    
    cmp = tree->node_cmp( newnode, node );
    if( cmp == 0 )
        return RBTREE_ERR_EXIST;
    
    if( cmp < 0 )
    {
        if( node->left == NULL )
        {
            node->left = newnode;
            newnode->color = RED;
            newnode->left  = NULL;
            newnode->right = NULL;
            newnode->parent = node;
            tree->count++;
            return 0;
        }
        else
            return binary_node_insert( tree, node->left, newnode );
    }
    else
    {
        if( node->right == NULL )
        {
            node->right = newnode;
            newnode->color = RED;
            newnode->left = NULL;
            newnode->right = NULL;
            newnode->parent = node;
            tree->count++;
            return 0;
        }
        else
            return binary_node_insert( tree, node->right, newnode );
    }
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0xb31b
movl $0x1, -0x4(%rbp)
jmp 0xb40c
cmpl $0x0, -0x24(%rbp)
jge 0xb399
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xb37f
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xb40c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0xb2e0
movl %eax, -0x4(%rbp)
jmp 0xb40c
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xb3f4
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xb40c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0xb2e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: binary_find
static rbnode* binary_find( rbtree* tree, rbnode* node, void* val )
{
    int cmp;
    
    cmp = tree->value_cmp( val, node );
    
    if( cmp == 0 )
        return node;
    
    if( cmp < 0 )
    {
        if( node->left == NULL )
            return NULL;
        else
            return binary_find( tree, node->left, val );
    }
    else
    {
        if( node->right == NULL )
            return NULL;
        else
            return binary_find( tree, node->right, val );
    }
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0xb4a9
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb50d
cmpl $0x0, -0x24(%rbp)
jge 0xb4df
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xb4c4
movq $0x0, -0x8(%rbp)
jmp 0xb50d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0xb470
movq %rax, -0x8(%rbp)
jmp 0xb50d
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xb4f4
movq $0x0, -0x8(%rbp)
jmp 0xb50d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0xb470
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: rbtree_insert
int  rbtree_insert( rbtree* tree, rbnode* node )
{
    int rc;
    
    if( tree->root == NULL )
    {
        node->color = BLACK;
        node->left  = NULL;
        node->right = NULL;
        node->parent = NULL;
        tree->root = node;
        tree->count ++;
        return 0;
    }
    
    rc = binary_node_insert( tree, tree->root, node );
    if( rc )
        return rc;
    
    insert_case1( tree, node );
    
    return 0;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xb589
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xb5c2
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xb2e0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xb5ae
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb5c2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb5d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: rbtree_print
void rbtree_print( rbtree* tree, rbtree_proc_node print )
{
    
    if( tree->root == NULL )
    {
        printf( "rbtree empty!\n" );
        return ;
    }

    print_node( tree, tree->root, print );
    
    printf( "\n\n" );
    return;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xb63a
leaq 0x42a3(%rip), %rdi      # 0xf8d4
movb $0x0, %al
callq 0x2120
jmp 0xb65c
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0xb670
leaq 0x428e(%rip), %rdi      # 0xf8e3
movb $0x0, %al
callq 0x2120
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: print_node
static void print_node( rbtree* tree, rbnode* node, rbtree_proc_node print )
{
    print( node );
    if( node->left )
        print_node( tree, node->left, print );
    
    if( node->right )
        print_node( tree, node->right, print );

    
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xb6ae
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xb670
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xb6ce
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xb670
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: rbtree_verify
int  rbtree_verify( rbtree* tree )
{
    int rc;
    
    if( !tree->root )
        return 0;
    
    if( tree->root->color != BLACK )
    {
        printf( "root node is not black!\n" );
        return 1;
    }
    
    rc = rbtree_verify_rednode( tree->root );
    if( rc )
        return 1;
    
    rc = verify_node( tree->root );
    if( rc )
        return rc;
    return 0;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xb6ff
movl $0x0, -0x4(%rbp)
jmp 0xb764
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, (%rax)
je 0xb722
leaq 0x41d4(%rip), %rdi      # 0xf8e6
movb $0x0, %al
callq 0x2120
movl $0x1, -0x4(%rbp)
jmp 0xb764
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xb770
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xb740
movl $0x1, -0x4(%rbp)
jmp 0xb764
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xb860
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xb75d
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb764
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: rbtree_verify_rednode
int rbtree_verify_rednode( rbnode* n )
{
    int rc;
    
    if( n->color == RED )
    {
        if(( n->left ) && n->left->color != BLACK  )
        {
            printf( "red node %p child is red!\n", n );
            return 1;
        }
            
        if(( n->right ) && n->right->color != BLACK  )
        {
            printf( "red node %p child is red!\n", n );
            return 1;
        }
    }
    
    
    if( n->left )
    {
        rc = rbtree_verify_rednode( n->left );
        if( rc ) 
            return rc;
    }
     
    if( n->right )
    {
        rc = rbtree_verify_rednode( n->right );
        if( rc )
            return rc;
    }
    
    return 0;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xb7f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xb7bb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x2, (%rax)
je 0xb7bb
movq -0x10(%rbp), %rsi
leaq 0x42f8(%rip), %rdi      # 0xfaa0
movb $0x0, %al
callq 0x2120
movl $0x1, -0x4(%rbp)
jmp 0xb84d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xb7ee
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
je 0xb7ee
movq -0x10(%rbp), %rsi
leaq 0x42c2(%rip), %rdi      # 0xfaa0
movb $0x0, %al
callq 0x2120
movl $0x1, -0x4(%rbp)
jmp 0xb84d
jmp 0xb7f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xb81b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xb770
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xb819
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb84d
jmp 0xb81b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xb846
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb770
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xb844
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb84d
jmp 0xb846
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: verify_node
int verify_node( rbnode* n )
{
    int cnt;
    int find = 0;
    int rc;
    
    cnt = rbtree_path_black_count( n );
    rc = node_black_walk( n, find, cnt );
    if( rc )
        return 1;

    if( n->left )
    {
        rc = verify_node( n->left );
        if( rc )
            return rc;
    }
    
    if( n->right )
    {
        rc = verify_node( n->right );
        if( rc )
            return rc;
            
    }
    
        
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc4e0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0xc520
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xb8a0
movl $0x1, -0x4(%rbp)
jmp 0xb8fd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xb8cb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xb860
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xb8c9
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb8fd
jmp 0xb8cb
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xb8f6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb860
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xb8f4
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb8fd
jmp 0xb8f6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: delete_one_child
void delete_one_child( rbtree* tree, rbnode *n)
{
        rbnode *child = n->left != NULL ? n->left : n->right;
        
        if(n->color == BLACK){
                n->color = node_color( child );
                delete_case1 ( tree, n );
        }
        replace_child( tree, n, child);
        
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xb939
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xb945
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xb974
movq -0x18(%rbp), %rdi
callq 0xb990
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb9c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xb9f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: replace_child
static void replace_child( rbtree* tree, rbnode* n, rbnode* child )
{
    rbnode* parent;
    
    parent = n->parent;
    if( child )
        child->parent = parent;
    
    if( parent )
    {
        if( parent->left == n )
            parent->left = child;
        else
            parent->right = child;
    }
    else
    {
        tree->root = child;
        if( child )
            child->color = BLACK;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xba1f
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
cmpq $0x0, -0x20(%rbp)
je 0xba50
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xba42
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xba4e
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xba6e
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0xba6c
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
jmp 0xba6e
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: rbtree_delete
rbnode* rbtree_delete( rbtree* tree, void* val )
{
    rbnode* node;
    rbnode* min;
    
    if( tree->root == NULL )
        return NULL;
    
    node = rbtree_find( tree, val );
    if( node == NULL )
        return NULL;
    
    
    if( node->left && node->right )
    {
        min = find_subtree_min( node->right );
        tree->node_swap( node, min );
        node = min;
    }
    
    delete_one_child( tree, node );
    tree->count --;
    
    return node;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xba97
movq $0x0, -0x8(%rbp)
jmp 0xbb1c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb420
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xbab9
movq $0x0, -0x8(%rbp)
jmp 0xbb1c
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xbafa
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xbafa
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xbb30
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq *%rax
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb910
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bloomsource[P]dns_update/rbtree.c
// Function: rbtree_walk
void rbtree_walk( rbtree* tree, int order, rbtree_proc_node cb )
{
    switch( order )
    {
        case RBTREE_WALK_PRE_ORDER:
        case RBTREE_WALK_IN_ORDER:
        case RBTREE_WALK_POST_ORDER:
            break;
        
        default:
            order = RBTREE_WALK_IN_ORDER;
    }

    node_walk( tree->root, order, cb );
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
decl %eax
subl $0x2, %eax
ja 0xbb81
jmp 0xbb7f
jmp 0xbb88
movl $0x2, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0xbbb0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)