// Skip function: __VERIFIER_error

// Skip function: __VERIFIER_nondet_int

// Skip function: __VERIFIER_nondet_ulong

// Function: __bitmap_weight
// with type: int __bitmap_weight(const unsigned long *, unsigned int)
// with return type: int
int __VERIFIER_nondet_int(void);
int __bitmap_weight(const unsigned long *arg0, unsigned int arg1) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: __dynamic_pr_debug
// with type: void __dynamic_pr_debug(struct _ddebug *, const char *, ...)
// with return type: void
void __dynamic_pr_debug(struct _ddebug *arg0, const char *arg1, ...) {
  // Void type
  return;
}

// Function: __init_waitqueue_head
// with type: void __init_waitqueue_head(wait_queue_head_t *, const char *, struct lock_class_key *)
// with return type: void
void __init_waitqueue_head(wait_queue_head_t *arg0, const char *arg1, struct lock_class_key *arg2) {
  // Void type
  return;
}

// Function: __init_work
// with type: void __init_work(struct work_struct *, int)
// with return type: void
void __init_work(struct work_struct *arg0, int arg1) {
  // Void type
  return;
}

// Function: __list_add
// with type: void __list_add(struct list_head *, struct list_head *, struct list_head *)
// with return type: void
void __list_add(struct list_head *arg0, struct list_head *arg1, struct list_head *arg2) {
  // Void type
  return;
}

// Function: __list_del_entry
// with type: void __list_del_entry(struct list_head *)
// with return type: void
void __list_del_entry(struct list_head *arg0) {
  // Void type
  return;
}

// Function: __might_sleep
// with type: void __might_sleep(const char *, int, int)
// with return type: void
void __might_sleep(const char *arg0, int arg1, int arg2) {
  // Void type
  return;
}

// Function: __mutex_init
// with type: void __mutex_init(struct mutex *, const char *, struct lock_class_key *)
// with return type: void
void __mutex_init(struct mutex *arg0, const char *arg1, struct lock_class_key *arg2) {
  // Void type
  return;
}

// Function: __raw_spin_lock_init
// with type: void __raw_spin_lock_init(raw_spinlock_t *, const char *, struct lock_class_key *)
// with return type: void
void __raw_spin_lock_init(raw_spinlock_t *arg0, const char *arg1, struct lock_class_key *arg2) {
  // Void type
  return;
}

// Function: __request_module
// with type: int __request_module(bool , const char *, ...)
// with return type: int
int __VERIFIER_nondet_int(void);
int __request_module(bool arg0, const char *arg1, ...) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: __transport_register_session
// with type: void __transport_register_session(struct se_portal_group *, struct se_node_acl *, struct se_session *, void *)
// with return type: void
void __transport_register_session(struct se_portal_group *arg0, struct se_node_acl *arg1, struct se_session *arg2, void *arg3) {
  // Void type
  return;
}

// Function: __wake_up
// with type: void __wake_up(wait_queue_head_t *, unsigned int, int, void *)
// with return type: void
void __wake_up(wait_queue_head_t *arg0, unsigned int arg1, int arg2, void *arg3) {
  // Void type
  return;
}

// Function: _raw_read_lock_bh
// with type: void _raw_read_lock_bh(rwlock_t *)
// with return type: void
void _raw_read_lock_bh(rwlock_t *arg0) {
  // Void type
  return;
}

// Function: _raw_read_unlock_bh
// with type: void _raw_read_unlock_bh(rwlock_t *)
// with return type: void
void _raw_read_unlock_bh(rwlock_t *arg0) {
  // Void type
  return;
}

// Function: _raw_spin_lock
// with type: void _raw_spin_lock(raw_spinlock_t *)
// with return type: void
void _raw_spin_lock(raw_spinlock_t *arg0) {
  // Void type
  return;
}

// Function: _raw_spin_lock_bh
// with type: void _raw_spin_lock_bh(raw_spinlock_t *)
// with return type: void
void _raw_spin_lock_bh(raw_spinlock_t *arg0) {
  // Void type
  return;
}

// Function: _raw_spin_unlock
// with type: void _raw_spin_unlock(raw_spinlock_t *)
// with return type: void
void _raw_spin_unlock(raw_spinlock_t *arg0) {
  // Void type
  return;
}

// Function: _raw_spin_unlock_bh
// with type: void _raw_spin_unlock_bh(raw_spinlock_t *)
// with return type: void
void _raw_spin_unlock_bh(raw_spinlock_t *arg0) {
  // Void type
  return;
}

// Function: _raw_write_lock_bh
// with type: void _raw_write_lock_bh(rwlock_t *)
// with return type: void
void _raw_write_lock_bh(rwlock_t *arg0) {
  // Void type
  return;
}

// Function: _raw_write_unlock_bh
// with type: void _raw_write_unlock_bh(rwlock_t *)
// with return type: void
void _raw_write_unlock_bh(rwlock_t *arg0) {
  // Void type
  return;
}

// Function: add_timer
// with type: void add_timer(struct timer_list *)
// with return type: void
void add_timer(struct timer_list *arg0) {
  // Void type
  return;
}

// Function: bitmap_find_free_region
// with type: int bitmap_find_free_region(unsigned long *, unsigned int, int)
// with return type: int
int __VERIFIER_nondet_int(void);
int bitmap_find_free_region(unsigned long *arg0, unsigned int arg1, int arg2) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: bitmap_release_region
// with type: void bitmap_release_region(unsigned long *, unsigned int, int)
// with return type: void
void bitmap_release_region(unsigned long *arg0, unsigned int arg1, int arg2) {
  // Void type
  return;
}

// Skip function: calloc

// Function: cancel_delayed_work_sync
// with type: bool cancel_delayed_work_sync(struct delayed_work *)
// with return type: bool 
bool __VERIFIER_nondet_bool(void);
bool cancel_delayed_work_sync(struct delayed_work *arg0) {
  // Typedef type
  // Real type: _Bool
  // Simple type
  return __VERIFIER_nondet_bool();
}

// Function: capable
// with type: bool capable(int)
// with return type: bool 
bool __VERIFIER_nondet_bool(void);
bool capable(int arg0) {
  // Typedef type
  // Real type: _Bool
  // Simple type
  return __VERIFIER_nondet_bool();
}

// Function: complete
// with type: void complete(struct completion *)
// with return type: void
void complete(struct completion *arg0) {
  // Void type
  return;
}

// Function: config_group_init_type_name
// with type: void config_group_init_type_name(struct config_group *, const char *, struct config_item_type *)
// with return type: void
void config_group_init_type_name(struct config_group *arg0, const char *arg1, struct config_item_type *arg2) {
  // Void type
  return;
}

// Function: config_item_put
// with type: void config_item_put(struct config_item *)
// with return type: void
void config_item_put(struct config_item *arg0) {
  // Void type
  return;
}

// Function: core_alua_check_nonop_delay
// with type: int core_alua_check_nonop_delay(struct se_cmd *)
// with return type: int
int __VERIFIER_nondet_int(void);
int core_alua_check_nonop_delay(struct se_cmd *arg0) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: core_tmr_alloc_req
// with type: int core_tmr_alloc_req(struct se_cmd *, void *, u8 , gfp_t )
// with return type: int
int __VERIFIER_nondet_int(void);
int core_tmr_alloc_req(struct se_cmd *arg0, void *arg1, u8 arg2, gfp_t arg3) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: core_tpg_check_initiator_node_acl
// with type: struct se_node_acl *core_tpg_check_initiator_node_acl(struct se_portal_group *, unsigned char *)
// with return type: (struct se_node_acl)*
struct se_node_acl *core_tpg_check_initiator_node_acl(struct se_portal_group *arg0, unsigned char *arg1) {
  // Pointer type
  return ldv_malloc(sizeof(struct se_node_acl));
}

// Function: core_tpg_deregister
// with type: int core_tpg_deregister(struct se_portal_group *)
// with return type: int
int __VERIFIER_nondet_int(void);
int core_tpg_deregister(struct se_portal_group *arg0) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: core_tpg_get_initiator_node_acl
// with type: struct se_node_acl *core_tpg_get_initiator_node_acl(struct se_portal_group *, unsigned char *)
// with return type: (struct se_node_acl)*
struct se_node_acl *core_tpg_get_initiator_node_acl(struct se_portal_group *arg0, unsigned char *arg1) {
  // Pointer type
  return ldv_malloc(sizeof(struct se_node_acl));
}

// Function: core_tpg_register
// with type: int core_tpg_register(struct se_wwn *, struct se_portal_group *, int)
// with return type: int
int __VERIFIER_nondet_int(void);
int core_tpg_register(struct se_wwn *arg0, struct se_portal_group *arg1, int arg2) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: core_tpg_set_initiator_node_queue_depth
// with type: int core_tpg_set_initiator_node_queue_depth(struct se_portal_group *, unsigned char *, u32 , int)
// with return type: int
int __VERIFIER_nondet_int(void);
int core_tpg_set_initiator_node_queue_depth(struct se_portal_group *arg0, unsigned char *arg1, u32 arg2, int arg3) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: core_tpg_set_initiator_node_tag
// with type: int core_tpg_set_initiator_node_tag(struct se_portal_group *, struct se_node_acl *, const char *)
// with return type: int
int __VERIFIER_nondet_int(void);
int core_tpg_set_initiator_node_tag(struct se_portal_group *arg0, struct se_node_acl *arg1, const char *arg2) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: crypto_alloc_base
// with type: struct crypto_tfm *crypto_alloc_base(const char *, u32 , u32 )
// with return type: (struct crypto_tfm)*
struct crypto_tfm *crypto_alloc_base(const char *arg0, u32 arg1, u32 arg2) {
  // Pointer type
  return ldv_malloc(sizeof(struct crypto_tfm));
}

// Function: del_timer_sync
// with type: int del_timer_sync(struct timer_list *)
// with return type: int
int __VERIFIER_nondet_int(void);
int del_timer_sync(struct timer_list *arg0) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: down_interruptible
// with type: int down_interruptible(struct semaphore *)
// with return type: int
int __VERIFIER_nondet_int(void);
int down_interruptible(struct semaphore *arg0) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: dump_stack
// with type: void dump_stack()
// with return type: void
void dump_stack() {
  // Void type
  return;
}

// Function: find_next_bit
// with type: unsigned long int find_next_bit(const unsigned long *, unsigned long, unsigned long)
// with return type: unsigned long int
unsigned long __VERIFIER_nondet_ulong(void);
unsigned long int find_next_bit(const unsigned long *arg0, unsigned long arg1, unsigned long arg2) {
  // Simple type
  return __VERIFIER_nondet_ulong();
}

// Function: finish_wait
// with type: void finish_wait(wait_queue_head_t *, wait_queue_t *)
// with return type: void
void finish_wait(wait_queue_head_t *arg0, wait_queue_t *arg1) {
  // Void type
  return;
}

// Function: flush_signals
// with type: void flush_signals(struct task_struct *)
// with return type: void
void flush_signals(struct task_struct *arg0) {
  // Void type
  return;
}

// Function: flush_workqueue
// with type: void flush_workqueue(struct workqueue_struct *)
// with return type: void
void flush_workqueue(struct workqueue_struct *arg0) {
  // Void type
  return;
}

// Function: free_cpumask_var
// with type: void free_cpumask_var(cpumask_var_t )
// with return type: void
void free_cpumask_var(cpumask_var_t arg0) {
  // Void type
  return;
}

// Function: get_random_bytes
// with type: void get_random_bytes(void *, int)
// with return type: void
void get_random_bytes(void *arg0, int arg1) {
  // Void type
  return;
}

// Function: hex2bin
// with type: int hex2bin(u8 *, const char *, size_t )
// with return type: int
int __VERIFIER_nondet_int(void);
int hex2bin(u8 *arg0, const char *arg1, size_t arg2) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: idr_alloc
// with type: int idr_alloc(struct idr *, void *, int, int, gfp_t )
// with return type: int
int __VERIFIER_nondet_int(void);
int idr_alloc(struct idr *arg0, void *arg1, int arg2, int arg3, gfp_t arg4) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: idr_init
// with type: void idr_init(struct idr *)
// with return type: void
void idr_init(struct idr *arg0) {
  // Void type
  return;
}

// Function: idr_preload
// with type: void idr_preload(gfp_t )
// with return type: void
void idr_preload(gfp_t arg0) {
  // Void type
  return;
}

// Function: idr_remove
// with type: void idr_remove(struct idr *, int)
// with return type: void
void idr_remove(struct idr *arg0, int arg1) {
  // Void type
  return;
}

// Function: in6_pton
// with type: int in6_pton(const char *, int, u8 *, int, const char **)
// with return type: int
int __VERIFIER_nondet_int(void);
int in6_pton(const char *arg0, int arg1, u8 *arg2, int arg3, const char **arg4) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: in_aton
// with type: __be32 in_aton(const char *)
// with return type: __be32 
unsigned int __VERIFIER_nondet_uint(void);
__be32 in_aton(const char *arg0) {
  // Typedef type
  // Real type: __u32 
  // Typedef type
  // Real type: unsigned int
  // Simple type
  return __VERIFIER_nondet_uint();
}

// Function: init_timer_key
// with type: void init_timer_key(struct timer_list *, unsigned int, const char *, struct lock_class_key *)
// with return type: void
void init_timer_key(struct timer_list *arg0, unsigned int arg1, const char *arg2, struct lock_class_key *arg3) {
  // Void type
  return;
}

// Function: int_to_scsilun
// with type: void int_to_scsilun(u64 , struct scsi_lun *)
// with return type: void
void int_to_scsilun(u64 arg0, struct scsi_lun *arg1) {
  // Void type
  return;
}

// Function: iov_iter_kvec
// with type: void iov_iter_kvec(struct iov_iter *, int, const struct kvec *, unsigned long, size_t )
// with return type: void
void iov_iter_kvec(struct iov_iter *arg0, int arg1, const struct kvec *arg2, unsigned long arg3, size_t arg4) {
  // Void type
  return;
}

// Function: kernel_accept
// with type: int kernel_accept(struct socket *, struct socket **, int)
// with return type: int
int __VERIFIER_nondet_int(void);
int kernel_accept(struct socket *arg0, struct socket **arg1, int arg2) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: kernel_bind
// with type: int kernel_bind(struct socket *, struct sockaddr *, int)
// with return type: int
int __VERIFIER_nondet_int(void);
int kernel_bind(struct socket *arg0, struct sockaddr *arg1, int arg2) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: kernel_listen
// with type: int kernel_listen(struct socket *, int)
// with return type: int
int __VERIFIER_nondet_int(void);
int kernel_listen(struct socket *arg0, int arg1) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: kernel_sendmsg
// with type: int kernel_sendmsg(struct socket *, struct msghdr *, struct kvec *, size_t , size_t )
// with return type: int
int __VERIFIER_nondet_int(void);
int kernel_sendmsg(struct socket *arg0, struct msghdr *arg1, struct kvec *arg2, size_t arg3, size_t arg4) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: kernel_setsockopt
// with type: int kernel_setsockopt(struct socket *, int, int, char *, unsigned int)
// with return type: int
int __VERIFIER_nondet_int(void);
int kernel_setsockopt(struct socket *arg0, int arg1, int arg2, char *arg3, unsigned int arg4) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: kernel_sigaction
// with type: void kernel_sigaction(int, __sighandler_t )
// with return type: void
void kernel_sigaction(int arg0, __sighandler_t arg1) {
  // Void type
  return;
}

// Skip function: kfree

// Function: kmem_cache_alloc
// with type: void *kmem_cache_alloc(struct kmem_cache *, gfp_t )
// with return type: (void)*
void *kmem_cache_alloc(struct kmem_cache *arg0, gfp_t arg1) {
  // Pointer type
  return ldv_malloc(0UL);
}

// Function: kmem_cache_create
// with type: struct kmem_cache *kmem_cache_create(const char *, size_t , size_t , unsigned long, void (*)(void *))
// with return type: (struct kmem_cache)*
struct kmem_cache *kmem_cache_create(const char *arg0, size_t arg1, size_t arg2, unsigned long arg3, void (*arg4)(void *)) {
  // Pointer type
  return ldv_malloc(0UL);
}

// Function: kmem_cache_destroy
// with type: void kmem_cache_destroy(struct kmem_cache *)
// with return type: void
void kmem_cache_destroy(struct kmem_cache *arg0) {
  // Void type
  return;
}

// Function: kmem_cache_free
// with type: void kmem_cache_free(struct kmem_cache *, void *)
// with return type: void
void kmem_cache_free(struct kmem_cache *arg0, void *arg1) {
  // Void type
  return;
}

// Function: kmemdup
// with type: void *kmemdup(const void *, size_t , gfp_t )
// with return type: (void)*
void *kmemdup(const void *arg0, size_t arg1, gfp_t arg2) {
  // Pointer type
  return ldv_malloc(0UL);
}

// Function: kstrdup
// with type: char *kstrdup(const char *, gfp_t )
// with return type: (char)*
char *kstrdup(const char *arg0, gfp_t arg1) {
  // Pointer type
  return ldv_malloc(sizeof(char));
}

// Function: kstrtou16
// with type: int kstrtou16(const char *, unsigned int, u16 *)
// with return type: int
int __VERIFIER_nondet_int(void);
int kstrtou16(const char *arg0, unsigned int arg1, u16 *arg2) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: kstrtouint
// with type: int kstrtouint(const char *, unsigned int, unsigned int *)
// with return type: int
int __VERIFIER_nondet_int(void);
int kstrtouint(const char *arg0, unsigned int arg1, unsigned int *arg2) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: kstrtoull
// with type: int kstrtoull(const char *, unsigned int, unsigned long long *)
// with return type: int
int __VERIFIER_nondet_int(void);
int kstrtoull(const char *arg0, unsigned int arg1, unsigned long long *arg2) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: kthread_create_on_node
// with type: struct task_struct *kthread_create_on_node(int (*)(void *), void *, int, const char *, ...)
// with return type: (struct task_struct)*
struct task_struct *kthread_create_on_node(int (*arg0)(void *), void *arg1, int arg2, const char *arg3, ...) {
  // Pointer type
  return ldv_malloc(sizeof(struct task_struct));
}

// Function: kthread_should_stop
// with type: bool kthread_should_stop()
// with return type: bool 
bool __VERIFIER_nondet_bool(void);
bool kthread_should_stop() {
  // Typedef type
  // Real type: _Bool
  // Simple type
  return __VERIFIER_nondet_bool();
}

// Function: kthread_stop
// with type: int kthread_stop(struct task_struct *)
// with return type: int
int __VERIFIER_nondet_int(void);
int kthread_stop(struct task_struct *arg0) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: ldv__builtin_va_end
// with type: void ldv__builtin_va_end(__builtin_va_list *)
// with return type: void
void ldv__builtin_va_end(__builtin_va_list *arg0) {
  // Void type
  return;
}

// Function: ldv__builtin_va_start
// with type: void ldv__builtin_va_start(__builtin_va_list *)
// with return type: void
void ldv__builtin_va_start(__builtin_va_list *arg0) {
  // Void type
  return;
}

// Function: ldv_initialize
// with type: void ldv_initialize()
// with return type: void
void ldv_initialize() {
  // Void type
  return;
}

// Function: ldv_probe_62
// with type: int ldv_probe_62()
// with return type: int
int __VERIFIER_nondet_int(void);
int ldv_probe_62() {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: ldv_release_62
// with type: int ldv_release_62()
// with return type: int
int __VERIFIER_nondet_int(void);
int ldv_release_62() {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: list_del
// with type: void list_del(struct list_head *)
// with return type: void
void list_del(struct list_head *arg0) {
  // Void type
  return;
}

// Function: lockdep_init_map
// with type: void lockdep_init_map(struct lockdep_map *, const char *, struct lock_class_key *, int)
// with return type: void
void lockdep_init_map(struct lockdep_map *arg0, const char *arg1, struct lock_class_key *arg2, int arg3) {
  // Void type
  return;
}

// Skip function: malloc

// Skip function: memcmp

// Skip function: memcpy

// Skip function: memset

// Function: mod_timer
// with type: int mod_timer(struct timer_list *, unsigned long)
// with return type: int
int __VERIFIER_nondet_int(void);
int mod_timer(struct timer_list *arg0, unsigned long arg1) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: module_put
// with type: void module_put(struct module *)
// with return type: void
void module_put(struct module *arg0) {
  // Void type
  return;
}

// Function: msleep
// with type: void msleep(unsigned int)
// with return type: void
void msleep(unsigned int arg0) {
  // Void type
  return;
}

// Function: mutex_lock
// with type: void mutex_lock(struct mutex *)
// with return type: void
void mutex_lock(struct mutex *arg0) {
  // Void type
  return;
}

// Function: mutex_lock_interruptible
// with type: int mutex_lock_interruptible(struct mutex *)
// with return type: int
int __VERIFIER_nondet_int(void);
int mutex_lock_interruptible(struct mutex *arg0) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: mutex_trylock
// with type: int mutex_trylock(struct mutex *)
// with return type: int
int __VERIFIER_nondet_int(void);
int mutex_trylock(struct mutex *arg0) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: mutex_unlock
// with type: void mutex_unlock(struct mutex *)
// with return type: void
void mutex_unlock(struct mutex *arg0) {
  // Void type
  return;
}

// Function: percpu_ida_alloc
// with type: int percpu_ida_alloc(struct percpu_ida *, int)
// with return type: int
int __VERIFIER_nondet_int(void);
int percpu_ida_alloc(struct percpu_ida *arg0, int arg1) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: percpu_ida_free
// with type: void percpu_ida_free(struct percpu_ida *, unsigned int)
// with return type: void
void percpu_ida_free(struct percpu_ida *arg0, unsigned int arg1) {
  // Void type
  return;
}

// Function: prepare_to_wait_event
// with type: long int prepare_to_wait_event(wait_queue_head_t *, wait_queue_t *, int)
// with return type: long int
long __VERIFIER_nondet_long(void);
long int prepare_to_wait_event(wait_queue_head_t *arg0, wait_queue_t *arg1, int arg2) {
  // Simple type
  return __VERIFIER_nondet_long();
}

// Function: printk
// with type: int printk(const char *, ...)
// with return type: int
int __VERIFIER_nondet_int(void);
int printk(const char *arg0, ...) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: queue_delayed_work_on
// with type: bool queue_delayed_work_on(int, struct workqueue_struct *, struct delayed_work *, unsigned long)
// with return type: bool 
bool __VERIFIER_nondet_bool(void);
bool queue_delayed_work_on(int arg0, struct workqueue_struct *arg1, struct delayed_work *arg2, unsigned long arg3) {
  // Typedef type
  // Real type: _Bool
  // Simple type
  return __VERIFIER_nondet_bool();
}

// Function: queue_work_on
// with type: bool queue_work_on(int, struct workqueue_struct *, struct work_struct *)
// with return type: bool 
bool __VERIFIER_nondet_bool(void);
bool queue_work_on(int arg0, struct workqueue_struct *arg1, struct work_struct *arg2) {
  // Typedef type
  // Real type: _Bool
  // Simple type
  return __VERIFIER_nondet_bool();
}

// Function: schedule
// with type: void schedule()
// with return type: void
void schedule() {
  // Void type
  return;
}

// Function: scsilun_to_int
// with type: u64 scsilun_to_int(struct scsi_lun *)
// with return type: u64 
unsigned long __VERIFIER_nondet_ulong(void);
u64 scsilun_to_int(struct scsi_lun *arg0) {
  // Typedef type
  // Real type: unsigned long long
  // Simple type
  return __VERIFIER_nondet_ulong();
}

// Function: send_sig
// with type: int send_sig(int, struct task_struct *, int)
// with return type: int
int __VERIFIER_nondet_int(void);
int send_sig(int arg0, struct task_struct *arg1, int arg2) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: set_cpus_allowed_ptr
// with type: int set_cpus_allowed_ptr(struct task_struct *, const struct cpumask *)
// with return type: int
int __VERIFIER_nondet_int(void);
int set_cpus_allowed_ptr(struct task_struct *arg0, const struct cpumask *arg1) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: sg_init_one
// with type: void sg_init_one(struct scatterlist *, const void *, unsigned int)
// with return type: void
void sg_init_one(struct scatterlist *arg0, const void *arg1, unsigned int arg2) {
  // Void type
  return;
}

// Function: sg_next
// with type: struct scatterlist *sg_next(struct scatterlist *)
// with return type: (struct scatterlist)*
struct scatterlist *sg_next(struct scatterlist *arg0) {
  // Pointer type
  return ldv_malloc(sizeof(struct scatterlist));
}

// Function: simple_strtoul
// with type: unsigned long int simple_strtoul(const char *, char **, unsigned int)
// with return type: unsigned long int
unsigned long __VERIFIER_nondet_ulong(void);
unsigned long int simple_strtoul(const char *arg0, char **arg1, unsigned int arg2) {
  // Simple type
  return __VERIFIER_nondet_ulong();
}

// Skip function: snprintf

// Function: sock_create
// with type: int sock_create(int, int, int, struct socket **)
// with return type: int
int __VERIFIER_nondet_int(void);
int sock_create(int arg0, int arg1, int arg2, struct socket **arg3) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: sock_recvmsg
// with type: int sock_recvmsg(struct socket *, struct msghdr *, size_t , int)
// with return type: int
int __VERIFIER_nondet_int(void);
int sock_recvmsg(struct socket *arg0, struct msghdr *arg1, size_t arg2, int arg3) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: sock_release
// with type: void sock_release(struct socket *)
// with return type: void
void sock_release(struct socket *arg0) {
  // Void type
  return;
}

// Skip function: sprintf

// Skip function: strchr

// Skip function: strcmp

// Skip function: strcpy

// Function: strlcpy
// with type: size_t strlcpy(char *, const char *, size_t )
// with return type: size_t 
unsigned long __VERIFIER_nondet_ulong(void);
size_t strlcpy(char *arg0, const char *arg1, size_t arg2) {
  // Typedef type
  // Real type: __kernel_size_t 
  // Typedef type
  // Real type: __kernel_ulong_t 
  // Typedef type
  // Real type: unsigned long
  // Simple type
  return __VERIFIER_nondet_ulong();
}

// Skip function: strlen

// Skip function: strncat

// Skip function: strncmp

// Function: strsep
// with type: char *strsep(char **, const char *)
// with return type: (char)*
char *strsep(char **arg0, const char *arg1) {
  // Pointer type
  return ldv_malloc(sizeof(char));
}

// Skip function: strstr

// Function: target_execute_cmd
// with type: void target_execute_cmd(struct se_cmd *)
// with return type: void
void target_execute_cmd(struct se_cmd *arg0) {
  // Void type
  return;
}

// Function: target_get_sess_cmd
// with type: int target_get_sess_cmd(struct se_cmd *, bool )
// with return type: int
int __VERIFIER_nondet_int(void);
int target_get_sess_cmd(struct se_cmd *arg0, bool arg1) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: target_put_sess_cmd
// with type: int target_put_sess_cmd(struct se_cmd *)
// with return type: int
int __VERIFIER_nondet_int(void);
int target_put_sess_cmd(struct se_cmd *arg0) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: target_put_session
// with type: void target_put_session(struct se_session *)
// with return type: void
void target_put_session(struct se_session *arg0) {
  // Void type
  return;
}

// Function: target_register_template
// with type: int target_register_template(const struct target_core_fabric_ops *)
// with return type: int
int __VERIFIER_nondet_int(void);
int target_register_template(const struct target_core_fabric_ops *arg0) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: target_setup_cmd_from_cdb
// with type: sense_reason_t target_setup_cmd_from_cdb(struct se_cmd *, unsigned char *)
// with return type: sense_reason_t 
unsigned int __VERIFIER_nondet_uint(void);
sense_reason_t target_setup_cmd_from_cdb(struct se_cmd *arg0, unsigned char *arg1) {
  // Typedef type
  // Real type: unsigned int
  // Simple type
  return __VERIFIER_nondet_uint();
}

// Function: target_show_dynamic_sessions
// with type: ssize_t target_show_dynamic_sessions(struct se_portal_group *, char *)
// with return type: ssize_t 
long __VERIFIER_nondet_long(void);
ssize_t target_show_dynamic_sessions(struct se_portal_group *arg0, char *arg1) {
  // Typedef type
  // Real type: __kernel_ssize_t 
  // Typedef type
  // Real type: __kernel_long_t 
  // Typedef type
  // Real type: long
  // Simple type
  return __VERIFIER_nondet_long();
}

// Function: target_unregister_template
// with type: void target_unregister_template(const struct target_core_fabric_ops *)
// with return type: void
void target_unregister_template(const struct target_core_fabric_ops *arg0) {
  // Void type
  return;
}

// Function: transport_alloc_session_tags
// with type: int transport_alloc_session_tags(struct se_session *, unsigned int, unsigned int)
// with return type: int
int __VERIFIER_nondet_int(void);
int transport_alloc_session_tags(struct se_session *arg0, unsigned int arg1, unsigned int arg2) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: transport_check_aborted_status
// with type: int transport_check_aborted_status(struct se_cmd *, int)
// with return type: int
int __VERIFIER_nondet_int(void);
int transport_check_aborted_status(struct se_cmd *arg0, int arg1) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: transport_deregister_session
// with type: void transport_deregister_session(struct se_session *)
// with return type: void
void transport_deregister_session(struct se_session *arg0) {
  // Void type
  return;
}

// Function: transport_deregister_session_configfs
// with type: void transport_deregister_session_configfs(struct se_session *)
// with return type: void
void transport_deregister_session_configfs(struct se_session *arg0) {
  // Void type
  return;
}

// Function: transport_free_session
// with type: void transport_free_session(struct se_session *)
// with return type: void
void transport_free_session(struct se_session *arg0) {
  // Void type
  return;
}

// Function: transport_generic_free_cmd
// with type: int transport_generic_free_cmd(struct se_cmd *, int)
// with return type: int
int __VERIFIER_nondet_int(void);
int transport_generic_free_cmd(struct se_cmd *arg0, int arg1) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: transport_generic_handle_tmr
// with type: int transport_generic_handle_tmr(struct se_cmd *)
// with return type: int
int __VERIFIER_nondet_int(void);
int transport_generic_handle_tmr(struct se_cmd *arg0) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: transport_generic_new_cmd
// with type: sense_reason_t transport_generic_new_cmd(struct se_cmd *)
// with return type: sense_reason_t 
unsigned int __VERIFIER_nondet_uint(void);
sense_reason_t transport_generic_new_cmd(struct se_cmd *arg0) {
  // Typedef type
  // Real type: unsigned int
  // Simple type
  return __VERIFIER_nondet_uint();
}

// Function: transport_handle_cdb_direct
// with type: int transport_handle_cdb_direct(struct se_cmd *)
// with return type: int
int __VERIFIER_nondet_int(void);
int transport_handle_cdb_direct(struct se_cmd *arg0) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: transport_init_se_cmd
// with type: void transport_init_se_cmd(struct se_cmd *, const struct target_core_fabric_ops *, struct se_session *, u32 , int, int, unsigned char *)
// with return type: void
void transport_init_se_cmd(struct se_cmd *arg0, const struct target_core_fabric_ops *arg1, struct se_session *arg2, u32 arg3, int arg4, int arg5, unsigned char *arg6) {
  // Void type
  return;
}

// Function: transport_init_session
// with type: struct se_session *transport_init_session(enum target_prot_op )
// with return type: (struct se_session)*
struct se_session *transport_init_session(enum target_prot_op arg0) {
  // Pointer type
  return ldv_malloc(sizeof(struct se_session));
}

// Function: transport_lookup_cmd_lun
// with type: sense_reason_t transport_lookup_cmd_lun(struct se_cmd *, u64 )
// with return type: sense_reason_t 
unsigned int __VERIFIER_nondet_uint(void);
sense_reason_t transport_lookup_cmd_lun(struct se_cmd *arg0, u64 arg1) {
  // Typedef type
  // Real type: unsigned int
  // Simple type
  return __VERIFIER_nondet_uint();
}

// Function: transport_lookup_tmr_lun
// with type: int transport_lookup_tmr_lun(struct se_cmd *, u64 )
// with return type: int
int __VERIFIER_nondet_int(void);
int transport_lookup_tmr_lun(struct se_cmd *arg0, u64 arg1) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: transport_send_check_condition_and_sense
// with type: int transport_send_check_condition_and_sense(struct se_cmd *, sense_reason_t , int)
// with return type: int
int __VERIFIER_nondet_int(void);
int transport_send_check_condition_and_sense(struct se_cmd *arg0, sense_reason_t arg1, int arg2) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: transport_wait_for_tasks
// with type: bool transport_wait_for_tasks(struct se_cmd *)
// with return type: bool 
bool __VERIFIER_nondet_bool(void);
bool transport_wait_for_tasks(struct se_cmd *arg0) {
  // Typedef type
  // Real type: _Bool
  // Simple type
  return __VERIFIER_nondet_bool();
}

// Function: try_module_get
// with type: bool try_module_get(struct module *)
// with return type: bool 
bool __VERIFIER_nondet_bool(void);
bool try_module_get(struct module *arg0) {
  // Typedef type
  // Real type: _Bool
  // Simple type
  return __VERIFIER_nondet_bool();
}

// Function: up
// with type: void up(struct semaphore *)
// with return type: void
void up(struct semaphore *arg0) {
  // Void type
  return;
}

// Function: vfree
// with type: void vfree(const void *)
// with return type: void
void vfree(const void *arg0) {
  // Void type
  return;
}

// Skip function: vsnprintf

// Function: vzalloc
// with type: void *vzalloc(unsigned long)
// with return type: (void)*
void *vzalloc(unsigned long arg0) {
  // Pointer type
  return ldv_malloc(0UL);
}

// Function: wait_for_completion
// with type: void wait_for_completion(struct completion *)
// with return type: void
void wait_for_completion(struct completion *arg0) {
  // Void type
  return;
}

// Function: wait_for_completion_interruptible
// with type: int wait_for_completion_interruptible(struct completion *)
// with return type: int
int __VERIFIER_nondet_int(void);
int wait_for_completion_interruptible(struct completion *arg0) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: wait_for_completion_interruptible_timeout
// with type: long int wait_for_completion_interruptible_timeout(struct completion *, unsigned long)
// with return type: long int
long __VERIFIER_nondet_long(void);
long int wait_for_completion_interruptible_timeout(struct completion *arg0, unsigned long arg1) {
  // Simple type
  return __VERIFIER_nondet_long();
}

// Function: wait_for_completion_timeout
// with type: unsigned long int wait_for_completion_timeout(struct completion *, unsigned long)
// with return type: unsigned long int
unsigned long __VERIFIER_nondet_ulong(void);
unsigned long int wait_for_completion_timeout(struct completion *arg0, unsigned long arg1) {
  // Simple type
  return __VERIFIER_nondet_ulong();
}

// Function: wake_up_process
// with type: int wake_up_process(struct task_struct *)
// with return type: int
int __VERIFIER_nondet_int(void);
int wake_up_process(struct task_struct *arg0) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: warn_slowpath_null
// with type: void warn_slowpath_null(const char *, const int)
// with return type: void
void warn_slowpath_null(const char *arg0, const int arg1) {
  // Void type
  return;
}

// Function: zalloc_cpumask_var
// with type: bool zalloc_cpumask_var(cpumask_var_t **, gfp_t )
// with return type: bool 
bool __VERIFIER_nondet_bool(void);
bool zalloc_cpumask_var(cpumask_var_t **arg0, gfp_t arg1) {
  // Typedef type
  // Real type: _Bool
  // Simple type
  return __VERIFIER_nondet_bool();
}