LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_encode_attribute_v2_protect_stop_date
int
test_encode_attribute_v2_protect_stop_date(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    /* This encoding matches the following values:
    *  Protect Stop Date - 1335514945 (Fri Apr 27 10:22:25 CEST 2012)
    */
    uint8 expected[16] = {
        0x42, 0x00, 0x68, 0x09, 0x00, 0x00, 0x00, 0x08,
        0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x57, 0x41
    };

    uint8 observed[16] = {0};
    KMIP ctx = {0};
    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0);

    int64 date_time = 1335514945;

    Attribute attribute = {0};
    kmip_init_attribute(&attribute);

    attribute.type = KMIP_ATTR_PROTECT_STOP_DATE;
    attribute.value = &date_time;

    int result = kmip_encode_attribute_v2(&ctx, &attribute);
    result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__);

    kmip_destroy(&ctx);

    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8f0, %rsp            # imm = 0x8F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x33edc(%rip), %rax     # 0x47240
movq %rax, -0x20(%rbp)
movq 0x33ed9(%rip), %rax     # 0x47248
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8c8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x30(%rbp), %rsi
leaq -0x8c8(%rbp), %rdi
movl $0x10, %edx
movl $0x5, %ecx
callq 0x1c6e0
movq $0x4f9a5741, -0x8d0(%rbp) # imm = 0x4F9A5741
leaq -0x8e0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8e0(%rbp), %rdi
callq 0x1d330
movl $0xd, -0x8e0(%rbp)
leaq -0x8d0(%rbp), %rax
movq %rax, -0x8d8(%rbp)
leaq -0x8c8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x26690
movl %eax, -0x8e4(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movl -0x8e4(%rbp), %r8d
leaq -0x8c8(%rbp), %rsi
leaq 0x2d669(%rip), %r9      # 0x40a95
callq 0x11f0
movl %eax, -0x8e4(%rbp)
leaq -0x8c8(%rbp), %rdi
callq 0x1cab0
movl -0x8e4(%rbp), %eax
addq $0x8f0, %rsp            # imm = 0x8F0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_encode_attribute_v2_cryptographic_parameters
int
test_encode_attribute_v2_cryptographic_parameters(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    /* This encoding matches the following values:
    *  Cryptographic Parameters
    *      Block Cipher Mode - CBC
    *      Padding Method - PKCS5
    *      Hashing Algorithm - SHA-1
    */
    uint8 expected[56] = {
        0x42, 0x00, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x30,
        0x42, 0x00, 0x11, 0x05, 0x00, 0x00, 0x00, 0x04,
        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
        0x42, 0x00, 0x5F, 0x05, 0x00, 0x00, 0x00, 0x04,
        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
        0x42, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x04,
        0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00
    };

    uint8 observed[56] = {0};
    KMIP ctx = {0};
    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_2_0);

    CryptographicParameters value = {0};
    kmip_init_cryptographic_parameters(&value);
    value.block_cipher_mode = KMIP_BLOCK_CBC;
    value.padding_method = KMIP_PAD_PKCS5;
    value.hashing_algorithm = KMIP_HASH_SHA1;

    Attribute attr = {0};
    kmip_init_attribute(&attr);

    attr.type = KMIP_ATTR_CRYPTOGRAPHIC_PARAMETERS;
    attr.value = &value;

    int result = kmip_encode_attribute_v2(&ctx, &attr);
    result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__);

    kmip_destroy(&ctx);

    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x980, %rsp            # imm = 0x980
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
leaq -0x40(%rbp), %rdi
leaq 0x32248(%rip), %rsi     # 0x456d0
movl $0x38, %edx
callq 0x10c0
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x1090
leaq -0x918(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x80(%rbp), %rsi
leaq -0x918(%rbp), %rdi
movl $0x38, %edx
movl $0x5, %ecx
callq 0x1c6e0
leaq -0x968(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x1090
leaq -0x968(%rbp), %rdi
callq 0x1d370
movl $0x1, -0x968(%rbp)
movl $0x3, -0x964(%rbp)
movl $0x4, -0x960(%rbp)
leaq -0x978(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x978(%rbp), %rdi
callq 0x1d330
movl $0xe, -0x978(%rbp)
leaq -0x968(%rbp), %rax
movq %rax, -0x970(%rbp)
leaq -0x918(%rbp), %rdi
leaq -0x978(%rbp), %rsi
callq 0x26690
movl %eax, -0x97c(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rdx
leaq -0x80(%rbp), %rcx
movl -0x97c(%rbp), %r8d
leaq -0x918(%rbp), %rsi
leaq 0x2d543(%rip), %r9      # 0x40ac0
callq 0x11f0
movl %eax, -0x97c(%rbp)
leaq -0x918(%rbp), %rdi
callq 0x1cab0
movl -0x97c(%rbp), %eax
addq $0x980, %rsp            # imm = 0x980
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_encode_attribute_v2_unsupported_attribute
int
test_encode_attribute_v2_unsupported_attribute(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    uint8 encoding[16] = {0};

    KMIP ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);

    Attribute attribute = {0};
    attribute.type = -1;
    int result = kmip_encode_attribute_v2(&ctx, &attribute);
    if(result != KMIP_ERROR_ATTR_UNSUPPORTED)
    {
        TEST_FAILED(tracker, __func__, __LINE__);
    }

    kmip_destroy(&ctx);

    TEST_PASSED(tracker, __func__);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8d0, %rsp            # imm = 0x8D0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8b8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x20(%rbp), %rsi
leaq -0x8b8(%rbp), %rdi
movl $0x10, %edx
movl $0x5, %ecx
callq 0x1c6e0
leaq -0x8c8(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
movl $0xffffffff, -0x8c8(%rbp) # imm = 0xFFFFFFFF
leaq -0x8b8(%rbp), %rdi
leaq -0x8c8(%rbp), %rsi
callq 0x26690
movl %eax, -0x8cc(%rbp)
cmpl $-0x3, -0x8cc(%rbp)
je 0x1367e
jmp 0x1364b
leaq 0x2ba63(%rip), %rdi     # 0x3f0b5
leaq 0x2d499(%rip), %rsi     # 0x40af2
movl $0x23fb, %edx           # imm = 0x23FB
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rax
movw 0x2(%rax), %cx
addw $0x1, %cx
movw %cx, 0x2(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x136b6
leaq -0x8b8(%rbp), %rdi
callq 0x1cab0
leaq 0x2b9ba(%rip), %rdi     # 0x3f04b
leaq 0x2d45a(%rip), %rsi     # 0x40af2
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rax
movw 0x4(%rax), %cx
addw $0x1, %cx
movw %cx, 0x4(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x8d0, %rsp            # imm = 0x8D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_decode_attributes_with_invalid_kmip_version
int
test_decode_attributes_with_invalid_kmip_version(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    uint8 encoding[] = {0};

    KMIP ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_4);

    Attributes observed = {0};
    int result = kmip_decode_attributes(&ctx, &observed);

    kmip_free_attributes(&ctx, &observed);
    kmip_destroy(&ctx);

    result = report_result(tracker, result, KMIP_INVALID_FOR_VERSION, __func__);
    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8c0, %rsp            # imm = 0x8C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
leaq -0x9(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x1090
leaq -0x8a8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x9(%rbp), %rsi
leaq -0x8a8(%rbp), %rdi
movl $0x1, %edx
movl $0x4, %ecx
callq 0x1c6e0
leaq -0x8b0(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x1090
leaq -0x8a8(%rbp), %rdi
leaq -0x8b0(%rbp), %rsi
callq 0x2f100
movl %eax, -0x8b4(%rbp)
leaq -0x8a8(%rbp), %rdi
leaq -0x8b0(%rbp), %rsi
callq 0x1db80
leaq -0x8a8(%rbp), %rdi
callq 0x1cab0
movq -0x8(%rbp), %rdi
movl -0x8b4(%rbp), %esi
movl $0xfffffff5, %edx       # imm = 0xFFFFFFF5
leaq 0x2d14d(%rip), %rcx     # 0x40b38
callq 0x1490
movl %eax, -0x8b4(%rbp)
movl -0x8b4(%rbp), %eax
addq $0x8c0, %rsp            # imm = 0x8C0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_decode_attribute_v2_object_type
int
test_decode_attribute_v2_object_type(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    /* This encoding matches the following value:
    *  Object Type - Symmetric Key
    */
    uint8 encoding[16] = {
        0x42, 0x00, 0x57, 0x05, 0x00, 0x00, 0x00, 0x04,
        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00
    };

    KMIP ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);

    Attribute expected = {0};
    kmip_init_attribute(&expected);
    enum object_type object_type = KMIP_OBJTYPE_SYMMETRIC_KEY;
    expected.type = KMIP_ATTR_OBJECT_TYPE;
    expected.value = &object_type;

    Attribute observed = {0};
    int result = kmip_decode_attribute_v2(&ctx, &observed);
    int comparison = kmip_compare_attribute(&expected, &observed);
    if(!comparison)
    {
        kmip_print_attribute(stderr, 1, &expected);
        kmip_print_attribute(stderr, 1, &observed);
    }
    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);

    kmip_free_attribute(&ctx, &observed);
    kmip_destroy(&ctx);

    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8f0, %rsp            # imm = 0x8F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x32fec(%rip), %rax     # 0x471c0
movq %rax, -0x20(%rbp)
movq 0x32fe9(%rip), %rax     # 0x471c8
movq %rax, -0x18(%rbp)
leaq -0x8b8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x20(%rbp), %rsi
leaq -0x8b8(%rbp), %rdi
movl $0x10, %edx
movl $0x5, %ecx
callq 0x1c6e0
leaq -0x8c8(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8c8(%rbp), %rdi
callq 0x1d330
movl $0x2, -0x8cc(%rbp)
movl $0x2, -0x8c8(%rbp)
leaq -0x8cc(%rbp), %rax
movq %rax, -0x8c0(%rbp)
leaq -0x8e0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8b8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x2e350
movl %eax, -0x8e4(%rbp)
leaq -0x8c8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x20f80
movl %eax, -0x8e8(%rbp)
cmpl $0x0, -0x8e8(%rbp)
jne 0x142d5
movq 0x3fd52(%rip), %rax     # 0x53ff8
movq (%rax), %rdi
movl $0x1, %esi
leaq -0x8c8(%rbp), %rdx
callq 0x3c210
movq 0x3fd37(%rip), %rax     # 0x53ff8
movq (%rax), %rdi
movl $0x1, %esi
leaq -0x8e0(%rbp), %rdx
callq 0x3c210
movq -0x8(%rbp), %rdi
movl -0x8e8(%rbp), %edx
movl -0x8e4(%rbp), %ecx
leaq -0x8b8(%rbp), %rsi
leaq 0x2c944(%rip), %r8      # 0x40c37
callq 0x13a0
movl %eax, -0x8e4(%rbp)
leaq -0x8b8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x1d8e0
leaq -0x8b8(%rbp), %rdi
callq 0x1cab0
movl -0x8e4(%rbp), %eax
addq $0x8f0, %rsp            # imm = 0x8F0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_decode_attribute_v2_cryptographic_algorithm
int
test_decode_attribute_v2_cryptographic_algorithm(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    /* This encoding matches the following value:
    *  Cryptographic Algorithm - AES
    */
    uint8 encoding[16] = {
        0x42, 0x00, 0x28, 0x05, 0x00, 0x00, 0x00, 0x04,
        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00
    };

    KMIP ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);

    Attribute expected = {0};
    kmip_init_attribute(&expected);
    enum cryptographic_algorithm algorithm = KMIP_CRYPTOALG_AES;
    expected.type = KMIP_ATTR_CRYPTOGRAPHIC_ALGORITHM;
    expected.value = &algorithm;

    Attribute observed = {0};
    int result = kmip_decode_attribute_v2(&ctx, &observed);
    int comparison = kmip_compare_attribute(&expected, &observed);
    if(!comparison)
    {
        kmip_print_attribute(stderr, 1, &expected);
        kmip_print_attribute(stderr, 1, &observed);
    }
    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);

    kmip_free_attribute(&ctx, &observed);
    kmip_destroy(&ctx);

    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8f0, %rsp            # imm = 0x8F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x32e7c(%rip), %rax     # 0x471d0
movq %rax, -0x20(%rbp)
movq 0x32e79(%rip), %rax     # 0x471d8
movq %rax, -0x18(%rbp)
leaq -0x8b8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x20(%rbp), %rsi
leaq -0x8b8(%rbp), %rdi
movl $0x10, %edx
movl $0x5, %ecx
callq 0x1c6e0
leaq -0x8c8(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8c8(%rbp), %rdi
callq 0x1d330
movl $0x3, -0x8cc(%rbp)
movl $0x3, -0x8c8(%rbp)
leaq -0x8cc(%rbp), %rax
movq %rax, -0x8c0(%rbp)
leaq -0x8e0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8b8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x2e350
movl %eax, -0x8e4(%rbp)
leaq -0x8c8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x20f80
movl %eax, -0x8e8(%rbp)
cmpl $0x0, -0x8e8(%rbp)
jne 0x14455
movq 0x3fbd2(%rip), %rax     # 0x53ff8
movq (%rax), %rdi
movl $0x1, %esi
leaq -0x8c8(%rbp), %rdx
callq 0x3c210
movq 0x3fbb7(%rip), %rax     # 0x53ff8
movq (%rax), %rdi
movl $0x1, %esi
leaq -0x8e0(%rbp), %rdx
callq 0x3c210
movq -0x8(%rbp), %rdi
movl -0x8e8(%rbp), %edx
movl -0x8e4(%rbp), %ecx
leaq -0x8b8(%rbp), %rsi
leaq 0x2c7e9(%rip), %r8      # 0x40c5c
callq 0x13a0
movl %eax, -0x8e4(%rbp)
leaq -0x8b8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x1d8e0
leaq -0x8b8(%rbp), %rdi
callq 0x1cab0
movl -0x8e4(%rbp), %eax
addq $0x8f0, %rsp            # imm = 0x8F0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_decode_attribute_v2_cryptographic_length
int
test_decode_attribute_v2_cryptographic_length(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    /* This encoding matches the following value:
    *  Cryptographic Length - 128
    */
    uint8 encoding[16] = {
        0x42, 0x00, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x04,
        0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00
    };

    KMIP ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);

    Attribute expected = {0};
    kmip_init_attribute(&expected);
    int32 length = 128;
    expected.type = KMIP_ATTR_CRYPTOGRAPHIC_LENGTH;
    expected.value = &length;

    Attribute observed = {0};
    int result = kmip_decode_attribute_v2(&ctx, &observed);
    int comparison = kmip_compare_attribute(&expected, &observed);
    if(!comparison)
    {
        kmip_print_attribute(stderr, 1, &expected);
        kmip_print_attribute(stderr, 1, &observed);
    }
    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);

    kmip_free_attribute(&ctx, &observed);
    kmip_destroy(&ctx);

    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8f0, %rsp            # imm = 0x8F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x32d0c(%rip), %rax     # 0x471e0
movq %rax, -0x20(%rbp)
movq 0x32d09(%rip), %rax     # 0x471e8
movq %rax, -0x18(%rbp)
leaq -0x8b8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x20(%rbp), %rsi
leaq -0x8b8(%rbp), %rdi
movl $0x10, %edx
movl $0x5, %ecx
callq 0x1c6e0
leaq -0x8c8(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8c8(%rbp), %rdi
callq 0x1d330
movl $0x80, -0x8cc(%rbp)
movl $0x4, -0x8c8(%rbp)
leaq -0x8cc(%rbp), %rax
movq %rax, -0x8c0(%rbp)
leaq -0x8e0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8b8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x2e350
movl %eax, -0x8e4(%rbp)
leaq -0x8c8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x20f80
movl %eax, -0x8e8(%rbp)
cmpl $0x0, -0x8e8(%rbp)
jne 0x145d5
movq 0x3fa52(%rip), %rax     # 0x53ff8
movq (%rax), %rdi
movl $0x1, %esi
leaq -0x8c8(%rbp), %rdx
callq 0x3c210
movq 0x3fa37(%rip), %rax     # 0x53ff8
movq (%rax), %rdi
movl $0x1, %esi
leaq -0x8e0(%rbp), %rdx
callq 0x3c210
movq -0x8(%rbp), %rdi
movl -0x8e8(%rbp), %edx
movl -0x8e4(%rbp), %ecx
leaq -0x8b8(%rbp), %rsi
leaq 0x2c69a(%rip), %r8      # 0x40c8d
callq 0x13a0
movl %eax, -0x8e4(%rbp)
leaq -0x8b8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x1d8e0
leaq -0x8b8(%rbp), %rdi
callq 0x1cab0
movl -0x8e4(%rbp), %eax
addq $0x8f0, %rsp            # imm = 0x8F0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_decode_attribute_v2_cryptographic_usage_mask
int
test_decode_attribute_v2_cryptographic_usage_mask(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    /* This encoding matches the following value:
    *  Cryptographic Usage Mask - Encrypt | Decrypt
    */
    uint8 encoding[16] = {
        0x42, 0x00, 0x2C, 0x02, 0x00, 0x00, 0x00, 0x04,
        0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00
    };

    KMIP ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);

    Attribute expected = {0};
    kmip_init_attribute(&expected);
    int32 mask = KMIP_CRYPTOMASK_ENCRYPT | KMIP_CRYPTOMASK_DECRYPT;
    expected.type = KMIP_ATTR_CRYPTOGRAPHIC_USAGE_MASK;
    expected.value = &mask;

    Attribute observed = {0};
    int result = kmip_decode_attribute_v2(&ctx, &observed);
    int comparison = kmip_compare_attribute(&expected, &observed);
    if(!comparison)
    {
        kmip_print_attribute(stderr, 1, &expected);
        kmip_print_attribute(stderr, 1, &observed);
    }
    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);

    kmip_free_attribute(&ctx, &observed);
    kmip_destroy(&ctx);

    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8f0, %rsp            # imm = 0x8F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x32b9c(%rip), %rax     # 0x471f0
movq %rax, -0x20(%rbp)
movq 0x32b99(%rip), %rax     # 0x471f8
movq %rax, -0x18(%rbp)
leaq -0x8b8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x20(%rbp), %rsi
leaq -0x8b8(%rbp), %rdi
movl $0x10, %edx
movl $0x5, %ecx
callq 0x1c6e0
leaq -0x8c8(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8c8(%rbp), %rdi
callq 0x1d330
movl $0xc, -0x8cc(%rbp)
movl $0x6, -0x8c8(%rbp)
leaq -0x8cc(%rbp), %rax
movq %rax, -0x8c0(%rbp)
leaq -0x8e0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8b8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x2e350
movl %eax, -0x8e4(%rbp)
leaq -0x8c8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x20f80
movl %eax, -0x8e8(%rbp)
cmpl $0x0, -0x8e8(%rbp)
jne 0x14755
movq 0x3f8d2(%rip), %rax     # 0x53ff8
movq (%rax), %rdi
movl $0x1, %esi
leaq -0x8c8(%rbp), %rdx
callq 0x3c210
movq 0x3f8b7(%rip), %rax     # 0x53ff8
movq (%rax), %rdi
movl $0x1, %esi
leaq -0x8e0(%rbp), %rdx
callq 0x3c210
movq -0x8(%rbp), %rdi
movl -0x8e8(%rbp), %edx
movl -0x8e4(%rbp), %ecx
leaq -0x8b8(%rbp), %rsi
leaq 0x2c548(%rip), %r8      # 0x40cbb
callq 0x13a0
movl %eax, -0x8e4(%rbp)
leaq -0x8b8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x1d8e0
leaq -0x8b8(%rbp), %rdi
callq 0x1cab0
movl -0x8e4(%rbp), %eax
addq $0x8f0, %rsp            # imm = 0x8F0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_decode_attribute_v2_state
int
test_decode_attribute_v2_state(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    /* This encoding matches the following value:
    *  State - Active
    */
    uint8 encoding[16] = {
        0x42, 0x00, 0x8D, 0x05, 0x00, 0x00, 0x00, 0x04,
        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00
    };

    KMIP ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);

    Attribute expected = {0};
    kmip_init_attribute(&expected);
    enum state state = KMIP_STATE_ACTIVE;
    expected.type = KMIP_ATTR_STATE;
    expected.value = &state;

    Attribute observed = {0};
    int result = kmip_decode_attribute_v2(&ctx, &observed);
    int comparison = kmip_compare_attribute(&expected, &observed);
    if(!comparison)
    {
        kmip_print_attribute(stderr, 1, &expected);
        kmip_print_attribute(stderr, 1, &observed);
    }
    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);

    kmip_free_attribute(&ctx, &observed);
    kmip_destroy(&ctx);

    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8f0, %rsp            # imm = 0x8F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x32a2c(%rip), %rax     # 0x47200
movq %rax, -0x20(%rbp)
movq 0x32a29(%rip), %rax     # 0x47208
movq %rax, -0x18(%rbp)
leaq -0x8b8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x20(%rbp), %rsi
leaq -0x8b8(%rbp), %rdi
movl $0x10, %edx
movl $0x5, %ecx
callq 0x1c6e0
leaq -0x8c8(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8c8(%rbp), %rdi
callq 0x1d330
movl $0x2, -0x8cc(%rbp)
movl $0x7, -0x8c8(%rbp)
leaq -0x8cc(%rbp), %rax
movq %rax, -0x8c0(%rbp)
leaq -0x8e0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8b8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x2e350
movl %eax, -0x8e4(%rbp)
leaq -0x8c8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x20f80
movl %eax, -0x8e8(%rbp)
cmpl $0x0, -0x8e8(%rbp)
jne 0x148d5
movq 0x3f752(%rip), %rax     # 0x53ff8
movq (%rax), %rdi
movl $0x1, %esi
leaq -0x8c8(%rbp), %rdx
callq 0x3c210
movq 0x3f737(%rip), %rax     # 0x53ff8
movq (%rax), %rdi
movl $0x1, %esi
leaq -0x8e0(%rbp), %rdx
callq 0x3c210
movq -0x8(%rbp), %rdi
movl -0x8e8(%rbp), %edx
movl -0x8e4(%rbp), %ecx
leaq -0x8b8(%rbp), %rsi
leaq 0x2c3fa(%rip), %r8      # 0x40ced
callq 0x13a0
movl %eax, -0x8e4(%rbp)
leaq -0x8b8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x1d8e0
leaq -0x8b8(%rbp), %rdi
callq 0x1cab0
movl -0x8e4(%rbp), %eax
addq $0x8f0, %rsp            # imm = 0x8F0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_decode_attribute_v2_activation_date
int
test_decode_attribute_v2_activation_date(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    /* This encoding matches the following values:
    *  Activation Date - 2 (Thu Jan 01 01:00:02 UST 1970)
    */
    uint8 encoding[16] = {
        0x42, 0x00, 0x01, 0x09, 0x00, 0x00, 0x00, 0x08,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02
    };

    KMIP ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);

    int64 date_time = 2;

    Attribute expected = {0};
    kmip_init_attribute(&expected);

    expected.type = KMIP_ATTR_ACTIVATION_DATE;
    expected.value = &date_time;

    Attribute observed = {0};
    int result = kmip_decode_attribute_v2(&ctx, &observed);
    int comparison = kmip_compare_attribute(&expected, &observed);
    if(!comparison)
    {
        kmip_print_attribute(stderr, 1, &expected);
        kmip_print_attribute(stderr, 1, &observed);
    }
    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);

    kmip_free_attribute(&ctx, &observed);
    kmip_destroy(&ctx);

    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8f0, %rsp            # imm = 0x8F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x326fc(%rip), %rax     # 0x47210
movq %rax, -0x20(%rbp)
movq 0x326f9(%rip), %rax     # 0x47218
movq %rax, -0x18(%rbp)
leaq -0x8b8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x20(%rbp), %rsi
leaq -0x8b8(%rbp), %rdi
movl $0x10, %edx
movl $0x5, %ecx
callq 0x1c6e0
movq $0x2, -0x8c0(%rbp)
leaq -0x8d0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8d0(%rbp), %rdi
callq 0x1d330
movl $0xa, -0x8d0(%rbp)
leaq -0x8c0(%rbp), %rax
movq %rax, -0x8c8(%rbp)
leaq -0x8e0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8b8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x2e350
movl %eax, -0x8e4(%rbp)
leaq -0x8d0(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x20f80
movl %eax, -0x8e8(%rbp)
cmpl $0x0, -0x8e8(%rbp)
jne 0x14c16
movq 0x3f411(%rip), %rax     # 0x53ff8
movq (%rax), %rdi
movl $0x1, %esi
leaq -0x8d0(%rbp), %rdx
callq 0x3c210
movq 0x3f3f6(%rip), %rax     # 0x53ff8
movq (%rax), %rdi
movl $0x1, %esi
leaq -0x8e0(%rbp), %rdx
callq 0x3c210
movq -0x8(%rbp), %rdi
movl -0x8e8(%rbp), %edx
movl -0x8e4(%rbp), %ecx
leaq -0x8b8(%rbp), %rsi
leaq 0x2c0fe(%rip), %r8      # 0x40d32
callq 0x13a0
movl %eax, -0x8e4(%rbp)
leaq -0x8b8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x1d8e0
leaq -0x8b8(%rbp), %rdi
callq 0x1cab0
movl -0x8e4(%rbp), %eax
addq $0x8f0, %rsp            # imm = 0x8F0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_decode_attribute_v2_deactivation_date
int
test_decode_attribute_v2_deactivation_date(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    /* This encoding matches the following values:
    *  Deactivation Date - 1335514467 (Fri Apr 27 10:14:27 CEST 2012)
    */
    uint8 encoding[16] = {
        0x42, 0x00, 0x2F, 0x09, 0x00, 0x00, 0x00, 0x08,
        0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x55, 0x63
    };

    KMIP ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);

    int64 date_time = 1335514467;

    Attribute expected = {0};
    kmip_init_attribute(&expected);

    expected.type = KMIP_ATTR_DEACTIVATION_DATE;
    expected.value = &date_time;

    Attribute observed = {0};
    int result = kmip_decode_attribute_v2(&ctx, &observed);
    int comparison = kmip_compare_attribute(&expected, &observed);
    if(!comparison)
    {
        kmip_print_attribute(stderr, 1, &expected);
        kmip_print_attribute(stderr, 1, &observed);
    }
    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);

    kmip_free_attribute(&ctx, &observed);
    kmip_destroy(&ctx);

    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8f0, %rsp            # imm = 0x8F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x3258c(%rip), %rax     # 0x47220
movq %rax, -0x20(%rbp)
movq 0x32589(%rip), %rax     # 0x47228
movq %rax, -0x18(%rbp)
leaq -0x8b8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x20(%rbp), %rsi
leaq -0x8b8(%rbp), %rdi
movl $0x10, %edx
movl $0x5, %ecx
callq 0x1c6e0
movq $0x4f9a5563, -0x8c0(%rbp) # imm = 0x4F9A5563
leaq -0x8d0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8d0(%rbp), %rdi
callq 0x1d330
movl $0xb, -0x8d0(%rbp)
leaq -0x8c0(%rbp), %rax
movq %rax, -0x8c8(%rbp)
leaq -0x8e0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8b8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x2e350
movl %eax, -0x8e4(%rbp)
leaq -0x8d0(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x20f80
movl %eax, -0x8e8(%rbp)
cmpl $0x0, -0x8e8(%rbp)
jne 0x14d96
movq 0x3f291(%rip), %rax     # 0x53ff8
movq (%rax), %rdi
movl $0x1, %esi
leaq -0x8d0(%rbp), %rdx
callq 0x3c210
movq 0x3f276(%rip), %rax     # 0x53ff8
movq (%rax), %rdi
movl $0x1, %esi
leaq -0x8e0(%rbp), %rdx
callq 0x3c210
movq -0x8(%rbp), %rdi
movl -0x8e8(%rbp), %edx
movl -0x8e4(%rbp), %ecx
leaq -0x8b8(%rbp), %rsi
leaq 0x2bfa7(%rip), %r8      # 0x40d5b
callq 0x13a0
movl %eax, -0x8e4(%rbp)
leaq -0x8b8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x1d8e0
leaq -0x8b8(%rbp), %rdi
callq 0x1cab0
movl -0x8e4(%rbp), %eax
addq $0x8f0, %rsp            # imm = 0x8F0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_decode_attribute_v2_process_start_date
int
test_decode_attribute_v2_process_start_date(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    /* This encoding matches the following values:
    *  Process Start Date - 1136113200 (Sun Jan 01 12:00:00 CET 2006)
    */
    uint8 encoding[16] = {
        0x42, 0x00, 0x67, 0x09, 0x00, 0x00, 0x00, 0x08,
        0x00, 0x00, 0x00, 0x00, 0x43, 0xB7, 0xB6, 0x30
    };

    KMIP ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);

    int64 date_time = 1136113200;

    Attribute expected = {0};
    kmip_init_attribute(&expected);

    expected.type = KMIP_ATTR_PROCESS_START_DATE;
    expected.value = &date_time;

    Attribute observed = {0};
    int result = kmip_decode_attribute_v2(&ctx, &observed);
    int comparison = kmip_compare_attribute(&expected, &observed);
    if(!comparison)
    {
        kmip_print_attribute(stderr, 1, &expected);
        kmip_print_attribute(stderr, 1, &observed);
    }
    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);

    kmip_free_attribute(&ctx, &observed);
    kmip_destroy(&ctx);

    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8f0, %rsp            # imm = 0x8F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x3241c(%rip), %rax     # 0x47230
movq %rax, -0x20(%rbp)
movq 0x32419(%rip), %rax     # 0x47238
movq %rax, -0x18(%rbp)
leaq -0x8b8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x20(%rbp), %rsi
leaq -0x8b8(%rbp), %rdi
movl $0x10, %edx
movl $0x5, %ecx
callq 0x1c6e0
movq $0x43b7b630, -0x8c0(%rbp) # imm = 0x43B7B630
leaq -0x8d0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8d0(%rbp), %rdi
callq 0x1d330
movl $0xc, -0x8d0(%rbp)
leaq -0x8c0(%rbp), %rax
movq %rax, -0x8c8(%rbp)
leaq -0x8e0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8b8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x2e350
movl %eax, -0x8e4(%rbp)
leaq -0x8d0(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x20f80
movl %eax, -0x8e8(%rbp)
cmpl $0x0, -0x8e8(%rbp)
jne 0x14f16
movq 0x3f111(%rip), %rax     # 0x53ff8
movq (%rax), %rdi
movl $0x1, %esi
leaq -0x8d0(%rbp), %rdx
callq 0x3c210
movq 0x3f0f6(%rip), %rax     # 0x53ff8
movq (%rax), %rdi
movl $0x1, %esi
leaq -0x8e0(%rbp), %rdx
callq 0x3c210
movq -0x8(%rbp), %rdi
movl -0x8e8(%rbp), %edx
movl -0x8e4(%rbp), %ecx
leaq -0x8b8(%rbp), %rsi
leaq 0x2be52(%rip), %r8      # 0x40d86
callq 0x13a0
movl %eax, -0x8e4(%rbp)
leaq -0x8b8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x1d8e0
leaq -0x8b8(%rbp), %rdi
callq 0x1cab0
movl -0x8e4(%rbp), %eax
addq $0x8f0, %rsp            # imm = 0x8F0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_decode_attribute_v2_protect_stop_date
int
test_decode_attribute_v2_protect_stop_date(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    /* This encoding matches the following values:
    *  Protect Stop Date - 1335514945 (Fri Apr 27 10:22:25 CEST 2012)
    */
    uint8 encoding[16] = {
        0x42, 0x00, 0x68, 0x09, 0x00, 0x00, 0x00, 0x08,
        0x00, 0x00, 0x00, 0x00, 0x4F, 0x9A, 0x57, 0x41
    };

    KMIP ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);

    int64 date_time = 1335514945;

    Attribute expected = {0};
    kmip_init_attribute(&expected);

    expected.type = KMIP_ATTR_PROTECT_STOP_DATE;
    expected.value = &date_time;

    Attribute observed = {0};
    int result = kmip_decode_attribute_v2(&ctx, &observed);
    int comparison = kmip_compare_attribute(&expected, &observed);
    if(!comparison)
    {
        kmip_print_attribute(stderr, 1, &expected);
        kmip_print_attribute(stderr, 1, &observed);
    }
    result = report_decoding_test_result(tracker, &ctx, comparison, result, __func__);

    kmip_free_attribute(&ctx, &observed);
    kmip_destroy(&ctx);

    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8f0, %rsp            # imm = 0x8F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x322ac(%rip), %rax     # 0x47240
movq %rax, -0x20(%rbp)
movq 0x322a9(%rip), %rax     # 0x47248
movq %rax, -0x18(%rbp)
leaq -0x8b8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x20(%rbp), %rsi
leaq -0x8b8(%rbp), %rdi
movl $0x10, %edx
movl $0x5, %ecx
callq 0x1c6e0
movq $0x4f9a5741, -0x8c0(%rbp) # imm = 0x4F9A5741
leaq -0x8d0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8d0(%rbp), %rdi
callq 0x1d330
movl $0xd, -0x8d0(%rbp)
leaq -0x8c0(%rbp), %rax
movq %rax, -0x8c8(%rbp)
leaq -0x8e0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8b8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x2e350
movl %eax, -0x8e4(%rbp)
leaq -0x8d0(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x20f80
movl %eax, -0x8e8(%rbp)
cmpl $0x0, -0x8e8(%rbp)
jne 0x15096
movq 0x3ef91(%rip), %rax     # 0x53ff8
movq (%rax), %rdi
movl $0x1, %esi
leaq -0x8d0(%rbp), %rdx
callq 0x3c210
movq 0x3ef76(%rip), %rax     # 0x53ff8
movq (%rax), %rdi
movl $0x1, %esi
leaq -0x8e0(%rbp), %rdx
callq 0x3c210
movq -0x8(%rbp), %rdi
movl -0x8e8(%rbp), %edx
movl -0x8e4(%rbp), %ecx
leaq -0x8b8(%rbp), %rsi
leaq 0x2bcfe(%rip), %r8      # 0x40db2
callq 0x13a0
movl %eax, -0x8e4(%rbp)
leaq -0x8b8(%rbp), %rdi
leaq -0x8e0(%rbp), %rsi
callq 0x1d8e0
leaq -0x8b8(%rbp), %rdi
callq 0x1cab0
movl -0x8e4(%rbp), %eax
addq $0x8f0, %rsp            # imm = 0x8F0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_decode_attribute_v2_unsupported_attribute
int
test_decode_attribute_v2_unsupported_attribute(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    uint8 encoding[3] = {0x42, 0x00, 0x00};

    KMIP ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_2_0);

    Attribute observed = {0};
    int result = kmip_decode_attribute_v2(&ctx, &observed);
    if(result != KMIP_ERROR_ATTR_UNSUPPORTED)
    {
        TEST_FAILED(tracker, __func__, __LINE__);
    }

    kmip_free_attribute(&ctx, &observed);
    kmip_destroy(&ctx);

    TEST_PASSED(tracker, __func__);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8d0, %rsp            # imm = 0x8D0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movw 0x30554(%rip), %ax      # 0x45828
movw %ax, -0x13(%rbp)
movb 0x3054c(%rip), %al      # 0x4582a
movb %al, -0x11(%rbp)
leaq -0x8b0(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x13(%rbp), %rsi
leaq -0x8b0(%rbp), %rdi
movl $0x3, %edx
movl $0x5, %ecx
callq 0x1c6e0
leaq -0x8c0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8b0(%rbp), %rdi
leaq -0x8c0(%rbp), %rsi
callq 0x2e350
movl %eax, -0x8c4(%rbp)
cmpl $-0x3, -0x8c4(%rbp)
je 0x15378
jmp 0x15345
leaq 0x29d69(%rip), %rdi     # 0x3f0b5
leaq 0x2babc(%rip), %rsi     # 0x40e0f
movl $0x26e8, %edx           # imm = 0x26E8
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rax
movw 0x2(%rax), %cx
addw $0x1, %cx
movw %cx, 0x2(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x153c3
leaq -0x8b0(%rbp), %rdi
leaq -0x8c0(%rbp), %rsi
callq 0x1d8e0
leaq -0x8b0(%rbp), %rdi
callq 0x1cab0
leaq 0x29cad(%rip), %rdi     # 0x3f04b
leaq 0x2ba6a(%rip), %rsi     # 0x40e0f
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rax
movw 0x4(%rax), %cx
addw $0x1, %cx
movw %cx, 0x4(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x8d0, %rsp            # imm = 0x8D0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_encode_nonce
int
test_encode_nonce(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    uint8 expected[40] = {
        0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20,
        0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04,
        0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00,
        0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00
    };
    
    uint8 observed[40] = {0};
    struct kmip ctx = {0};
    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_2);
    
    uint8 id[4] = {0x01, 0x02, 0x03, 0x04};
    struct byte_string ni = {0};
    ni.value = id;
    ni.size = ARRAY_LENGTH(id);
    
    uint8 value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
    struct byte_string nv = {0};
    nv.value = value;
    nv.size = ARRAY_LENGTH(value);
    
    struct nonce n = {0};
    n.nonce_id = &ni;
    n.nonce_value = &nv;
    
    int result = kmip_encode_nonce(&ctx, &n);
    result = report_encoding_test_result(
        tracker,
        &ctx,
        expected,
        observed,
        result,
        __func__);
    kmip_destroy(&ctx);
    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x940, %rsp            # imm = 0x940
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
leaq -0x30(%rbp), %rdi
leaq 0x2f9f8(%rip), %rsi     # 0x45d10
movl $0x28, %edx
callq 0x10c0
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1090
leaq -0x8f8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x60(%rbp), %rsi
leaq -0x8f8(%rbp), %rdi
movl $0x28, %edx
movl $0x2, %ecx
callq 0x1c6e0
movl 0x30db3(%rip), %eax     # 0x47118
movl %eax, -0x8fc(%rbp)
leaq -0x910(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8fc(%rbp), %rax
movq %rax, -0x910(%rbp)
movq $0x4, -0x908(%rbp)
movl 0x2f99b(%rip), %eax     # 0x45d38
movl %eax, -0x916(%rbp)
movw 0x2f992(%rip), %ax      # 0x45d3c
movw %ax, -0x912(%rbp)
leaq -0x928(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x916(%rbp), %rax
movq %rax, -0x928(%rbp)
movq $0x6, -0x920(%rbp)
leaq -0x938(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x910(%rbp), %rax
movq %rax, -0x938(%rbp)
leaq -0x928(%rbp), %rax
movq %rax, -0x930(%rbp)
leaq -0x8f8(%rbp), %rdi
leaq -0x938(%rbp), %rsi
callq 0x28dd0
movl %eax, -0x93c(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rdx
leaq -0x60(%rbp), %rcx
movl -0x93c(%rbp), %r8d
leaq -0x8f8(%rbp), %rsi
leaq 0x2ab57(%rip), %r9      # 0x40f9d
callq 0x11f0
movl %eax, -0x93c(%rbp)
leaq -0x8f8(%rbp), %rdi
callq 0x1cab0
movl -0x93c(%rbp), %eax
addq $0x940, %rsp            # imm = 0x940
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_decode_nonce
int
test_decode_nonce(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    uint8 encoding[40] = {
        0x42, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x00, 0x20,
        0x42, 0x00, 0xC9, 0x08, 0x00, 0x00, 0x00, 0x04,
        0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00,
        0x42, 0x00, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x06,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00
    };
    
    struct kmip ctx = {0};
    kmip_init(&ctx, encoding, ARRAY_LENGTH(encoding), KMIP_1_2);
    
    uint8 id[4] = {0x01, 0x02, 0x03, 0x04};
    struct byte_string ni = {0};
    ni.value = id;
    ni.size = ARRAY_LENGTH(id);
    
    uint8 value[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
    struct byte_string nv = {0};
    nv.value = value;
    nv.size = ARRAY_LENGTH(value);
    
    struct nonce expected = {0};
    expected.nonce_id = &ni;
    expected.nonce_value = &nv;
    
    struct nonce observed = {0};
    
    int result = kmip_decode_nonce(&ctx, &observed);
    result = report_decoding_test_result(
        tracker,
        &ctx,
        kmip_compare_nonce(&expected, &observed),
        result,
        __func__);
    kmip_free_nonce(&ctx, &observed);
    kmip_destroy(&ctx);
    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x930, %rsp            # imm = 0x930
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
leaq -0x30(%rbp), %rdi
leaq 0x2f8a8(%rip), %rsi     # 0x45d40
movl $0x28, %edx
callq 0x10c0
leaq -0x8c8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x30(%rbp), %rsi
leaq -0x8c8(%rbp), %rdi
movl $0x28, %edx
movl $0x2, %ecx
callq 0x1c6e0
movl 0x30c43(%rip), %eax     # 0x47118
movl %eax, -0x8cc(%rbp)
leaq -0x8e0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8cc(%rbp), %rax
movq %rax, -0x8e0(%rbp)
movq $0x4, -0x8d8(%rbp)
movl 0x2f85b(%rip), %eax     # 0x45d68
movl %eax, -0x8e6(%rbp)
movw 0x2f852(%rip), %ax      # 0x45d6c
movw %ax, -0x8e2(%rbp)
leaq -0x8f8(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8e6(%rbp), %rax
movq %rax, -0x8f8(%rbp)
movq $0x6, -0x8f0(%rbp)
leaq -0x908(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8e0(%rbp), %rax
movq %rax, -0x908(%rbp)
leaq -0x8f8(%rbp), %rax
movq %rax, -0x900(%rbp)
leaq -0x918(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq -0x8c8(%rbp), %rdi
leaq -0x918(%rbp), %rsi
callq 0x34680
movl %eax, -0x91c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x928(%rbp)
leaq -0x908(%rbp), %rdi
leaq -0x918(%rbp), %rsi
callq 0x23300
movq -0x928(%rbp), %rdi
movl %eax, %edx
movl -0x91c(%rbp), %ecx
leaq -0x8c8(%rbp), %rsi
leaq 0x2a9cc(%rip), %r8      # 0x40faf
callq 0x13a0
movl %eax, -0x91c(%rbp)
leaq -0x8c8(%rbp), %rdi
leaq -0x918(%rbp), %rsi
callq 0x1ef20
leaq -0x8c8(%rbp), %rdi
callq 0x1cab0
movl -0x91c(%rbp), %eax
addq $0x930, %rsp            # imm = 0x930
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_encode_get_request_payload_with_wrap_type
int
test_encode_get_request_payload_with_wrap_type(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    uint8 expected[104] = {
        0x42, 0x00, 0x79, 0x01, 0x00, 0x00, 0x00, 0x60, 
        0x42, 0x00, 0x94, 0x07, 0x00, 0x00, 0x00, 0x24, 
        0x37, 0x63, 0x66, 0x35, 0x32, 0x30, 0x39, 0x62, 
        0x2D, 0x36, 0x66, 0x66, 0x36, 0x2D, 0x34, 0x34, 
        0x32, 0x36, 0x2D, 0x38, 0x39, 0x39, 0x65, 0x2D, 
        0x32, 0x32, 0x62, 0x30, 0x36, 0x37, 0x38, 0x35, 
        0x39, 0x33, 0x37, 0x32, 0x00, 0x00, 0x00, 0x00, 
        0x42, 0x00, 0x42, 0x05, 0x00, 0x00, 0x00, 0x04, 
        0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
        0x42, 0x00, 0xF8, 0x05, 0x00, 0x00, 0x00, 0x04,
        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
        0x42, 0x00, 0x41, 0x05, 0x00, 0x00, 0x00, 0x04,
        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
    };
    
    uint8 observed[104] = {0};
    struct kmip ctx = {0};
    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_4);
    
    struct text_string uuid = {0};
    uuid.value = "7cf5209b-6ff6-4426-899e-22b067859372";
    uuid.size = 36;
    
    struct get_request_payload grp = {0};
    grp.unique_identifier = &uuid;
    grp.key_format_type = KMIP_KEYFORMAT_PKCS1;
    grp.key_compression_type = KMIP_KEYCOMP_EC_PUB_UNCOMPRESSED;
    
    grp.key_wrap_type = KMIP_WRAPTYPE_NOT_WRAPPED;
    
    int result = kmip_encode_get_request_payload(&ctx, &grp);
    result = report_encoding_test_result(
        tracker,
        &ctx,
        expected,
        observed,
        result,
        __func__);
    kmip_destroy(&ctx);
    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x9b0, %rsp            # imm = 0x9B0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
leaq -0x70(%rbp), %rdi
leaq 0x2eb98(%rip), %rsi     # 0x46570
movl $0x68, %edx
callq 0x10c0
leaq -0xe0(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0x1090
leaq -0x978(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0xe0(%rbp), %rsi
leaq -0x978(%rbp), %rdi
movl $0x68, %edx
movl $0x4, %ecx
callq 0x1c6e0
leaq -0x988(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1090
leaq 0x288f1(%rip), %rax     # 0x40330
movq %rax, -0x988(%rbp)
movq $0x24, -0x980(%rbp)
leaq -0x9a8(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1090
leaq -0x988(%rbp), %rax
movq %rax, -0x9a8(%rbp)
movl $0x3, -0x9a0(%rbp)
movl $0x1, -0x99c(%rbp)
movl $0x1, -0x990(%rbp)
leaq -0x978(%rbp), %rdi
leaq -0x9a8(%rbp), %rsi
callq 0x286a0
movl %eax, -0x9ac(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x70(%rbp), %rdx
leaq -0xe0(%rbp), %rcx
movl -0x9ac(%rbp), %r8d
leaq -0x978(%rbp), %rsi
leaq 0x296ca(%rip), %r9      # 0x41197
callq 0x11f0
movl %eax, -0x9ac(%rbp)
leaq -0x978(%rbp), %rdi
callq 0x1cab0
movl -0x9ac(%rbp), %eax
addq $0x9b0, %rsp            # imm = 0x9B0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: test_encode_query_functions
int
test_encode_query_functions(TestTracker *tracker)
{
    TRACK_TEST(tracker);

    /* This encoding matches the following set of values:
    *  Query Functions
          Query Operations
          Query Objects
    */
    uint8 expected[32] = {
        0x42, 0x00, 0x74, 0x05, 0x00, 0x00, 0x00, 0x04,
        0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
        0x42, 0x00, 0x74, 0x05, 0x00, 0x00, 0x00, 0x04,
        0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00
    };

    uint8 observed[32] = {0};
    KMIP ctx = {0};
    kmip_init(&ctx, observed, ARRAY_LENGTH(observed), KMIP_1_0);

    LinkedList list = {0};
    LinkedListItem item_1 = {0};
    int32 funct_1 = KMIP_QUERY_OPERATIONS;
    item_1.data = &funct_1;

    LinkedListItem item_2 = {0};
    int32 funct_2 = KMIP_QUERY_OBJECTS;
    item_2.data = &funct_2;

    kmip_linked_list_enqueue(&list, &item_1);
    kmip_linked_list_enqueue(&list, &item_2);

    Functions qf = {0};
    qf.function_list = &list;

    int result = kmip_encode_query_functions(&ctx, &qf);
    result = report_encoding_test_result(tracker, &ctx, expected, observed, result, __func__);

    kmip_destroy(&ctx);

    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x950, %rsp            # imm = 0x950
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq 0x2e6ec(%rip), %rax     # 0x47300
movq %rax, -0x30(%rbp)
movq 0x2e6e9(%rip), %rax     # 0x47308
movq %rax, -0x28(%rbp)
movq 0x2e6e6(%rip), %rax     # 0x47310
movq %rax, -0x20(%rbp)
movq 0x2e6e3(%rip), %rax     # 0x47318
movq %rax, -0x18(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1090
leaq -0x8e8(%rbp), %rdi
xorl %esi, %esi
movl $0x898, %edx            # imm = 0x898
callq 0x1090
leaq -0x50(%rbp), %rsi
leaq -0x8e8(%rbp), %rdi
movl $0x20, %edx
xorl %ecx, %ecx
callq 0x1c6e0
leaq -0x900(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x1090
leaq -0x918(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x1090
movl $0x1, -0x91c(%rbp)
leaq -0x91c(%rbp), %rax
movq %rax, -0x908(%rbp)
leaq -0x938(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x1090
movl $0x2, -0x93c(%rbp)
leaq -0x93c(%rbp), %rax
movq %rax, -0x928(%rbp)
leaq -0x900(%rbp), %rdi
leaq -0x918(%rbp), %rsi
callq 0x1b660
leaq -0x900(%rbp), %rdi
leaq -0x938(%rbp), %rsi
callq 0x1b660
leaq -0x948(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x1090
leaq -0x900(%rbp), %rax
movq %rax, -0x948(%rbp)
leaq -0x8e8(%rbp), %rdi
leaq -0x948(%rbp), %rsi
callq 0x2ab10
movl %eax, -0x94c(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rdx
leaq -0x50(%rbp), %rcx
movl -0x94c(%rbp), %r8d
leaq -0x8e8(%rbp), %rsi
leaq 0x2857d(%rip), %r9      # 0x412da
callq 0x11f0
movl %eax, -0x94c(%rbp)
leaq -0x8e8(%rbp), %rdi
callq 0x1cab0
movl -0x94c(%rbp), %eax
addq $0x950, %rsp            # imm = 0x950
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/tests/tests.c
// Function: print_help
void
print_help(const char *app)
{
    printf("Usage: %s [flag] ...\n\n", app);
    printf("Flags:\n");
    printf("-h : print this help info\n");
    printf("-i : run the test suite forever\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x26306(%rip), %rdi     # 0x415cd
movb $0x0, %al
callq 0x1070
leaq 0x2630f(%rip), %rdi     # 0x415e4
movb $0x0, %al
callq 0x1070
leaq 0x26309(%rip), %rdi     # 0x415ec
movb $0x0, %al
callq 0x1070
leaq 0x26316(%rip), %rdi     # 0x41607
movb $0x0, %al
callq 0x1070
addq $0x10, %rsp
popq %rbp
retq
nop