// Skip function: __VERIFIER_error

// Skip function: __VERIFIER_nondet_int

// Skip function: __VERIFIER_nondet_ulong

// Function: ___ratelimit
// with type: int ___ratelimit(struct ratelimit_state *, const char *)
// with return type: int
int __VERIFIER_nondet_int(void);
int ___ratelimit(struct ratelimit_state *arg0, const char *arg1) {
  // Simple type
  return __VERIFIER_nondet_int();
}

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

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

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

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

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

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

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

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

// 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: __free_pages
// with type: void __free_pages(struct page *, unsigned int)
// with return type: void
void __free_pages(struct page *arg0, unsigned int arg1) {
  // 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: __ldv_linux_kernel_locking_spinlock_spin_lock
// with type: void __ldv_linux_kernel_locking_spinlock_spin_lock(spinlock_t *)
// with return type: void
void __ldv_linux_kernel_locking_spinlock_spin_lock(spinlock_t *arg0) {
  // 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: __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: __phys_addr
// with type: unsigned long int __phys_addr(unsigned long)
// with return type: unsigned long int
unsigned long __VERIFIER_nondet_ulong(void);
unsigned long int __phys_addr(unsigned long arg0) {
  // Simple type
  return __VERIFIER_nondet_ulong();
}

// 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: __xenbus_register_frontend
// with type: int __xenbus_register_frontend(struct xenbus_driver *, struct module *, const char *)
// with return type: int
int __VERIFIER_nondet_int(void);
int __xenbus_register_frontend(struct xenbus_driver *arg0, struct module *arg1, const char *arg2) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: _dev_info
// with type: void _dev_info(const struct device *, const char *, ...)
// with return type: void
void _dev_info(const struct device *arg0, const char *arg1, ...) {
  // 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_irq
// with type: void _raw_spin_lock_irq(raw_spinlock_t *)
// with return type: void
void _raw_spin_lock_irq(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_irq
// with type: void _raw_spin_unlock_irq(raw_spinlock_t *)
// with return type: void
void _raw_spin_unlock_irq(raw_spinlock_t *arg0) {
  // Void type
  return;
}

// Function: _raw_spin_unlock_irqrestore
// with type: void _raw_spin_unlock_irqrestore(raw_spinlock_t *, unsigned long)
// with return type: void
void _raw_spin_unlock_irqrestore(raw_spinlock_t *arg0, unsigned long arg1) {
  // Void type
  return;
}

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

// Function: alloc_disk
// with type: struct gendisk *alloc_disk(int)
// with return type: (struct gendisk)*
struct gendisk *alloc_disk(int arg0) {
  // Pointer type
  return ldv_malloc(sizeof(struct gendisk));
}

// Function: bdget_disk
// with type: struct block_device *bdget_disk(struct gendisk *, int)
// with return type: (struct block_device)*
struct block_device *bdget_disk(struct gendisk *arg0, int arg1) {
  // Pointer type
  return ldv_malloc(sizeof(struct block_device));
}

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

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

// Function: bio_clone_bioset
// with type: struct bio *bio_clone_bioset(struct bio *, gfp_t , struct bio_set *)
// with return type: (struct bio)*
struct bio *bio_clone_bioset(struct bio *arg0, gfp_t arg1, struct bio_set *arg2) {
  // Pointer type
  return ldv_malloc(sizeof(struct bio));
}

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

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

// Function: bio_trim
// with type: void bio_trim(struct bio *, int, int)
// with return type: void
void bio_trim(struct bio *arg0, int arg1, int arg2) {
  // Void type
  return;
}

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

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

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

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

// Function: blk_fetch_request
// with type: struct request *blk_fetch_request(struct request_queue *)
// with return type: (struct request)*
struct request *blk_fetch_request(struct request_queue *arg0) {
  // Pointer type
  return ldv_malloc(sizeof(struct request));
}

// Function: blk_init_queue
// with type: struct request_queue *blk_init_queue(void (*)(struct request_queue *), spinlock_t *)
// with return type: (struct request_queue)*
struct request_queue *blk_init_queue(void (*arg0)(struct request_queue *), spinlock_t *arg1) {
  // Pointer type
  return ldv_malloc(sizeof(struct request_queue));
}

// Function: blk_peek_request
// with type: struct request *blk_peek_request(struct request_queue *)
// with return type: (struct request)*
struct request *blk_peek_request(struct request_queue *arg0) {
  // Pointer type
  return ldv_malloc(sizeof(struct request));
}

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

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

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

// Function: blk_queue_logical_block_size
// with type: void blk_queue_logical_block_size(struct request_queue *, unsigned short)
// with return type: void
void blk_queue_logical_block_size(struct request_queue *arg0, unsigned short arg1) {
  // Void type
  return;
}

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

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

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

// Function: blk_queue_max_segments
// with type: void blk_queue_max_segments(struct request_queue *, unsigned short)
// with return type: void
void blk_queue_max_segments(struct request_queue *arg0, unsigned short arg1) {
  // Void type
  return;
}

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

// Function: blk_queue_segment_boundary
// with type: void blk_queue_segment_boundary(struct request_queue *, unsigned long)
// with return type: void
void blk_queue_segment_boundary(struct request_queue *arg0, unsigned long arg1) {
  // Void type
  return;
}

// Function: blk_requeue_request
// with type: void blk_requeue_request(struct request_queue *, struct request *)
// with return type: void
void blk_requeue_request(struct request_queue *arg0, struct request *arg1) {
  // Void type
  return;
}

// Function: blk_rq_map_sg
// with type: int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *)
// with return type: int
int __VERIFIER_nondet_int(void);
int blk_rq_map_sg(struct request_queue *arg0, struct request *arg1, struct scatterlist *arg2) {
  // Simple type
  return __VERIFIER_nondet_int();
}

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

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

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

// Skip function: calloc

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

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

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

// Skip function: free

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

// Function: get_phys_to_machine
// with type: unsigned long int get_phys_to_machine(unsigned long)
// with return type: unsigned long int
unsigned long __VERIFIER_nondet_ulong(void);
unsigned long int get_phys_to_machine(unsigned long arg0) {
  // Simple type
  return __VERIFIER_nondet_ulong();
}

// Function: gnttab_alloc_grant_references
// with type: int gnttab_alloc_grant_references(u16 , grant_ref_t *)
// with return type: int
int __VERIFIER_nondet_int(void);
int gnttab_alloc_grant_references(u16 arg0, grant_ref_t *arg1) {
  // Simple type
  return __VERIFIER_nondet_int();
}

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

// Function: gnttab_claim_grant_reference
// with type: int gnttab_claim_grant_reference(grant_ref_t *)
// with return type: int
int __VERIFIER_nondet_int(void);
int gnttab_claim_grant_reference(grant_ref_t *arg0) {
  // Simple type
  return __VERIFIER_nondet_int();
}

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

// Function: gnttab_free_grant_references
// with type: void gnttab_free_grant_references(grant_ref_t )
// with return type: void
void gnttab_free_grant_references(grant_ref_t arg0) {
  // Void type
  return;
}

// Function: gnttab_grant_foreign_access_ref
// with type: void gnttab_grant_foreign_access_ref(grant_ref_t , domid_t , unsigned long, int)
// with return type: void
void gnttab_grant_foreign_access_ref(grant_ref_t arg0, domid_t arg1, unsigned long arg2, int arg3) {
  // Void type
  return;
}

// Function: gnttab_query_foreign_access
// with type: int gnttab_query_foreign_access(grant_ref_t )
// with return type: int
int __VERIFIER_nondet_int(void);
int gnttab_query_foreign_access(grant_ref_t arg0) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: gnttab_request_free_callback
// with type: void gnttab_request_free_callback(struct gnttab_free_callback *, void (*)(void *), void *, u16 )
// with return type: void
void gnttab_request_free_callback(struct gnttab_free_callback *arg0, void (*arg1)(void *), void *arg2, u16 arg3) {
  // Void type
  return;
}

// Skip function: kfree

// 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: ldv_after_alloc
// with type: void ldv_after_alloc(void *)
// with return type: void
void ldv_after_alloc(void *arg0) {
  // Void type
  return;
}

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

// 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: lock_is_held
// with type: int lock_is_held(struct lockdep_map *)
// with return type: int
int __VERIFIER_nondet_int(void);
int lock_is_held(struct lockdep_map *arg0) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// 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: memcpy

// Skip function: memset

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

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

// 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: put_disk
// with type: void put_disk(struct gendisk *)
// with return type: void
void put_disk(struct gendisk *arg0) {
  // Void type
  return;
}

// 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: register_blkdev
// with type: int register_blkdev(unsigned int, const char *)
// with return type: int
int __VERIFIER_nondet_int(void);
int register_blkdev(unsigned int arg0, const char *arg1) {
  // Simple type
  return __VERIFIER_nondet_int();
}

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

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

// Function: sg_init_table
// with type: void sg_init_table(struct scatterlist *, unsigned int)
// with return type: void
void sg_init_table(struct scatterlist *arg0, unsigned int arg1) {
  // 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

// Skip function: strcpy

// Skip function: strncmp

// Skip function: strrchr

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

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

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

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

// 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: xen_has_pv_and_legacy_disk_devices
// with type: bool xen_has_pv_and_legacy_disk_devices()
// with return type: bool 
bool __VERIFIER_nondet_bool(void);
bool xen_has_pv_and_legacy_disk_devices() {
  // Typedef type
  // Real type: _Bool
  // Simple type
  return __VERIFIER_nondet_bool();
}

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

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

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

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

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

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

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

// Function: xenbus_printf
// with type: int xenbus_printf(struct xenbus_transaction , const char *, const char *, const char *, ...)
// with return type: int
int __VERIFIER_nondet_int(void);
int xenbus_printf(struct xenbus_transaction arg0, const char *arg1, const char *arg2, const char *arg3, ...) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: xenbus_read
// with type: void *xenbus_read(struct xenbus_transaction , const char *, const char *, unsigned int *)
// with return type: (void)*
void *xenbus_read(struct xenbus_transaction arg0, const char *arg1, const char *arg2, unsigned int *arg3) {
  // Pointer type
  return ldv_malloc(0UL);
}

// Function: xenbus_scanf
// with type: int xenbus_scanf(struct xenbus_transaction , const char *, const char *, const char *, ...)
// with return type: int
int __VERIFIER_nondet_int(void);
int xenbus_scanf(struct xenbus_transaction arg0, const char *arg1, const char *arg2, const char *arg3, ...) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: xenbus_switch_state
// with type: int xenbus_switch_state(struct xenbus_device *, enum xenbus_state )
// with return type: int
int __VERIFIER_nondet_int(void);
int xenbus_switch_state(struct xenbus_device *arg0, enum xenbus_state arg1) {
  // Simple type
  return __VERIFIER_nondet_int();
}

// Function: xenbus_transaction_end
// with type: int xenbus_transaction_end(struct xenbus_transaction , int)
// with return type: int
int __VERIFIER_nondet_int(void);
int xenbus_transaction_end(struct xenbus_transaction arg0, int arg1) {
  // Simple type
  return __VERIFIER_nondet_int();
}

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

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