tmpssl

typedef struct stack_st OPENSSL_STACK;

typedef int(*OPENSSL_sk_compfunc)(const void*, const void*);
typedef void(*OPENSSL_sk_freefunc)(void*);
typedef void* (*OPENSSL_sk_copyfunc)(const void*);

int OPENSSL_sk_num(const OPENSSL_STACK*);
void* OPENSSL_sk_value(const OPENSSL_STACK*, int);

void* OPENSSL_sk_set(OPENSSL_STACK* st, int i, const void* data);

OPENSSL_STACK* OPENSSL_sk_new(OPENSSL_sk_compfunc cmp);
OPENSSL_STACK* OPENSSL_sk_new_null(void);
void OPENSSL_sk_free(OPENSSL_STACK*);
void OPENSSL_sk_pop_free(OPENSSL_STACK* st, void(*func) (void*));
OPENSSL_STACK* OPENSSL_sk_deep_copy(const OPENSSL_STACK*, OPENSSL_sk_copyfunc c, OPENSSL_sk_freefunc f);
int OPENSSL_sk_insert(OPENSSL_STACK* sk, const void* data, int where);
void* OPENSSL_sk_delete(OPENSSL_STACK* st, int loc);
void* OPENSSL_sk_delete_ptr(OPENSSL_STACK* st, const void* p);
int OPENSSL_sk_find(OPENSSL_STACK* st, const void* data);
int OPENSSL_sk_find_ex(OPENSSL_STACK* st, const void* data);
int OPENSSL_sk_push(OPENSSL_STACK* st, const void* data);
int OPENSSL_sk_unshift(OPENSSL_STACK* st, const void* data);
void* OPENSSL_sk_shift(OPENSSL_STACK* st);
void* OPENSSL_sk_pop(OPENSSL_STACK* st);
void OPENSSL_sk_zero(OPENSSL_STACK* st);
OPENSSL_sk_compfunc OPENSSL_sk_set_cmp_func(OPENSSL_STACK* sk, OPENSSL_sk_compfunc cmp);
OPENSSL_STACK* OPENSSL_sk_dup(const OPENSSL_STACK* st);
void OPENSSL_sk_sort(OPENSSL_STACK* st);
int OPENSSL_sk_is_sorted(const OPENSSL_STACK* st);


typedef char* OPENSSL_STRING;
typedef const char* OPENSSL_CSTRING;


struct stack_st_OPENSSL_STRING;
typedef int(*sk_OPENSSL_STRING_compfunc)(const char* const* a, const char* const* b);
typedef void(*sk_OPENSSL_STRING_freefunc)(char* a);
typedef char* (*sk_OPENSSL_STRING_copyfunc)(const char* a);
static __inline int sk_OPENSSL_STRING_num(const struct stack_st_OPENSSL_STRING* sk)
{
    return OPENSSL_sk_num((const OPENSSL_STACK*)sk);
}
static __inline char* sk_OPENSSL_STRING_value(const struct stack_st_OPENSSL_STRING* sk, int idx)
{
    return (char*)OPENSSL_sk_value((const OPENSSL_STACK*)sk, idx);
}
static __inline struct stack_st_OPENSSL_STRING* sk_OPENSSL_STRING_new(sk_OPENSSL_STRING_compfunc compare)
{
    return (struct stack_st_OPENSSL_STRING*)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare);
}
static __inline struct stack_st_OPENSSL_STRING* sk_OPENSSL_STRING_new_null(void)
{
    return (struct stack_st_OPENSSL_STRING*)OPENSSL_sk_new_null();
}
static __inline void sk_OPENSSL_STRING_free(struct stack_st_OPENSSL_STRING* sk)
{
    OPENSSL_sk_free((OPENSSL_STACK*)sk);
}
static __inline void sk_OPENSSL_STRING_zero(struct stack_st_OPENSSL_STRING* sk)
{
    OPENSSL_sk_zero((OPENSSL_STACK*)sk);
}
static __inline char* sk_OPENSSL_STRING_delete(struct stack_st_OPENSSL_STRING* sk, int i)
{
    return (char*)OPENSSL_sk_delete((OPENSSL_STACK*)sk, i);
}
static __inline char* sk_OPENSSL_STRING_delete_ptr(struct stack_st_OPENSSL_STRING* sk, char* ptr)
{
    return (char*)OPENSSL_sk_delete_ptr((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline int sk_OPENSSL_STRING_push(struct stack_st_OPENSSL_STRING* sk, char* ptr)
{
    return OPENSSL_sk_push((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline int sk_OPENSSL_STRING_unshift(struct stack_st_OPENSSL_STRING* sk, char* ptr)
{
    return OPENSSL_sk_unshift((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline char* sk_OPENSSL_STRING_pop(struct stack_st_OPENSSL_STRING* sk)
{
    return (char*)OPENSSL_sk_pop((OPENSSL_STACK*)sk);
}
static __inline char* sk_OPENSSL_STRING_shift(struct stack_st_OPENSSL_STRING* sk)
{
    return (char*)OPENSSL_sk_shift((OPENSSL_STACK*)sk);
}
static __inline void sk_OPENSSL_STRING_pop_free(struct stack_st_OPENSSL_STRING* sk, sk_OPENSSL_STRING_freefunc freefunc)
{
    OPENSSL_sk_pop_free((OPENSSL_STACK*)sk, (OPENSSL_sk_freefunc)freefunc);
}
static __inline int sk_OPENSSL_STRING_insert(struct stack_st_OPENSSL_STRING* sk, char* ptr, int idx)
{
    return OPENSSL_sk_insert((OPENSSL_STACK*)sk, (const void*)ptr, idx);
}
static __inline char* sk_OPENSSL_STRING_set(struct stack_st_OPENSSL_STRING* sk, int idx, char* ptr)
{
    return (char*)OPENSSL_sk_set((OPENSSL_STACK*)sk, idx, (const void*)ptr);
}
static __inline int sk_OPENSSL_STRING_find(struct stack_st_OPENSSL_STRING* sk, char* ptr)
{
    return OPENSSL_sk_find((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline int sk_OPENSSL_STRING_find_ex(struct stack_st_OPENSSL_STRING* sk, char* ptr)
{
    return OPENSSL_sk_find_ex((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline void sk_OPENSSL_STRING_sort(struct stack_st_OPENSSL_STRING* sk)
{
    OPENSSL_sk_sort((OPENSSL_STACK*)sk);
}
static __inline int sk_OPENSSL_STRING_is_sorted(const struct stack_st_OPENSSL_STRING* sk)
{
    return OPENSSL_sk_is_sorted((const OPENSSL_STACK*)sk);
}
static __inline struct stack_st_OPENSSL_STRING* sk_OPENSSL_STRING_dup(const struct stack_st_OPENSSL_STRING* sk)
{
    return (struct stack_st_OPENSSL_STRING*)OPENSSL_sk_dup((const OPENSSL_STACK*)sk);
}
static __inline struct stack_st_OPENSSL_STRING* sk_OPENSSL_STRING_deep_copy(const struct stack_st_OPENSSL_STRING* sk, sk_OPENSSL_STRING_copyfunc copyfunc, sk_OPENSSL_STRING_freefunc freefunc)
{
    return (struct stack_st_OPENSSL_STRING*)OPENSSL_sk_deep_copy((const OPENSSL_STACK*)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc);
}
static __inline sk_OPENSSL_STRING_compfunc sk_OPENSSL_STRING_set_cmp_func(struct stack_st_OPENSSL_STRING* sk, sk_OPENSSL_STRING_compfunc compare)
{
    return (sk_OPENSSL_STRING_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK*)sk, (OPENSSL_sk_compfunc)compare);
}
struct stack_st_OPENSSL_CSTRING;
typedef int(*sk_OPENSSL_CSTRING_compfunc)(const char* const* a, const char* const* b);
typedef void(*sk_OPENSSL_CSTRING_freefunc)(char* a);
typedef char* (*sk_OPENSSL_CSTRING_copyfunc)(const char* a);
static __inline int sk_OPENSSL_CSTRING_num(const struct stack_st_OPENSSL_CSTRING* sk)
{
    return OPENSSL_sk_num((const OPENSSL_STACK*)sk);
}
static __inline const char* sk_OPENSSL_CSTRING_value(const struct stack_st_OPENSSL_CSTRING* sk, int idx)
{
    return (const char*)OPENSSL_sk_value((const OPENSSL_STACK*)sk, idx);
}
static __inline struct stack_st_OPENSSL_CSTRING* sk_OPENSSL_CSTRING_new(sk_OPENSSL_CSTRING_compfunc compare)
{
    return (struct stack_st_OPENSSL_CSTRING*)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare);
}
static __inline struct stack_st_OPENSSL_CSTRING* sk_OPENSSL_CSTRING_new_null(void)
{
    return (struct stack_st_OPENSSL_CSTRING*)OPENSSL_sk_new_null();
}
static __inline void sk_OPENSSL_CSTRING_free(struct stack_st_OPENSSL_CSTRING* sk)
{
    OPENSSL_sk_free((OPENSSL_STACK*)sk);
}
static __inline void sk_OPENSSL_CSTRING_zero(struct stack_st_OPENSSL_CSTRING* sk)
{
    OPENSSL_sk_zero((OPENSSL_STACK*)sk);
}
static __inline const char* sk_OPENSSL_CSTRING_delete(struct stack_st_OPENSSL_CSTRING* sk, int i)
{
    return (const char*)OPENSSL_sk_delete((OPENSSL_STACK*)sk, i);
}
static __inline const char* sk_OPENSSL_CSTRING_delete_ptr(struct stack_st_OPENSSL_CSTRING* sk, const char* ptr)
{
    return (const char*)OPENSSL_sk_delete_ptr((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline int sk_OPENSSL_CSTRING_push(struct stack_st_OPENSSL_CSTRING* sk, const char* ptr)
{
    return OPENSSL_sk_push((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline int sk_OPENSSL_CSTRING_unshift(struct stack_st_OPENSSL_CSTRING* sk, const char* ptr)
{
    return OPENSSL_sk_unshift((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline const char* sk_OPENSSL_CSTRING_pop(struct stack_st_OPENSSL_CSTRING* sk)
{
    return (const char*)OPENSSL_sk_pop((OPENSSL_STACK*)sk);
}
static __inline const char* sk_OPENSSL_CSTRING_shift(struct stack_st_OPENSSL_CSTRING* sk)
{
    return (const char*)OPENSSL_sk_shift((OPENSSL_STACK*)sk);
}
static __inline void sk_OPENSSL_CSTRING_pop_free(struct stack_st_OPENSSL_CSTRING* sk, sk_OPENSSL_CSTRING_freefunc freefunc)
{
    OPENSSL_sk_pop_free((OPENSSL_STACK*)sk, (OPENSSL_sk_freefunc)freefunc);
}
static __inline int sk_OPENSSL_CSTRING_insert(struct stack_st_OPENSSL_CSTRING* sk, const char* ptr, int idx)
{
    return OPENSSL_sk_insert((OPENSSL_STACK*)sk, (const void*)ptr, idx);
}
static __inline const char* sk_OPENSSL_CSTRING_set(struct stack_st_OPENSSL_CSTRING* sk, int idx, const char* ptr)
{
    return (const char*)OPENSSL_sk_set((OPENSSL_STACK*)sk, idx, (const void*)ptr);
}
static __inline int sk_OPENSSL_CSTRING_find(struct stack_st_OPENSSL_CSTRING* sk, const char* ptr)
{
    return OPENSSL_sk_find((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline int sk_OPENSSL_CSTRING_find_ex(struct stack_st_OPENSSL_CSTRING* sk, const char* ptr)
{
    return OPENSSL_sk_find_ex((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline void sk_OPENSSL_CSTRING_sort(struct stack_st_OPENSSL_CSTRING* sk)
{
    OPENSSL_sk_sort((OPENSSL_STACK*)sk);
}
static __inline int sk_OPENSSL_CSTRING_is_sorted(const struct stack_st_OPENSSL_CSTRING* sk)
{
    return OPENSSL_sk_is_sorted((const OPENSSL_STACK*)sk);
}
static __inline struct stack_st_OPENSSL_CSTRING* sk_OPENSSL_CSTRING_dup(const struct stack_st_OPENSSL_CSTRING* sk)
{
    return (struct stack_st_OPENSSL_CSTRING*)OPENSSL_sk_dup((const OPENSSL_STACK*)sk);
}
static __inline struct stack_st_OPENSSL_CSTRING* sk_OPENSSL_CSTRING_deep_copy(const struct stack_st_OPENSSL_CSTRING* sk, sk_OPENSSL_CSTRING_copyfunc copyfunc, sk_OPENSSL_CSTRING_freefunc freefunc)
{
    return (struct stack_st_OPENSSL_CSTRING*)OPENSSL_sk_deep_copy((const OPENSSL_STACK*)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc);
}
static __inline sk_OPENSSL_CSTRING_compfunc sk_OPENSSL_CSTRING_set_cmp_func(struct stack_st_OPENSSL_CSTRING* sk, sk_OPENSSL_CSTRING_compfunc compare)
{
    return (sk_OPENSSL_CSTRING_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK*)sk, (OPENSSL_sk_compfunc)compare);
}





typedef void* OPENSSL_BLOCK;
struct stack_st_OPENSSL_BLOCK;
typedef int(*sk_OPENSSL_BLOCK_compfunc)(const void* const* a, const void* const* b);
typedef void(*sk_OPENSSL_BLOCK_freefunc)(void* a);
typedef void* (*sk_OPENSSL_BLOCK_copyfunc)(const void* a);
static __inline int sk_OPENSSL_BLOCK_num(const struct stack_st_OPENSSL_BLOCK* sk)
{
    return OPENSSL_sk_num((const OPENSSL_STACK*)sk);
}
static __inline void* sk_OPENSSL_BLOCK_value(const struct stack_st_OPENSSL_BLOCK* sk, int idx)
{
    return (void*)OPENSSL_sk_value((const OPENSSL_STACK*)sk, idx);
}
static __inline struct stack_st_OPENSSL_BLOCK* sk_OPENSSL_BLOCK_new(sk_OPENSSL_BLOCK_compfunc compare)
{
    return (struct stack_st_OPENSSL_BLOCK*)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare);
}
static __inline struct stack_st_OPENSSL_BLOCK* sk_OPENSSL_BLOCK_new_null(void)
{
    return (struct stack_st_OPENSSL_BLOCK*)OPENSSL_sk_new_null();
}
static __inline void sk_OPENSSL_BLOCK_free(struct stack_st_OPENSSL_BLOCK* sk)
{
    OPENSSL_sk_free((OPENSSL_STACK*)sk);
}
static __inline void sk_OPENSSL_BLOCK_zero(struct stack_st_OPENSSL_BLOCK* sk)
{
    OPENSSL_sk_zero((OPENSSL_STACK*)sk);
}
static __inline void* sk_OPENSSL_BLOCK_delete(struct stack_st_OPENSSL_BLOCK* sk, int i)
{
    return (void*)OPENSSL_sk_delete((OPENSSL_STACK*)sk, i);
}
static __inline void* sk_OPENSSL_BLOCK_delete_ptr(struct stack_st_OPENSSL_BLOCK* sk, void* ptr)
{
    return (void*)OPENSSL_sk_delete_ptr((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline int sk_OPENSSL_BLOCK_push(struct stack_st_OPENSSL_BLOCK* sk, void* ptr)
{
    return OPENSSL_sk_push((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline int sk_OPENSSL_BLOCK_unshift(struct stack_st_OPENSSL_BLOCK* sk, void* ptr)
{
    return OPENSSL_sk_unshift((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline void* sk_OPENSSL_BLOCK_pop(struct stack_st_OPENSSL_BLOCK* sk)
{
    return (void*)OPENSSL_sk_pop((OPENSSL_STACK*)sk);
}
static __inline void* sk_OPENSSL_BLOCK_shift(struct stack_st_OPENSSL_BLOCK* sk)
{
    return (void*)OPENSSL_sk_shift((OPENSSL_STACK*)sk);
}
static __inline void sk_OPENSSL_BLOCK_pop_free(struct stack_st_OPENSSL_BLOCK* sk, sk_OPENSSL_BLOCK_freefunc freefunc)
{
    OPENSSL_sk_pop_free((OPENSSL_STACK*)sk, (OPENSSL_sk_freefunc)freefunc);
}
static __inline int sk_OPENSSL_BLOCK_insert(struct stack_st_OPENSSL_BLOCK* sk, void* ptr, int idx)
{
    return OPENSSL_sk_insert((OPENSSL_STACK*)sk, (const void*)ptr, idx);
}
static __inline void* sk_OPENSSL_BLOCK_set(struct stack_st_OPENSSL_BLOCK* sk, int idx, void* ptr)
{
    return (void*)OPENSSL_sk_set((OPENSSL_STACK*)sk, idx, (const void*)ptr);
}
static __inline int sk_OPENSSL_BLOCK_find(struct stack_st_OPENSSL_BLOCK* sk, void* ptr)
{
    return OPENSSL_sk_find((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline int sk_OPENSSL_BLOCK_find_ex(struct stack_st_OPENSSL_BLOCK* sk, void* ptr)
{
    return OPENSSL_sk_find_ex((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline void sk_OPENSSL_BLOCK_sort(struct stack_st_OPENSSL_BLOCK* sk)
{
    OPENSSL_sk_sort((OPENSSL_STACK*)sk);
}
static __inline int sk_OPENSSL_BLOCK_is_sorted(const struct stack_st_OPENSSL_BLOCK* sk)
{
    return OPENSSL_sk_is_sorted((const OPENSSL_STACK*)sk);
}
static __inline struct stack_st_OPENSSL_BLOCK* sk_OPENSSL_BLOCK_dup(const struct stack_st_OPENSSL_BLOCK* sk)
{
    return (struct stack_st_OPENSSL_BLOCK*)OPENSSL_sk_dup((const OPENSSL_STACK*)sk);
}
static __inline struct stack_st_OPENSSL_BLOCK* sk_OPENSSL_BLOCK_deep_copy(const struct stack_st_OPENSSL_BLOCK* sk, sk_OPENSSL_BLOCK_copyfunc copyfunc, sk_OPENSSL_BLOCK_freefunc freefunc)
{
    return (struct stack_st_OPENSSL_BLOCK*)OPENSSL_sk_deep_copy((const OPENSSL_STACK*)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc);
}
static __inline sk_OPENSSL_BLOCK_compfunc sk_OPENSSL_BLOCK_set_cmp_func(struct stack_st_OPENSSL_BLOCK* sk, sk_OPENSSL_BLOCK_compfunc compare)
{
    return (sk_OPENSSL_BLOCK_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK*)sk, (OPENSSL_sk_compfunc)compare);
}

typedef struct example_st
{
    int a;
    double b;
} example_t;

DECLARE_STACK_OF(example_t);
DECLARE_ASN1_FUNCTIONS(example_t);
DECLARE_ASN1_ITEM(example_t);
DECLARE_ASN1_SET_OF(example_t);
struct stack_st_example_t;
typedef int(*sk_example_t_compfunc)(const example_t* const* a, const example_t* const* b);
typedef void(*sk_example_t_freefunc)(example_t* a);
typedef example_t* (*sk_example_t_copyfunc)(const example_t* a);
static __inline int sk_example_t_num(const struct stack_st_example_t* sk)
{
    return OPENSSL_sk_num((const OPENSSL_STACK*)sk);
}
static __inline example_t* sk_example_t_value(const struct stack_st_example_t* sk, int idx)
{
    return (example_t*)OPENSSL_sk_value((const OPENSSL_STACK*)sk, idx);
}
static __inline struct stack_st_example_t* sk_example_t_new(sk_example_t_compfunc compare)
{
    return (struct stack_st_example_t*)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare);
}
static __inline struct stack_st_example_t* sk_example_t_new_null(void)
{
    return (struct stack_st_example_t*)OPENSSL_sk_new_null();
}
static __inline void sk_example_t_free(struct stack_st_example_t* sk)
{
    OPENSSL_sk_free((OPENSSL_STACK*)sk);
}
static __inline void sk_example_t_zero(struct stack_st_example_t* sk)
{
    OPENSSL_sk_zero((OPENSSL_STACK*)sk);
}
static __inline example_t* sk_example_t_delete(struct stack_st_example_t* sk, int i)
{
    return (example_t*)OPENSSL_sk_delete((OPENSSL_STACK*)sk, i);
}
static __inline example_t* sk_example_t_delete_ptr(struct stack_st_example_t* sk, example_t* ptr)
{
    return (example_t*)OPENSSL_sk_delete_ptr((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline int sk_example_t_push(struct stack_st_example_t* sk, example_t* ptr)
{
    return OPENSSL_sk_push((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline int sk_example_t_unshift(struct stack_st_example_t* sk, example_t* ptr)
{
    return OPENSSL_sk_unshift((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline example_t* sk_example_t_pop(struct stack_st_example_t* sk)
{
    return (example_t*)OPENSSL_sk_pop((OPENSSL_STACK*)sk);
}
static __inline example_t* sk_example_t_shift(struct stack_st_example_t* sk)
{
    return (example_t*)OPENSSL_sk_shift((OPENSSL_STACK*)sk);
}
static __inline void sk_example_t_pop_free(struct stack_st_example_t* sk, sk_example_t_freefunc freefunc)
{
    OPENSSL_sk_pop_free((OPENSSL_STACK*)sk, (OPENSSL_sk_freefunc)freefunc);
}
static __inline int sk_example_t_insert(struct stack_st_example_t* sk, example_t* ptr, int idx)
{
    return OPENSSL_sk_insert((OPENSSL_STACK*)sk, (const void*)ptr, idx);
}
static __inline example_t* sk_example_t_set(struct stack_st_example_t* sk, int idx, example_t* ptr)
{
    return (example_t*)OPENSSL_sk_set((OPENSSL_STACK*)sk, idx, (const void*)ptr);
}
static __inline int sk_example_t_find(struct stack_st_example_t* sk, example_t* ptr)
{
    return OPENSSL_sk_find((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline int sk_example_t_find_ex(struct stack_st_example_t* sk, example_t* ptr)
{
    return OPENSSL_sk_find_ex((OPENSSL_STACK*)sk, (const void*)ptr);
}
static __inline void sk_example_t_sort(struct stack_st_example_t* sk)
{
    OPENSSL_sk_sort((OPENSSL_STACK*)sk);
}
static __inline int sk_example_t_is_sorted(const struct stack_st_example_t* sk)
{
    return OPENSSL_sk_is_sorted((const OPENSSL_STACK*)sk);
}
static __inline struct stack_st_example_t* sk_example_t_dup(const struct stack_st_example_t* sk)
{
    return (struct stack_st_example_t*)OPENSSL_sk_dup((const OPENSSL_STACK*)sk);
}
static __inline struct stack_st_example_t* sk_example_t_deep_copy(const struct stack_st_example_t* sk, sk_example_t_copyfunc copyfunc, sk_example_t_freefunc freefunc)
{
    return (struct stack_st_example_t*)OPENSSL_sk_deep_copy((const OPENSSL_STACK*)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc);
}
static __inline sk_example_t_compfunc sk_example_t_set_cmp_func(struct stack_st_example_t* sk, sk_example_t_compfunc compare)
{
    return (sk_example_t_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK*)sk, (OPENSSL_sk_compfunc)compare);
};

int main(void)
{
    struct stack_st_example_t* stackex = ((void*)0);

    stackex = stackex;


    return 0;
}