wine/server/request_handlers.h

/*
 * Wine server protocol definitions
 *
 * This file is automatically generated; DO NO EDIT!
 * Edit server/protocol.def instead and re-run tools/make_requests
 */

#include "request.h"

DECL_HANDLER(new_process);
DECL_HANDLER(get_new_process_info);
DECL_HANDLER(new_thread);
DECL_HANDLER(get_startup_info);
DECL_HANDLER(init_process_done);
DECL_HANDLER(init_first_thread);
DECL_HANDLER(init_thread);
DECL_HANDLER(terminate_process);
DECL_HANDLER(terminate_thread);
DECL_HANDLER(get_process_info);
DECL_HANDLER(get_process_debug_info);
DECL_HANDLER(get_process_image_name);
DECL_HANDLER(get_process_vm_counters);
DECL_HANDLER(set_process_info);
DECL_HANDLER(get_thread_info);
DECL_HANDLER(get_thread_times);
DECL_HANDLER(set_thread_info);
DECL_HANDLER(suspend_thread);
DECL_HANDLER(resume_thread);
DECL_HANDLER(queue_apc);
DECL_HANDLER(get_apc_result);
DECL_HANDLER(close_handle);
DECL_HANDLER(set_handle_info);
DECL_HANDLER(dup_handle);
DECL_HANDLER(allocate_reserve_object);
DECL_HANDLER(compare_objects);
DECL_HANDLER(set_object_permanence);
DECL_HANDLER(open_process);
DECL_HANDLER(open_thread);
DECL_HANDLER(select);
DECL_HANDLER(create_event);
DECL_HANDLER(event_op);
DECL_HANDLER(query_event);
DECL_HANDLER(open_event);
DECL_HANDLER(create_keyed_event);
DECL_HANDLER(open_keyed_event);
DECL_HANDLER(create_mutex);
DECL_HANDLER(release_mutex);
DECL_HANDLER(open_mutex);
DECL_HANDLER(query_mutex);
DECL_HANDLER(create_semaphore);
DECL_HANDLER(release_semaphore);
DECL_HANDLER(query_semaphore);
DECL_HANDLER(open_semaphore);
DECL_HANDLER(create_file);
DECL_HANDLER(open_file_object);
DECL_HANDLER(alloc_file_handle);
DECL_HANDLER(get_handle_unix_name);
DECL_HANDLER(get_handle_fd);
DECL_HANDLER(get_directory_cache_entry);
DECL_HANDLER(flush);
DECL_HANDLER(get_file_info);
DECL_HANDLER(get_volume_info);
DECL_HANDLER(lock_file);
DECL_HANDLER(unlock_file);
DECL_HANDLER(recv_socket);
DECL_HANDLER(send_socket);
DECL_HANDLER(socket_get_events);
DECL_HANDLER(socket_send_icmp_id);
DECL_HANDLER(socket_get_icmp_id);
DECL_HANDLER(get_next_console_request);
DECL_HANDLER(read_directory_changes);
DECL_HANDLER(read_change);
DECL_HANDLER(create_mapping);
DECL_HANDLER(open_mapping);
DECL_HANDLER(get_mapping_info);
DECL_HANDLER(get_image_map_address);
DECL_HANDLER(map_view);
DECL_HANDLER(map_image_view);
DECL_HANDLER(map_builtin_view);
DECL_HANDLER(get_image_view_info);
DECL_HANDLER(unmap_view);
DECL_HANDLER(get_mapping_committed_range);
DECL_HANDLER(add_mapping_committed_range);
DECL_HANDLER(is_same_mapping);
DECL_HANDLER(get_mapping_filename);
DECL_HANDLER(list_processes);
DECL_HANDLER(create_debug_obj);
DECL_HANDLER(wait_debug_event);
DECL_HANDLER(queue_exception_event);
DECL_HANDLER(get_exception_status);
DECL_HANDLER(continue_debug_event);
DECL_HANDLER(debug_process);
DECL_HANDLER(set_debug_obj_info);
DECL_HANDLER(read_process_memory);
DECL_HANDLER(write_process_memory);
DECL_HANDLER(create_key);
DECL_HANDLER(open_key);
DECL_HANDLER(delete_key);
DECL_HANDLER(flush_key);
DECL_HANDLER(enum_key);
DECL_HANDLER(set_key_value);
DECL_HANDLER(get_key_value);
DECL_HANDLER(enum_key_value);
DECL_HANDLER(delete_key_value);
DECL_HANDLER(load_registry);
DECL_HANDLER(unload_registry);
DECL_HANDLER(save_registry);
DECL_HANDLER(set_registry_notification);
DECL_HANDLER(rename_key);
DECL_HANDLER(create_timer);
DECL_HANDLER(open_timer);
DECL_HANDLER(set_timer);
DECL_HANDLER(cancel_timer);
DECL_HANDLER(get_timer_info);
DECL_HANDLER(get_thread_context);
DECL_HANDLER(set_thread_context);
DECL_HANDLER(get_selector_entry);
DECL_HANDLER(add_atom);
DECL_HANDLER(delete_atom);
DECL_HANDLER(find_atom);
DECL_HANDLER(get_atom_information);
DECL_HANDLER(get_msg_queue_handle);
DECL_HANDLER(get_msg_queue);
DECL_HANDLER(set_queue_fd);
DECL_HANDLER(set_queue_mask);
DECL_HANDLER(get_queue_status);
DECL_HANDLER(get_process_idle_event);
DECL_HANDLER(send_message);
DECL_HANDLER(post_quit_message);
DECL_HANDLER(send_hardware_message);
DECL_HANDLER(get_message);
DECL_HANDLER(reply_message);
DECL_HANDLER(accept_hardware_message);
DECL_HANDLER(get_message_reply);
DECL_HANDLER(set_win_timer);
DECL_HANDLER(kill_win_timer);
DECL_HANDLER(is_window_hung);
DECL_HANDLER(get_serial_info);
DECL_HANDLER(set_serial_info);
DECL_HANDLER(cancel_sync);
DECL_HANDLER(register_async);
DECL_HANDLER(cancel_async);
DECL_HANDLER(get_async_result);
DECL_HANDLER(set_async_direct_result);
DECL_HANDLER(read);
DECL_HANDLER(write);
DECL_HANDLER(ioctl);
DECL_HANDLER(set_irp_result);
DECL_HANDLER(create_named_pipe);
DECL_HANDLER(set_named_pipe_info);
DECL_HANDLER(create_window);
DECL_HANDLER(destroy_window);
DECL_HANDLER(get_desktop_window);
DECL_HANDLER(set_window_owner);
DECL_HANDLER(get_window_info);
DECL_HANDLER(set_window_info);
DECL_HANDLER(set_parent);
DECL_HANDLER(get_window_parents);
DECL_HANDLER(get_window_children);
DECL_HANDLER(get_window_children_from_point);
DECL_HANDLER(get_window_tree);
DECL_HANDLER(set_window_pos);
DECL_HANDLER(get_window_rectangles);
DECL_HANDLER(get_window_text);
DECL_HANDLER(set_window_text);
DECL_HANDLER(get_windows_offset);
DECL_HANDLER(get_visible_region);
DECL_HANDLER(get_window_region);
DECL_HANDLER(set_window_region);
DECL_HANDLER(get_update_region);
DECL_HANDLER(update_window_zorder);
DECL_HANDLER(redraw_window);
DECL_HANDLER(set_window_property);
DECL_HANDLER(remove_window_property);
DECL_HANDLER(get_window_property);
DECL_HANDLER(get_window_properties);
DECL_HANDLER(create_winstation);
DECL_HANDLER(open_winstation);
DECL_HANDLER(close_winstation);
DECL_HANDLER(set_winstation_monitors);
DECL_HANDLER(get_process_winstation);
DECL_HANDLER(set_process_winstation);
DECL_HANDLER(enum_winstation);
DECL_HANDLER(create_desktop);
DECL_HANDLER(open_desktop);
DECL_HANDLER(open_input_desktop);
DECL_HANDLER(set_input_desktop);
DECL_HANDLER(close_desktop);
DECL_HANDLER(get_thread_desktop);
DECL_HANDLER(set_thread_desktop);
DECL_HANDLER(set_user_object_info);
DECL_HANDLER(register_hotkey);
DECL_HANDLER(unregister_hotkey);
DECL_HANDLER(attach_thread_input);
DECL_HANDLER(get_thread_input);
DECL_HANDLER(get_last_input_time);
DECL_HANDLER(get_key_state);
DECL_HANDLER(set_key_state);
DECL_HANDLER(set_foreground_window);
DECL_HANDLER(set_focus_window);
DECL_HANDLER(set_active_window);
DECL_HANDLER(set_capture_window);
DECL_HANDLER(set_caret_window);
DECL_HANDLER(set_caret_info);
DECL_HANDLER(set_hook);
DECL_HANDLER(remove_hook);
DECL_HANDLER(start_hook_chain);
DECL_HANDLER(finish_hook_chain);
DECL_HANDLER(get_hook_info);
DECL_HANDLER(create_class);
DECL_HANDLER(destroy_class);
DECL_HANDLER(set_class_info);
DECL_HANDLER(open_clipboard);
DECL_HANDLER(close_clipboard);
DECL_HANDLER(empty_clipboard);
DECL_HANDLER(set_clipboard_data);
DECL_HANDLER(get_clipboard_data);
DECL_HANDLER(get_clipboard_formats);
DECL_HANDLER(enum_clipboard_formats);
DECL_HANDLER(release_clipboard);
DECL_HANDLER(get_clipboard_info);
DECL_HANDLER(set_clipboard_viewer);
DECL_HANDLER(add_clipboard_listener);
DECL_HANDLER(remove_clipboard_listener);
DECL_HANDLER(create_token);
DECL_HANDLER(open_token);
DECL_HANDLER(set_desktop_shell_windows);
DECL_HANDLER(adjust_token_privileges);
DECL_HANDLER(get_token_privileges);
DECL_HANDLER(check_token_privileges);
DECL_HANDLER(duplicate_token);
DECL_HANDLER(filter_token);
DECL_HANDLER(access_check);
DECL_HANDLER(get_token_sid);
DECL_HANDLER(get_token_groups);
DECL_HANDLER(get_token_default_dacl);
DECL_HANDLER(set_token_default_dacl);
DECL_HANDLER(set_security_object);
DECL_HANDLER(get_security_object);
DECL_HANDLER(get_system_handles);
DECL_HANDLER(get_tcp_connections);
DECL_HANDLER(get_udp_endpoints);
DECL_HANDLER(create_mailslot);
DECL_HANDLER(set_mailslot_info);
DECL_HANDLER(create_directory);
DECL_HANDLER(open_directory);
DECL_HANDLER(get_directory_entries);
DECL_HANDLER(create_symlink);
DECL_HANDLER(open_symlink);
DECL_HANDLER(query_symlink);
DECL_HANDLER(get_object_info);
DECL_HANDLER(get_object_name);
DECL_HANDLER(get_object_type);
DECL_HANDLER(get_object_types);
DECL_HANDLER(allocate_locally_unique_id);
DECL_HANDLER(create_device_manager);
DECL_HANDLER(create_device);
DECL_HANDLER(delete_device);
DECL_HANDLER(get_next_device_request);
DECL_HANDLER(get_kernel_object_ptr);
DECL_HANDLER(set_kernel_object_ptr);
DECL_HANDLER(grab_kernel_object);
DECL_HANDLER(release_kernel_object);
DECL_HANDLER(get_kernel_object_handle);
DECL_HANDLER(make_process_system);
DECL_HANDLER(get_token_info);
DECL_HANDLER(create_linked_token);
DECL_HANDLER(create_completion);
DECL_HANDLER(open_completion);
DECL_HANDLER(add_completion);
DECL_HANDLER(remove_completion);
DECL_HANDLER(get_thread_completion);
DECL_HANDLER(query_completion);
DECL_HANDLER(set_completion_info);
DECL_HANDLER(add_fd_completion);
DECL_HANDLER(set_fd_completion_mode);
DECL_HANDLER(set_fd_disp_info);
DECL_HANDLER(set_fd_name_info);
DECL_HANDLER(set_fd_eof_info);
DECL_HANDLER(get_window_layered_info);
DECL_HANDLER(set_window_layered_info);
DECL_HANDLER(alloc_user_handle);
DECL_HANDLER(free_user_handle);
DECL_HANDLER(set_cursor);
DECL_HANDLER(get_cursor_history);
DECL_HANDLER(get_rawinput_buffer);
DECL_HANDLER(update_rawinput_devices);
DECL_HANDLER(create_job);
DECL_HANDLER(open_job);
DECL_HANDLER(assign_job);
DECL_HANDLER(process_in_job);
DECL_HANDLER(set_job_limits);
DECL_HANDLER(set_job_completion_port);
DECL_HANDLER(get_job_info);
DECL_HANDLER(terminate_job);
DECL_HANDLER(suspend_process);
DECL_HANDLER(resume_process);
DECL_HANDLER(get_next_thread);
DECL_HANDLER(set_keyboard_repeat);

typedef void (*req_handler)( const void *req, void *reply );
static const req_handler req_handlers[REQ_NB_REQUESTS] =
{
    (req_handler)req_new_process,
    (req_handler)req_get_new_process_info,
    (req_handler)req_new_thread,
    (req_handler)req_get_startup_info,
    (req_handler)req_init_process_done,
    (req_handler)req_init_first_thread,
    (req_handler)req_init_thread,
    (req_handler)req_terminate_process,
    (req_handler)req_terminate_thread,
    (req_handler)req_get_process_info,
    (req_handler)req_get_process_debug_info,
    (req_handler)req_get_process_image_name,
    (req_handler)req_get_process_vm_counters,
    (req_handler)req_set_process_info,
    (req_handler)req_get_thread_info,
    (req_handler)req_get_thread_times,
    (req_handler)req_set_thread_info,
    (req_handler)req_suspend_thread,
    (req_handler)req_resume_thread,
    (req_handler)req_queue_apc,
    (req_handler)req_get_apc_result,
    (req_handler)req_close_handle,
    (req_handler)req_set_handle_info,
    (req_handler)req_dup_handle,
    (req_handler)req_allocate_reserve_object,
    (req_handler)req_compare_objects,
    (req_handler)req_set_object_permanence,
    (req_handler)req_open_process,
    (req_handler)req_open_thread,
    (req_handler)req_select,
    (req_handler)req_create_event,
    (req_handler)req_event_op,
    (req_handler)req_query_event,
    (req_handler)req_open_event,
    (req_handler)req_create_keyed_event,
    (req_handler)req_open_keyed_event,
    (req_handler)req_create_mutex,
    (req_handler)req_release_mutex,
    (req_handler)req_open_mutex,
    (req_handler)req_query_mutex,
    (req_handler)req_create_semaphore,
    (req_handler)req_release_semaphore,
    (req_handler)req_query_semaphore,
    (req_handler)req_open_semaphore,
    (req_handler)req_create_file,
    (req_handler)req_open_file_object,
    (req_handler)req_alloc_file_handle,
    (req_handler)req_get_handle_unix_name,
    (req_handler)req_get_handle_fd,
    (req_handler)req_get_directory_cache_entry,
    (req_handler)req_flush,
    (req_handler)req_get_file_info,
    (req_handler)req_get_volume_info,
    (req_handler)req_lock_file,
    (req_handler)req_unlock_file,
    (req_handler)req_recv_socket,
    (req_handler)req_send_socket,
    (req_handler)req_socket_get_events,
    (req_handler)req_socket_send_icmp_id,
    (req_handler)req_socket_get_icmp_id,
    (req_handler)req_get_next_console_request,
    (req_handler)req_read_directory_changes,
    (req_handler)req_read_change,
    (req_handler)req_create_mapping,
    (req_handler)req_open_mapping,
    (req_handler)req_get_mapping_info,
    (req_handler)req_get_image_map_address,
    (req_handler)req_map_view,
    (req_handler)req_map_image_view,
    (req_handler)req_map_builtin_view,
    (req_handler)req_get_image_view_info,
    (req_handler)req_unmap_view,
    (req_handler)req_get_mapping_committed_range,
    (req_handler)req_add_mapping_committed_range,
    (req_handler)req_is_same_mapping,
    (req_handler)req_get_mapping_filename,
    (req_handler)req_list_processes,
    (req_handler)req_create_debug_obj,
    (req_handler)req_wait_debug_event,
    (req_handler)req_queue_exception_event,
    (req_handler)req_get_exception_status,
    (req_handler)req_continue_debug_event,
    (req_handler)req_debug_process,
    (req_handler)req_set_debug_obj_info,
    (req_handler)req_read_process_memory,
    (req_handler)req_write_process_memory,
    (req_handler)req_create_key,
    (req_handler)req_open_key,
    (req_handler)req_delete_key,
    (req_handler)req_flush_key,
    (req_handler)req_enum_key,
    (req_handler)req_set_key_value,
    (req_handler)req_get_key_value,
    (req_handler)req_enum_key_value,
    (req_handler)req_delete_key_value,
    (req_handler)req_load_registry,
    (req_handler)req_unload_registry,
    (req_handler)req_save_registry,
    (req_handler)req_set_registry_notification,
    (req_handler)req_rename_key,
    (req_handler)req_create_timer,
    (req_handler)req_open_timer,
    (req_handler)req_set_timer,
    (req_handler)req_cancel_timer,
    (req_handler)req_get_timer_info,
    (req_handler)req_get_thread_context,
    (req_handler)req_set_thread_context,
    (req_handler)req_get_selector_entry,
    (req_handler)req_add_atom,
    (req_handler)req_delete_atom,
    (req_handler)req_find_atom,
    (req_handler)req_get_atom_information,
    (req_handler)req_get_msg_queue_handle,
    (req_handler)req_get_msg_queue,
    (req_handler)req_set_queue_fd,
    (req_handler)req_set_queue_mask,
    (req_handler)req_get_queue_status,
    (req_handler)req_get_process_idle_event,
    (req_handler)req_send_message,
    (req_handler)req_post_quit_message,
    (req_handler)req_send_hardware_message,
    (req_handler)req_get_message,
    (req_handler)req_reply_message,
    (req_handler)req_accept_hardware_message,
    (req_handler)req_get_message_reply,
    (req_handler)req_set_win_timer,
    (req_handler)req_kill_win_timer,
    (req_handler)req_is_window_hung,
    (req_handler)req_get_serial_info,
    (req_handler)req_set_serial_info,
    (req_handler)req_cancel_sync,
    (req_handler)req_register_async,
    (req_handler)req_cancel_async,
    (req_handler)req_get_async_result,
    (req_handler)req_set_async_direct_result,
    (req_handler)req_read,
    (req_handler)req_write,
    (req_handler)req_ioctl,
    (req_handler)req_set_irp_result,
    (req_handler)req_create_named_pipe,
    (req_handler)req_set_named_pipe_info,
    (req_handler)req_create_window,
    (req_handler)req_destroy_window,
    (req_handler)req_get_desktop_window,
    (req_handler)req_set_window_owner,
    (req_handler)req_get_window_info,
    (req_handler)req_set_window_info,
    (req_handler)req_set_parent,
    (req_handler)req_get_window_parents,
    (req_handler)req_get_window_children,
    (req_handler)req_get_window_children_from_point,
    (req_handler)req_get_window_tree,
    (req_handler)req_set_window_pos,
    (req_handler)req_get_window_rectangles,
    (req_handler)req_get_window_text,
    (req_handler)req_set_window_text,
    (req_handler)req_get_windows_offset,
    (req_handler)req_get_visible_region,
    (req_handler)req_get_window_region,
    (req_handler)req_set_window_region,
    (req_handler)req_get_update_region,
    (req_handler)req_update_window_zorder,
    (req_handler)req_redraw_window,
    (req_handler)req_set_window_property,
    (req_handler)req_remove_window_property,
    (req_handler)req_get_window_property,
    (req_handler)req_get_window_properties,
    (req_handler)req_create_winstation,
    (req_handler)req_open_winstation,
    (req_handler)req_close_winstation,
    (req_handler)req_set_winstation_monitors,
    (req_handler)req_get_process_winstation,
    (req_handler)req_set_process_winstation,
    (req_handler)req_enum_winstation,
    (req_handler)req_create_desktop,
    (req_handler)req_open_desktop,
    (req_handler)req_open_input_desktop,
    (req_handler)req_set_input_desktop,
    (req_handler)req_close_desktop,
    (req_handler)req_get_thread_desktop,
    (req_handler)req_set_thread_desktop,
    (req_handler)req_set_user_object_info,
    (req_handler)req_register_hotkey,
    (req_handler)req_unregister_hotkey,
    (req_handler)req_attach_thread_input,
    (req_handler)req_get_thread_input,
    (req_handler)req_get_last_input_time,
    (req_handler)req_get_key_state,
    (req_handler)req_set_key_state,
    (req_handler)req_set_foreground_window,
    (req_handler)req_set_focus_window,
    (req_handler)req_set_active_window,
    (req_handler)req_set_capture_window,
    (req_handler)req_set_caret_window,
    (req_handler)req_set_caret_info,
    (req_handler)req_set_hook,
    (req_handler)req_remove_hook,
    (req_handler)req_start_hook_chain,
    (req_handler)req_finish_hook_chain,
    (req_handler)req_get_hook_info,
    (req_handler)req_create_class,
    (req_handler)req_destroy_class,
    (req_handler)req_set_class_info,
    (req_handler)req_open_clipboard,
    (req_handler)req_close_clipboard,
    (req_handler)req_empty_clipboard,
    (req_handler)req_set_clipboard_data,
    (req_handler)req_get_clipboard_data,
    (req_handler)req_get_clipboard_formats,
    (req_handler)req_enum_clipboard_formats,
    (req_handler)req_release_clipboard,
    (req_handler)req_get_clipboard_info,
    (req_handler)req_set_clipboard_viewer,
    (req_handler)req_add_clipboard_listener,
    (req_handler)req_remove_clipboard_listener,
    (req_handler)req_create_token,
    (req_handler)req_open_token,
    (req_handler)req_set_desktop_shell_windows,
    (req_handler)req_adjust_token_privileges,
    (req_handler)req_get_token_privileges,
    (req_handler)req_check_token_privileges,
    (req_handler)req_duplicate_token,
    (req_handler)req_filter_token,
    (req_handler)req_access_check,
    (req_handler)req_get_token_sid,
    (req_handler)req_get_token_groups,
    (req_handler)req_get_token_default_dacl,
    (req_handler)req_set_token_default_dacl,
    (req_handler)req_set_security_object,
    (req_handler)req_get_security_object,
    (req_handler)req_get_system_handles,
    (req_handler)req_get_tcp_connections,
    (req_handler)req_get_udp_endpoints,
    (req_handler)req_create_mailslot,
    (req_handler)req_set_mailslot_info,
    (req_handler)req_create_directory,
    (req_handler)req_open_directory,
    (req_handler)req_get_directory_entries,
    (req_handler)req_create_symlink,
    (req_handler)req_open_symlink,
    (req_handler)req_query_symlink,
    (req_handler)req_get_object_info,
    (req_handler)req_get_object_name,
    (req_handler)req_get_object_type,
    (req_handler)req_get_object_types,
    (req_handler)req_allocate_locally_unique_id,
    (req_handler)req_create_device_manager,
    (req_handler)req_create_device,
    (req_handler)req_delete_device,
    (req_handler)req_get_next_device_request,
    (req_handler)req_get_kernel_object_ptr,
    (req_handler)req_set_kernel_object_ptr,
    (req_handler)req_grab_kernel_object,
    (req_handler)req_release_kernel_object,
    (req_handler)req_get_kernel_object_handle,
    (req_handler)req_make_process_system,
    (req_handler)req_get_token_info,
    (req_handler)req_create_linked_token,
    (req_handler)req_create_completion,
    (req_handler)req_open_completion,
    (req_handler)req_add_completion,
    (req_handler)req_remove_completion,
    (req_handler)req_get_thread_completion,
    (req_handler)req_query_completion,
    (req_handler)req_set_completion_info,
    (req_handler)req_add_fd_completion,
    (req_handler)req_set_fd_completion_mode,
    (req_handler)req_set_fd_disp_info,
    (req_handler)req_set_fd_name_info,
    (req_handler)req_set_fd_eof_info,
    (req_handler)req_get_window_layered_info,
    (req_handler)req_set_window_layered_info,
    (req_handler)req_alloc_user_handle,
    (req_handler)req_free_user_handle,
    (req_handler)req_set_cursor,
    (req_handler)req_get_cursor_history,
    (req_handler)req_get_rawinput_buffer,
    (req_handler)req_update_rawinput_devices,
    (req_handler)req_create_job,
    (req_handler)req_open_job,
    (req_handler)req_assign_job,
    (req_handler)req_process_in_job,
    (req_handler)req_set_job_limits,
    (req_handler)req_set_job_completion_port,
    (req_handler)req_get_job_info,
    (req_handler)req_terminate_job,
    (req_handler)req_suspend_process,
    (req_handler)req_resume_process,
    (req_handler)req_get_next_thread,
    (req_handler)req_set_keyboard_repeat,
};

C_ASSERT( sizeof(abstime_t) == 8 );
C_ASSERT( sizeof(affinity_t) == 8 );
C_ASSERT( sizeof(apc_param_t) == 8 );
C_ASSERT( sizeof(atom_t) == 4 );
C_ASSERT( sizeof(char) == 1 );
C_ASSERT( sizeof(client_ptr_t) == 8 );
C_ASSERT( sizeof(context_t) == 1728 );
C_ASSERT( sizeof(cursor_pos_t) == 24 );
C_ASSERT( sizeof(data_size_t) == 4 );
C_ASSERT( sizeof(file_pos_t) == 8 );
C_ASSERT( sizeof(generic_map_t) == 16 );
C_ASSERT( sizeof(int) == 4 );
C_ASSERT( sizeof(ioctl_code_t) == 4 );
C_ASSERT( sizeof(lparam_t) == 8 );
C_ASSERT( sizeof(mem_size_t) == 8 );
C_ASSERT( sizeof(mod_handle_t) == 8 );
C_ASSERT( sizeof(obj_handle_t) == 4 );
C_ASSERT( sizeof(obj_locator_t) == 16 );
C_ASSERT( sizeof(object_id_t) == 8 );
C_ASSERT( sizeof(pe_image_info_t) == 88 );
C_ASSERT( sizeof(process_id_t) == 4 );
C_ASSERT( sizeof(property_data_t) == 16 );
C_ASSERT( sizeof(rectangle_t) == 16 );
C_ASSERT( sizeof(short int) == 2 );
C_ASSERT( sizeof(startup_info_t) == 96 );
C_ASSERT( sizeof(struct async_data) == 40 );
C_ASSERT( sizeof(struct filesystem_event) == 12 );
C_ASSERT( sizeof(struct handle_info) == 20 );
C_ASSERT( sizeof(struct luid) == 8 );
C_ASSERT( sizeof(struct luid_attr) == 12 );
C_ASSERT( sizeof(struct object_attributes) == 16 );
C_ASSERT( sizeof(struct object_type_info) == 44 );
C_ASSERT( sizeof(struct process_info) == 40 );
C_ASSERT( sizeof(struct rawinput_device) == 12 );
C_ASSERT( sizeof(struct thread_info) == 40 );
C_ASSERT( sizeof(struct user_apc) == 40 );
C_ASSERT( sizeof(tcp_connection) == 60 );
C_ASSERT( sizeof(thread_id_t) == 4 );
C_ASSERT( sizeof(timeout_t) == 8 );
C_ASSERT( sizeof(udp_endpoint) == 32 );
C_ASSERT( sizeof(union apc_call) == 64 );
C_ASSERT( sizeof(union apc_result) == 40 );
C_ASSERT( sizeof(union debug_event_data) == 160 );
C_ASSERT( sizeof(union hw_input) == 40 );
C_ASSERT( sizeof(union irp_params) == 32 );
C_ASSERT( sizeof(union message_data) == 48 );
C_ASSERT( sizeof(union select_op) == 264 );
C_ASSERT( sizeof(unsigned __int64) == 8 );
C_ASSERT( sizeof(unsigned char) == 1 );
C_ASSERT( sizeof(unsigned int) == 4 );
C_ASSERT( sizeof(unsigned short) == 2 );
C_ASSERT( sizeof(user_handle_t) == 4 );
C_ASSERT( offsetof(struct new_process_request, token) == 12 );
C_ASSERT( offsetof(struct new_process_request, debug) == 16 );
C_ASSERT( offsetof(struct new_process_request, parent_process) == 20 );
C_ASSERT( offsetof(struct new_process_request, flags) == 24 );
C_ASSERT( offsetof(struct new_process_request, socket_fd) == 28 );
C_ASSERT( offsetof(struct new_process_request, access) == 32 );
C_ASSERT( offsetof(struct new_process_request, machine) == 36 );
C_ASSERT( offsetof(struct new_process_request, info_size) == 40 );
C_ASSERT( offsetof(struct new_process_request, handles_size) == 44 );
C_ASSERT( offsetof(struct new_process_request, jobs_size) == 48 );
C_ASSERT( sizeof(struct new_process_request) == 56 );
C_ASSERT( offsetof(struct new_process_reply, info) == 8 );
C_ASSERT( offsetof(struct new_process_reply, pid) == 12 );
C_ASSERT( offsetof(struct new_process_reply, handle) == 16 );
C_ASSERT( sizeof(struct new_process_reply) == 24 );
C_ASSERT( offsetof(struct get_new_process_info_request, info) == 12 );
C_ASSERT( sizeof(struct get_new_process_info_request) == 16 );
C_ASSERT( offsetof(struct get_new_process_info_reply, success) == 8 );
C_ASSERT( offsetof(struct get_new_process_info_reply, exit_code) == 12 );
C_ASSERT( sizeof(struct get_new_process_info_reply) == 16 );
C_ASSERT( offsetof(struct new_thread_request, process) == 12 );
C_ASSERT( offsetof(struct new_thread_request, access) == 16 );
C_ASSERT( offsetof(struct new_thread_request, flags) == 20 );
C_ASSERT( offsetof(struct new_thread_request, request_fd) == 24 );
C_ASSERT( sizeof(struct new_thread_request) == 32 );
C_ASSERT( offsetof(struct new_thread_reply, tid) == 8 );
C_ASSERT( offsetof(struct new_thread_reply, handle) == 12 );
C_ASSERT( sizeof(struct new_thread_reply) == 16 );
C_ASSERT( sizeof(struct get_startup_info_request) == 16 );
C_ASSERT( offsetof(struct get_startup_info_reply, info_size) == 8 );
C_ASSERT( offsetof(struct get_startup_info_reply, machine) == 12 );
C_ASSERT( sizeof(struct get_startup_info_reply) == 16 );
C_ASSERT( offsetof(struct init_process_done_request, teb) == 16 );
C_ASSERT( offsetof(struct init_process_done_request, peb) == 24 );
C_ASSERT( offsetof(struct init_process_done_request, ldt_copy) == 32 );
C_ASSERT( sizeof(struct init_process_done_request) == 40 );
C_ASSERT( offsetof(struct init_process_done_reply, suspend) == 8 );
C_ASSERT( sizeof(struct init_process_done_reply) == 16 );
C_ASSERT( offsetof(struct init_first_thread_request, unix_pid) == 12 );
C_ASSERT( offsetof(struct init_first_thread_request, unix_tid) == 16 );
C_ASSERT( offsetof(struct init_first_thread_request, debug_level) == 20 );
C_ASSERT( offsetof(struct init_first_thread_request, reply_fd) == 24 );
C_ASSERT( offsetof(struct init_first_thread_request, wait_fd) == 28 );
C_ASSERT( sizeof(struct init_first_thread_request) == 32 );
C_ASSERT( offsetof(struct init_first_thread_reply, pid) == 8 );
C_ASSERT( offsetof(struct init_first_thread_reply, tid) == 12 );
C_ASSERT( offsetof(struct init_first_thread_reply, server_start) == 16 );
C_ASSERT( offsetof(struct init_first_thread_reply, session_id) == 24 );
C_ASSERT( offsetof(struct init_first_thread_reply, info_size) == 28 );
C_ASSERT( sizeof(struct init_first_thread_reply) == 32 );
C_ASSERT( offsetof(struct init_thread_request, unix_tid) == 12 );
C_ASSERT( offsetof(struct init_thread_request, reply_fd) == 16 );
C_ASSERT( offsetof(struct init_thread_request, wait_fd) == 20 );
C_ASSERT( offsetof(struct init_thread_request, teb) == 24 );
C_ASSERT( offsetof(struct init_thread_request, entry) == 32 );
C_ASSERT( sizeof(struct init_thread_request) == 40 );
C_ASSERT( offsetof(struct init_thread_reply, suspend) == 8 );
C_ASSERT( sizeof(struct init_thread_reply) == 16 );
C_ASSERT( offsetof(struct terminate_process_request, handle) == 12 );
C_ASSERT( offsetof(struct terminate_process_request, exit_code) == 16 );
C_ASSERT( sizeof(struct terminate_process_request) == 24 );
C_ASSERT( offsetof(struct terminate_process_reply, self) == 8 );
C_ASSERT( sizeof(struct terminate_process_reply) == 16 );
C_ASSERT( offsetof(struct terminate_thread_request, handle) == 12 );
C_ASSERT( offsetof(struct terminate_thread_request, exit_code) == 16 );
C_ASSERT( sizeof(struct terminate_thread_request) == 24 );
C_ASSERT( offsetof(struct terminate_thread_reply, self) == 8 );
C_ASSERT( sizeof(struct terminate_thread_reply) == 16 );
C_ASSERT( offsetof(struct get_process_info_request, handle) == 12 );
C_ASSERT( sizeof(struct get_process_info_request) == 16 );
C_ASSERT( offsetof(struct get_process_info_reply, pid) == 8 );
C_ASSERT( offsetof(struct get_process_info_reply, ppid) == 12 );
C_ASSERT( offsetof(struct get_process_info_reply, affinity) == 16 );
C_ASSERT( offsetof(struct get_process_info_reply, peb) == 24 );
C_ASSERT( offsetof(struct get_process_info_reply, start_time) == 32 );
C_ASSERT( offsetof(struct get_process_info_reply, end_time) == 40 );
C_ASSERT( offsetof(struct get_process_info_reply, session_id) == 48 );
C_ASSERT( offsetof(struct get_process_info_reply, exit_code) == 52 );
C_ASSERT( offsetof(struct get_process_info_reply, priority) == 56 );
C_ASSERT( offsetof(struct get_process_info_reply, machine) == 60 );
C_ASSERT( sizeof(struct get_process_info_reply) == 64 );
C_ASSERT( offsetof(struct get_process_debug_info_request, handle) == 12 );
C_ASSERT( sizeof(struct get_process_debug_info_request) == 16 );
C_ASSERT( offsetof(struct get_process_debug_info_reply, debug) == 8 );
C_ASSERT( offsetof(struct get_process_debug_info_reply, debug_children) == 12 );
C_ASSERT( sizeof(struct get_process_debug_info_reply) == 16 );
C_ASSERT( offsetof(struct get_process_image_name_request, handle) == 12 );
C_ASSERT( offsetof(struct get_process_image_name_request, pid) == 16 );
C_ASSERT( offsetof(struct get_process_image_name_request, win32) == 20 );
C_ASSERT( sizeof(struct get_process_image_name_request) == 24 );
C_ASSERT( offsetof(struct get_process_image_name_reply, len) == 8 );
C_ASSERT( sizeof(struct get_process_image_name_reply) == 16 );
C_ASSERT( offsetof(struct get_process_vm_counters_request, handle) == 12 );
C_ASSERT( sizeof(struct get_process_vm_counters_request) == 16 );
C_ASSERT( offsetof(struct get_process_vm_counters_reply, peak_virtual_size) == 8 );
C_ASSERT( offsetof(struct get_process_vm_counters_reply, virtual_size) == 16 );
C_ASSERT( offsetof(struct get_process_vm_counters_reply, peak_working_set_size) == 24 );
C_ASSERT( offsetof(struct get_process_vm_counters_reply, working_set_size) == 32 );
C_ASSERT( offsetof(struct get_process_vm_counters_reply, pagefile_usage) == 40 );
C_ASSERT( offsetof(struct get_process_vm_counters_reply, peak_pagefile_usage) == 48 );
C_ASSERT( sizeof(struct get_process_vm_counters_reply) == 56 );
C_ASSERT( offsetof(struct set_process_info_request, handle) == 12 );
C_ASSERT( offsetof(struct set_process_info_request, mask) == 16 );
C_ASSERT( offsetof(struct set_process_info_request, priority) == 20 );
C_ASSERT( offsetof(struct set_process_info_request, affinity) == 24 );
C_ASSERT( offsetof(struct set_process_info_request, token) == 32 );
C_ASSERT( sizeof(struct set_process_info_request) == 40 );
C_ASSERT( offsetof(struct get_thread_info_request, handle) == 12 );
C_ASSERT( offsetof(struct get_thread_info_request, access) == 16 );
C_ASSERT( sizeof(struct get_thread_info_request) == 24 );
C_ASSERT( offsetof(struct get_thread_info_reply, pid) == 8 );
C_ASSERT( offsetof(struct get_thread_info_reply, tid) == 12 );
C_ASSERT( offsetof(struct get_thread_info_reply, teb) == 16 );
C_ASSERT( offsetof(struct get_thread_info_reply, entry_point) == 24 );
C_ASSERT( offsetof(struct get_thread_info_reply, affinity) == 32 );
C_ASSERT( offsetof(struct get_thread_info_reply, exit_code) == 40 );
C_ASSERT( offsetof(struct get_thread_info_reply, priority) == 44 );
C_ASSERT( offsetof(struct get_thread_info_reply, last) == 48 );
C_ASSERT( offsetof(struct get_thread_info_reply, suspend_count) == 52 );
C_ASSERT( offsetof(struct get_thread_info_reply, flags) == 56 );
C_ASSERT( offsetof(struct get_thread_info_reply, desc_len) == 60 );
C_ASSERT( sizeof(struct get_thread_info_reply) == 64 );
C_ASSERT( offsetof(struct get_thread_times_request, handle) == 12 );
C_ASSERT( sizeof(struct get_thread_times_request) == 16 );
C_ASSERT( offsetof(struct get_thread_times_reply, creation_time) == 8 );
C_ASSERT( offsetof(struct get_thread_times_reply, exit_time) == 16 );
C_ASSERT( offsetof(struct get_thread_times_reply, unix_pid) == 24 );
C_ASSERT( offsetof(struct get_thread_times_reply, unix_tid) == 28 );
C_ASSERT( sizeof(struct get_thread_times_reply) == 32 );
C_ASSERT( offsetof(struct set_thread_info_request, handle) == 12 );
C_ASSERT( offsetof(struct set_thread_info_request, mask) == 16 );
C_ASSERT( offsetof(struct set_thread_info_request, priority) == 20 );
C_ASSERT( offsetof(struct set_thread_info_request, affinity) == 24 );
C_ASSERT( offsetof(struct set_thread_info_request, entry_point) == 32 );
C_ASSERT( offsetof(struct set_thread_info_request, token) == 40 );
C_ASSERT( sizeof(struct set_thread_info_request) == 48 );
C_ASSERT( offsetof(struct suspend_thread_request, handle) == 12 );
C_ASSERT( sizeof(struct suspend_thread_request) == 16 );
C_ASSERT( offsetof(struct suspend_thread_reply, count) == 8 );
C_ASSERT( sizeof(struct suspend_thread_reply) == 16 );
C_ASSERT( offsetof(struct resume_thread_request, handle) == 12 );
C_ASSERT( sizeof(struct resume_thread_request) == 16 );
C_ASSERT( offsetof(struct resume_thread_reply, count) == 8 );
C_ASSERT( sizeof(struct resume_thread_reply) == 16 );
C_ASSERT( offsetof(struct queue_apc_request, handle) == 12 );
C_ASSERT( sizeof(struct queue_apc_request) == 16 );
C_ASSERT( offsetof(struct queue_apc_reply, handle) == 8 );
C_ASSERT( offsetof(struct queue_apc_reply, self) == 12 );
C_ASSERT( sizeof(struct queue_apc_reply) == 16 );
C_ASSERT( offsetof(struct get_apc_result_request, handle) == 12 );
C_ASSERT( sizeof(struct get_apc_result_request) == 16 );
C_ASSERT( offsetof(struct get_apc_result_reply, result) == 8 );
C_ASSERT( sizeof(struct get_apc_result_reply) == 48 );
C_ASSERT( offsetof(struct close_handle_request, handle) == 12 );
C_ASSERT( sizeof(struct close_handle_request) == 16 );
C_ASSERT( offsetof(struct set_handle_info_request, handle) == 12 );
C_ASSERT( offsetof(struct set_handle_info_request, flags) == 16 );
C_ASSERT( offsetof(struct set_handle_info_request, mask) == 20 );
C_ASSERT( sizeof(struct set_handle_info_request) == 24 );
C_ASSERT( offsetof(struct set_handle_info_reply, old_flags) == 8 );
C_ASSERT( sizeof(struct set_handle_info_reply) == 16 );
C_ASSERT( offsetof(struct dup_handle_request, src_process) == 12 );
C_ASSERT( offsetof(struct dup_handle_request, src_handle) == 16 );
C_ASSERT( offsetof(struct dup_handle_request, dst_process) == 20 );
C_ASSERT( offsetof(struct dup_handle_request, access) == 24 );
C_ASSERT( offsetof(struct dup_handle_request, attributes) == 28 );
C_ASSERT( offsetof(struct dup_handle_request, options) == 32 );
C_ASSERT( sizeof(struct dup_handle_request) == 40 );
C_ASSERT( offsetof(struct dup_handle_reply, handle) == 8 );
C_ASSERT( sizeof(struct dup_handle_reply) == 16 );
C_ASSERT( offsetof(struct allocate_reserve_object_request, type) == 12 );
C_ASSERT( sizeof(struct allocate_reserve_object_request) == 16 );
C_ASSERT( offsetof(struct allocate_reserve_object_reply, handle) == 8 );
C_ASSERT( sizeof(struct allocate_reserve_object_reply) == 16 );
C_ASSERT( offsetof(struct compare_objects_request, first) == 12 );
C_ASSERT( offsetof(struct compare_objects_request, second) == 16 );
C_ASSERT( sizeof(struct compare_objects_request) == 24 );
C_ASSERT( offsetof(struct set_object_permanence_request, handle) == 12 );
C_ASSERT( offsetof(struct set_object_permanence_request, permanent) == 16 );
C_ASSERT( sizeof(struct set_object_permanence_request) == 24 );
C_ASSERT( offsetof(struct open_process_request, pid) == 12 );
C_ASSERT( offsetof(struct open_process_request, access) == 16 );
C_ASSERT( offsetof(struct open_process_request, attributes) == 20 );
C_ASSERT( sizeof(struct open_process_request) == 24 );
C_ASSERT( offsetof(struct open_process_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_process_reply) == 16 );
C_ASSERT( offsetof(struct open_thread_request, tid) == 12 );
C_ASSERT( offsetof(struct open_thread_request, access) == 16 );
C_ASSERT( offsetof(struct open_thread_request, attributes) == 20 );
C_ASSERT( sizeof(struct open_thread_request) == 24 );
C_ASSERT( offsetof(struct open_thread_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_thread_reply) == 16 );
C_ASSERT( offsetof(struct select_request, flags) == 12 );
C_ASSERT( offsetof(struct select_request, cookie) == 16 );
C_ASSERT( offsetof(struct select_request, timeout) == 24 );
C_ASSERT( offsetof(struct select_request, size) == 32 );
C_ASSERT( offsetof(struct select_request, prev_apc) == 36 );
C_ASSERT( sizeof(struct select_request) == 40 );
C_ASSERT( offsetof(struct select_reply, apc_handle) == 8 );
C_ASSERT( offsetof(struct select_reply, signaled) == 12 );
C_ASSERT( sizeof(struct select_reply) == 16 );
C_ASSERT( offsetof(struct create_event_request, access) == 12 );
C_ASSERT( offsetof(struct create_event_request, manual_reset) == 16 );
C_ASSERT( offsetof(struct create_event_request, initial_state) == 20 );
C_ASSERT( sizeof(struct create_event_request) == 24 );
C_ASSERT( offsetof(struct create_event_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_event_reply) == 16 );
C_ASSERT( offsetof(struct event_op_request, handle) == 12 );
C_ASSERT( offsetof(struct event_op_request, op) == 16 );
C_ASSERT( sizeof(struct event_op_request) == 24 );
C_ASSERT( offsetof(struct event_op_reply, state) == 8 );
C_ASSERT( sizeof(struct event_op_reply) == 16 );
C_ASSERT( offsetof(struct query_event_request, handle) == 12 );
C_ASSERT( sizeof(struct query_event_request) == 16 );
C_ASSERT( offsetof(struct query_event_reply, manual_reset) == 8 );
C_ASSERT( offsetof(struct query_event_reply, state) == 12 );
C_ASSERT( sizeof(struct query_event_reply) == 16 );
C_ASSERT( offsetof(struct open_event_request, access) == 12 );
C_ASSERT( offsetof(struct open_event_request, attributes) == 16 );
C_ASSERT( offsetof(struct open_event_request, rootdir) == 20 );
C_ASSERT( sizeof(struct open_event_request) == 24 );
C_ASSERT( offsetof(struct open_event_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_event_reply) == 16 );
C_ASSERT( offsetof(struct create_keyed_event_request, access) == 12 );
C_ASSERT( sizeof(struct create_keyed_event_request) == 16 );
C_ASSERT( offsetof(struct create_keyed_event_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_keyed_event_reply) == 16 );
C_ASSERT( offsetof(struct open_keyed_event_request, access) == 12 );
C_ASSERT( offsetof(struct open_keyed_event_request, attributes) == 16 );
C_ASSERT( offsetof(struct open_keyed_event_request, rootdir) == 20 );
C_ASSERT( sizeof(struct open_keyed_event_request) == 24 );
C_ASSERT( offsetof(struct open_keyed_event_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_keyed_event_reply) == 16 );
C_ASSERT( offsetof(struct create_mutex_request, access) == 12 );
C_ASSERT( offsetof(struct create_mutex_request, owned) == 16 );
C_ASSERT( sizeof(struct create_mutex_request) == 24 );
C_ASSERT( offsetof(struct create_mutex_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_mutex_reply) == 16 );
C_ASSERT( offsetof(struct release_mutex_request, handle) == 12 );
C_ASSERT( sizeof(struct release_mutex_request) == 16 );
C_ASSERT( offsetof(struct release_mutex_reply, prev_count) == 8 );
C_ASSERT( sizeof(struct release_mutex_reply) == 16 );
C_ASSERT( offsetof(struct open_mutex_request, access) == 12 );
C_ASSERT( offsetof(struct open_mutex_request, attributes) == 16 );
C_ASSERT( offsetof(struct open_mutex_request, rootdir) == 20 );
C_ASSERT( sizeof(struct open_mutex_request) == 24 );
C_ASSERT( offsetof(struct open_mutex_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_mutex_reply) == 16 );
C_ASSERT( offsetof(struct query_mutex_request, handle) == 12 );
C_ASSERT( sizeof(struct query_mutex_request) == 16 );
C_ASSERT( offsetof(struct query_mutex_reply, count) == 8 );
C_ASSERT( offsetof(struct query_mutex_reply, owned) == 12 );
C_ASSERT( offsetof(struct query_mutex_reply, abandoned) == 16 );
C_ASSERT( sizeof(struct query_mutex_reply) == 24 );
C_ASSERT( offsetof(struct create_semaphore_request, access) == 12 );
C_ASSERT( offsetof(struct create_semaphore_request, initial) == 16 );
C_ASSERT( offsetof(struct create_semaphore_request, max) == 20 );
C_ASSERT( sizeof(struct create_semaphore_request) == 24 );
C_ASSERT( offsetof(struct create_semaphore_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_semaphore_reply) == 16 );
C_ASSERT( offsetof(struct release_semaphore_request, handle) == 12 );
C_ASSERT( offsetof(struct release_semaphore_request, count) == 16 );
C_ASSERT( sizeof(struct release_semaphore_request) == 24 );
C_ASSERT( offsetof(struct release_semaphore_reply, prev_count) == 8 );
C_ASSERT( sizeof(struct release_semaphore_reply) == 16 );
C_ASSERT( offsetof(struct query_semaphore_request, handle) == 12 );
C_ASSERT( sizeof(struct query_semaphore_request) == 16 );
C_ASSERT( offsetof(struct query_semaphore_reply, current) == 8 );
C_ASSERT( offsetof(struct query_semaphore_reply, max) == 12 );
C_ASSERT( sizeof(struct query_semaphore_reply) == 16 );
C_ASSERT( offsetof(struct open_semaphore_request, access) == 12 );
C_ASSERT( offsetof(struct open_semaphore_request, attributes) == 16 );
C_ASSERT( offsetof(struct open_semaphore_request, rootdir) == 20 );
C_ASSERT( sizeof(struct open_semaphore_request) == 24 );
C_ASSERT( offsetof(struct open_semaphore_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_semaphore_reply) == 16 );
C_ASSERT( offsetof(struct create_file_request, access) == 12 );
C_ASSERT( offsetof(struct create_file_request, sharing) == 16 );
C_ASSERT( offsetof(struct create_file_request, create) == 20 );
C_ASSERT( offsetof(struct create_file_request, options) == 24 );
C_ASSERT( offsetof(struct create_file_request, attrs) == 28 );
C_ASSERT( sizeof(struct create_file_request) == 32 );
C_ASSERT( offsetof(struct create_file_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_file_reply) == 16 );
C_ASSERT( offsetof(struct open_file_object_request, access) == 12 );
C_ASSERT( offsetof(struct open_file_object_request, attributes) == 16 );
C_ASSERT( offsetof(struct open_file_object_request, rootdir) == 20 );
C_ASSERT( offsetof(struct open_file_object_request, sharing) == 24 );
C_ASSERT( offsetof(struct open_file_object_request, options) == 28 );
C_ASSERT( sizeof(struct open_file_object_request) == 32 );
C_ASSERT( offsetof(struct open_file_object_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_file_object_reply) == 16 );
C_ASSERT( offsetof(struct alloc_file_handle_request, access) == 12 );
C_ASSERT( offsetof(struct alloc_file_handle_request, attributes) == 16 );
C_ASSERT( offsetof(struct alloc_file_handle_request, fd) == 20 );
C_ASSERT( sizeof(struct alloc_file_handle_request) == 24 );
C_ASSERT( offsetof(struct alloc_file_handle_reply, handle) == 8 );
C_ASSERT( sizeof(struct alloc_file_handle_reply) == 16 );
C_ASSERT( offsetof(struct get_handle_unix_name_request, handle) == 12 );
C_ASSERT( sizeof(struct get_handle_unix_name_request) == 16 );
C_ASSERT( offsetof(struct get_handle_unix_name_reply, name_len) == 8 );
C_ASSERT( sizeof(struct get_handle_unix_name_reply) == 16 );
C_ASSERT( offsetof(struct get_handle_fd_request, handle) == 12 );
C_ASSERT( sizeof(struct get_handle_fd_request) == 16 );
C_ASSERT( offsetof(struct get_handle_fd_reply, type) == 8 );
C_ASSERT( offsetof(struct get_handle_fd_reply, cacheable) == 12 );
C_ASSERT( offsetof(struct get_handle_fd_reply, access) == 16 );
C_ASSERT( offsetof(struct get_handle_fd_reply, options) == 20 );
C_ASSERT( sizeof(struct get_handle_fd_reply) == 24 );
C_ASSERT( offsetof(struct get_directory_cache_entry_request, handle) == 12 );
C_ASSERT( sizeof(struct get_directory_cache_entry_request) == 16 );
C_ASSERT( offsetof(struct get_directory_cache_entry_reply, entry) == 8 );
C_ASSERT( sizeof(struct get_directory_cache_entry_reply) == 16 );
C_ASSERT( offsetof(struct flush_request, async) == 16 );
C_ASSERT( sizeof(struct flush_request) == 56 );
C_ASSERT( offsetof(struct flush_reply, event) == 8 );
C_ASSERT( sizeof(struct flush_reply) == 16 );
C_ASSERT( offsetof(struct get_file_info_request, handle) == 12 );
C_ASSERT( offsetof(struct get_file_info_request, info_class) == 16 );
C_ASSERT( sizeof(struct get_file_info_request) == 24 );
C_ASSERT( sizeof(struct get_file_info_reply) == 8 );
C_ASSERT( offsetof(struct get_volume_info_request, handle) == 12 );
C_ASSERT( offsetof(struct get_volume_info_request, async) == 16 );
C_ASSERT( offsetof(struct get_volume_info_request, info_class) == 56 );
C_ASSERT( sizeof(struct get_volume_info_request) == 64 );
C_ASSERT( offsetof(struct get_volume_info_reply, wait) == 8 );
C_ASSERT( sizeof(struct get_volume_info_reply) == 16 );
C_ASSERT( offsetof(struct lock_file_request, handle) == 12 );
C_ASSERT( offsetof(struct lock_file_request, offset) == 16 );
C_ASSERT( offsetof(struct lock_file_request, count) == 24 );
C_ASSERT( offsetof(struct lock_file_request, shared) == 32 );
C_ASSERT( offsetof(struct lock_file_request, wait) == 36 );
C_ASSERT( sizeof(struct lock_file_request) == 40 );
C_ASSERT( offsetof(struct lock_file_reply, handle) == 8 );
C_ASSERT( offsetof(struct lock_file_reply, overlapped) == 12 );
C_ASSERT( sizeof(struct lock_file_reply) == 16 );
C_ASSERT( offsetof(struct unlock_file_request, handle) == 12 );
C_ASSERT( offsetof(struct unlock_file_request, offset) == 16 );
C_ASSERT( offsetof(struct unlock_file_request, count) == 24 );
C_ASSERT( sizeof(struct unlock_file_request) == 32 );
C_ASSERT( offsetof(struct recv_socket_request, oob) == 12 );
C_ASSERT( offsetof(struct recv_socket_request, async) == 16 );
C_ASSERT( offsetof(struct recv_socket_request, force_async) == 56 );
C_ASSERT( sizeof(struct recv_socket_request) == 64 );
C_ASSERT( offsetof(struct recv_socket_reply, wait) == 8 );
C_ASSERT( offsetof(struct recv_socket_reply, options) == 12 );
C_ASSERT( offsetof(struct recv_socket_reply, nonblocking) == 16 );
C_ASSERT( sizeof(struct recv_socket_reply) == 24 );
C_ASSERT( offsetof(struct send_socket_request, flags) == 12 );
C_ASSERT( offsetof(struct send_socket_request, async) == 16 );
C_ASSERT( sizeof(struct send_socket_request) == 56 );
C_ASSERT( offsetof(struct send_socket_reply, wait) == 8 );
C_ASSERT( offsetof(struct send_socket_reply, options) == 12 );
C_ASSERT( offsetof(struct send_socket_reply, nonblocking) == 16 );
C_ASSERT( sizeof(struct send_socket_reply) == 24 );
C_ASSERT( offsetof(struct socket_get_events_request, handle) == 12 );
C_ASSERT( offsetof(struct socket_get_events_request, event) == 16 );
C_ASSERT( sizeof(struct socket_get_events_request) == 24 );
C_ASSERT( offsetof(struct socket_get_events_reply, flags) == 8 );
C_ASSERT( sizeof(struct socket_get_events_reply) == 16 );
C_ASSERT( offsetof(struct socket_send_icmp_id_request, handle) == 12 );
C_ASSERT( offsetof(struct socket_send_icmp_id_request, icmp_id) == 16 );
C_ASSERT( offsetof(struct socket_send_icmp_id_request, icmp_seq) == 18 );
C_ASSERT( sizeof(struct socket_send_icmp_id_request) == 24 );
C_ASSERT( sizeof(struct socket_send_icmp_id_reply) == 8 );
C_ASSERT( offsetof(struct socket_get_icmp_id_request, handle) == 12 );
C_ASSERT( offsetof(struct socket_get_icmp_id_request, icmp_seq) == 16 );
C_ASSERT( sizeof(struct socket_get_icmp_id_request) == 24 );
C_ASSERT( offsetof(struct socket_get_icmp_id_reply, icmp_id) == 8 );
C_ASSERT( sizeof(struct socket_get_icmp_id_reply) == 16 );
C_ASSERT( offsetof(struct get_next_console_request_request, handle) == 12 );
C_ASSERT( offsetof(struct get_next_console_request_request, signal) == 16 );
C_ASSERT( offsetof(struct get_next_console_request_request, read) == 20 );
C_ASSERT( offsetof(struct get_next_console_request_request, status) == 24 );
C_ASSERT( sizeof(struct get_next_console_request_request) == 32 );
C_ASSERT( offsetof(struct get_next_console_request_reply, code) == 8 );
C_ASSERT( offsetof(struct get_next_console_request_reply, output) == 12 );
C_ASSERT( offsetof(struct get_next_console_request_reply, out_size) == 16 );
C_ASSERT( sizeof(struct get_next_console_request_reply) == 24 );
C_ASSERT( offsetof(struct read_directory_changes_request, filter) == 12 );
C_ASSERT( offsetof(struct read_directory_changes_request, subtree) == 16 );
C_ASSERT( offsetof(struct read_directory_changes_request, want_data) == 20 );
C_ASSERT( offsetof(struct read_directory_changes_request, async) == 24 );
C_ASSERT( sizeof(struct read_directory_changes_request) == 64 );
C_ASSERT( offsetof(struct read_change_request, handle) == 12 );
C_ASSERT( sizeof(struct read_change_request) == 16 );
C_ASSERT( sizeof(struct read_change_reply) == 8 );
C_ASSERT( offsetof(struct create_mapping_request, access) == 12 );
C_ASSERT( offsetof(struct create_mapping_request, flags) == 16 );
C_ASSERT( offsetof(struct create_mapping_request, file_access) == 20 );
C_ASSERT( offsetof(struct create_mapping_request, size) == 24 );
C_ASSERT( offsetof(struct create_mapping_request, file_handle) == 32 );
C_ASSERT( sizeof(struct create_mapping_request) == 40 );
C_ASSERT( offsetof(struct create_mapping_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_mapping_reply) == 16 );
C_ASSERT( offsetof(struct open_mapping_request, access) == 12 );
C_ASSERT( offsetof(struct open_mapping_request, attributes) == 16 );
C_ASSERT( offsetof(struct open_mapping_request, rootdir) == 20 );
C_ASSERT( sizeof(struct open_mapping_request) == 24 );
C_ASSERT( offsetof(struct open_mapping_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_mapping_reply) == 16 );
C_ASSERT( offsetof(struct get_mapping_info_request, handle) == 12 );
C_ASSERT( offsetof(struct get_mapping_info_request, access) == 16 );
C_ASSERT( sizeof(struct get_mapping_info_request) == 24 );
C_ASSERT( offsetof(struct get_mapping_info_reply, size) == 8 );
C_ASSERT( offsetof(struct get_mapping_info_reply, flags) == 16 );
C_ASSERT( offsetof(struct get_mapping_info_reply, shared_file) == 20 );
C_ASSERT( offsetof(struct get_mapping_info_reply, total) == 24 );
C_ASSERT( sizeof(struct get_mapping_info_reply) == 32 );
C_ASSERT( offsetof(struct get_image_map_address_request, handle) == 12 );
C_ASSERT( sizeof(struct get_image_map_address_request) == 16 );
C_ASSERT( offsetof(struct get_image_map_address_reply, addr) == 8 );
C_ASSERT( sizeof(struct get_image_map_address_reply) == 16 );
C_ASSERT( offsetof(struct map_view_request, mapping) == 12 );
C_ASSERT( offsetof(struct map_view_request, access) == 16 );
C_ASSERT( offsetof(struct map_view_request, base) == 24 );
C_ASSERT( offsetof(struct map_view_request, size) == 32 );
C_ASSERT( offsetof(struct map_view_request, start) == 40 );
C_ASSERT( sizeof(struct map_view_request) == 48 );
C_ASSERT( offsetof(struct map_image_view_request, mapping) == 12 );
C_ASSERT( offsetof(struct map_image_view_request, base) == 16 );
C_ASSERT( offsetof(struct map_image_view_request, size) == 24 );
C_ASSERT( offsetof(struct map_image_view_request, entry) == 32 );
C_ASSERT( offsetof(struct map_image_view_request, machine) == 36 );
C_ASSERT( sizeof(struct map_image_view_request) == 40 );
C_ASSERT( sizeof(struct map_builtin_view_request) == 16 );
C_ASSERT( offsetof(struct get_image_view_info_request, process) == 12 );
C_ASSERT( offsetof(struct get_image_view_info_request, addr) == 16 );
C_ASSERT( sizeof(struct get_image_view_info_request) == 24 );
C_ASSERT( offsetof(struct get_image_view_info_reply, base) == 8 );
C_ASSERT( offsetof(struct get_image_view_info_reply, size) == 16 );
C_ASSERT( sizeof(struct get_image_view_info_reply) == 24 );
C_ASSERT( offsetof(struct unmap_view_request, base) == 16 );
C_ASSERT( sizeof(struct unmap_view_request) == 24 );
C_ASSERT( offsetof(struct get_mapping_committed_range_request, base) == 16 );
C_ASSERT( offsetof(struct get_mapping_committed_range_request, offset) == 24 );
C_ASSERT( sizeof(struct get_mapping_committed_range_request) == 32 );
C_ASSERT( offsetof(struct get_mapping_committed_range_reply, size) == 8 );
C_ASSERT( offsetof(struct get_mapping_committed_range_reply, committed) == 16 );
C_ASSERT( sizeof(struct get_mapping_committed_range_reply) == 24 );
C_ASSERT( offsetof(struct add_mapping_committed_range_request, base) == 16 );
C_ASSERT( offsetof(struct add_mapping_committed_range_request, offset) == 24 );
C_ASSERT( offsetof(struct add_mapping_committed_range_request, size) == 32 );
C_ASSERT( sizeof(struct add_mapping_committed_range_request) == 40 );
C_ASSERT( offsetof(struct is_same_mapping_request, base1) == 16 );
C_ASSERT( offsetof(struct is_same_mapping_request, base2) == 24 );
C_ASSERT( sizeof(struct is_same_mapping_request) == 32 );
C_ASSERT( offsetof(struct get_mapping_filename_request, process) == 12 );
C_ASSERT( offsetof(struct get_mapping_filename_request, addr) == 16 );
C_ASSERT( sizeof(struct get_mapping_filename_request) == 24 );
C_ASSERT( offsetof(struct get_mapping_filename_reply, len) == 8 );
C_ASSERT( sizeof(struct get_mapping_filename_reply) == 16 );
C_ASSERT( sizeof(struct list_processes_request) == 16 );
C_ASSERT( offsetof(struct list_processes_reply, info_size) == 8 );
C_ASSERT( offsetof(struct list_processes_reply, process_count) == 12 );
C_ASSERT( offsetof(struct list_processes_reply, total_thread_count) == 16 );
C_ASSERT( offsetof(struct list_processes_reply, total_name_len) == 20 );
C_ASSERT( sizeof(struct list_processes_reply) == 24 );
C_ASSERT( offsetof(struct create_debug_obj_request, access) == 12 );
C_ASSERT( offsetof(struct create_debug_obj_request, flags) == 16 );
C_ASSERT( sizeof(struct create_debug_obj_request) == 24 );
C_ASSERT( offsetof(struct create_debug_obj_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_debug_obj_reply) == 16 );
C_ASSERT( offsetof(struct wait_debug_event_request, debug) == 12 );
C_ASSERT( sizeof(struct wait_debug_event_request) == 16 );
C_ASSERT( offsetof(struct wait_debug_event_reply, pid) == 8 );
C_ASSERT( offsetof(struct wait_debug_event_reply, tid) == 12 );
C_ASSERT( sizeof(struct wait_debug_event_reply) == 16 );
C_ASSERT( offsetof(struct queue_exception_event_request, first) == 12 );
C_ASSERT( offsetof(struct queue_exception_event_request, code) == 16 );
C_ASSERT( offsetof(struct queue_exception_event_request, flags) == 20 );
C_ASSERT( offsetof(struct queue_exception_event_request, record) == 24 );
C_ASSERT( offsetof(struct queue_exception_event_request, address) == 32 );
C_ASSERT( offsetof(struct queue_exception_event_request, len) == 40 );
C_ASSERT( sizeof(struct queue_exception_event_request) == 48 );
C_ASSERT( offsetof(struct queue_exception_event_reply, handle) == 8 );
C_ASSERT( sizeof(struct queue_exception_event_reply) == 16 );
C_ASSERT( offsetof(struct get_exception_status_request, handle) == 12 );
C_ASSERT( sizeof(struct get_exception_status_request) == 16 );
C_ASSERT( offsetof(struct continue_debug_event_request, debug) == 12 );
C_ASSERT( offsetof(struct continue_debug_event_request, pid) == 16 );
C_ASSERT( offsetof(struct continue_debug_event_request, tid) == 20 );
C_ASSERT( offsetof(struct continue_debug_event_request, status) == 24 );
C_ASSERT( sizeof(struct continue_debug_event_request) == 32 );
C_ASSERT( offsetof(struct debug_process_request, handle) == 12 );
C_ASSERT( offsetof(struct debug_process_request, debug) == 16 );
C_ASSERT( offsetof(struct debug_process_request, attach) == 20 );
C_ASSERT( sizeof(struct debug_process_request) == 24 );
C_ASSERT( offsetof(struct set_debug_obj_info_request, debug) == 12 );
C_ASSERT( offsetof(struct set_debug_obj_info_request, flags) == 16 );
C_ASSERT( sizeof(struct set_debug_obj_info_request) == 24 );
C_ASSERT( offsetof(struct read_process_memory_request, handle) == 12 );
C_ASSERT( offsetof(struct read_process_memory_request, addr) == 16 );
C_ASSERT( sizeof(struct read_process_memory_request) == 24 );
C_ASSERT( sizeof(struct read_process_memory_reply) == 8 );
C_ASSERT( offsetof(struct write_process_memory_request, handle) == 12 );
C_ASSERT( offsetof(struct write_process_memory_request, addr) == 16 );
C_ASSERT( sizeof(struct write_process_memory_request) == 24 );
C_ASSERT( offsetof(struct create_key_request, access) == 12 );
C_ASSERT( offsetof(struct create_key_request, options) == 16 );
C_ASSERT( sizeof(struct create_key_request) == 24 );
C_ASSERT( offsetof(struct create_key_reply, hkey) == 8 );
C_ASSERT( sizeof(struct create_key_reply) == 16 );
C_ASSERT( offsetof(struct open_key_request, parent) == 12 );
C_ASSERT( offsetof(struct open_key_request, access) == 16 );
C_ASSERT( offsetof(struct open_key_request, attributes) == 20 );
C_ASSERT( sizeof(struct open_key_request) == 24 );
C_ASSERT( offsetof(struct open_key_reply, hkey) == 8 );
C_ASSERT( sizeof(struct open_key_reply) == 16 );
C_ASSERT( offsetof(struct delete_key_request, hkey) == 12 );
C_ASSERT( sizeof(struct delete_key_request) == 16 );
C_ASSERT( offsetof(struct flush_key_request, hkey) == 12 );
C_ASSERT( sizeof(struct flush_key_request) == 16 );
C_ASSERT( offsetof(struct enum_key_request, hkey) == 12 );
C_ASSERT( offsetof(struct enum_key_request, index) == 16 );
C_ASSERT( offsetof(struct enum_key_request, info_class) == 20 );
C_ASSERT( sizeof(struct enum_key_request) == 24 );
C_ASSERT( offsetof(struct enum_key_reply, subkeys) == 8 );
C_ASSERT( offsetof(struct enum_key_reply, max_subkey) == 12 );
C_ASSERT( offsetof(struct enum_key_reply, max_class) == 16 );
C_ASSERT( offsetof(struct enum_key_reply, values) == 20 );
C_ASSERT( offsetof(struct enum_key_reply, max_value) == 24 );
C_ASSERT( offsetof(struct enum_key_reply, max_data) == 28 );
C_ASSERT( offsetof(struct enum_key_reply, modif) == 32 );
C_ASSERT( offsetof(struct enum_key_reply, total) == 40 );
C_ASSERT( offsetof(struct enum_key_reply, namelen) == 44 );
C_ASSERT( sizeof(struct enum_key_reply) == 48 );
C_ASSERT( offsetof(struct set_key_value_request, hkey) == 12 );
C_ASSERT( offsetof(struct set_key_value_request, type) == 16 );
C_ASSERT( offsetof(struct set_key_value_request, namelen) == 20 );
C_ASSERT( sizeof(struct set_key_value_request) == 24 );
C_ASSERT( offsetof(struct get_key_value_request, hkey) == 12 );
C_ASSERT( sizeof(struct get_key_value_request) == 16 );
C_ASSERT( offsetof(struct get_key_value_reply, type) == 8 );
C_ASSERT( offsetof(struct get_key_value_reply, total) == 12 );
C_ASSERT( sizeof(struct get_key_value_reply) == 16 );
C_ASSERT( offsetof(struct enum_key_value_request, hkey) == 12 );
C_ASSERT( offsetof(struct enum_key_value_request, index) == 16 );
C_ASSERT( offsetof(struct enum_key_value_request, info_class) == 20 );
C_ASSERT( sizeof(struct enum_key_value_request) == 24 );
C_ASSERT( offsetof(struct enum_key_value_reply, type) == 8 );
C_ASSERT( offsetof(struct enum_key_value_reply, total) == 12 );
C_ASSERT( offsetof(struct enum_key_value_reply, namelen) == 16 );
C_ASSERT( sizeof(struct enum_key_value_reply) == 24 );
C_ASSERT( offsetof(struct delete_key_value_request, hkey) == 12 );
C_ASSERT( sizeof(struct delete_key_value_request) == 16 );
C_ASSERT( offsetof(struct load_registry_request, file) == 12 );
C_ASSERT( sizeof(struct load_registry_request) == 16 );
C_ASSERT( offsetof(struct unload_registry_request, parent) == 12 );
C_ASSERT( offsetof(struct unload_registry_request, attributes) == 16 );
C_ASSERT( sizeof(struct unload_registry_request) == 24 );
C_ASSERT( offsetof(struct save_registry_request, hkey) == 12 );
C_ASSERT( offsetof(struct save_registry_request, file) == 16 );
C_ASSERT( sizeof(struct save_registry_request) == 24 );
C_ASSERT( offsetof(struct set_registry_notification_request, hkey) == 12 );
C_ASSERT( offsetof(struct set_registry_notification_request, event) == 16 );
C_ASSERT( offsetof(struct set_registry_notification_request, subtree) == 20 );
C_ASSERT( offsetof(struct set_registry_notification_request, filter) == 24 );
C_ASSERT( sizeof(struct set_registry_notification_request) == 32 );
C_ASSERT( offsetof(struct rename_key_request, hkey) == 12 );
C_ASSERT( sizeof(struct rename_key_request) == 16 );
C_ASSERT( offsetof(struct create_timer_request, access) == 12 );
C_ASSERT( offsetof(struct create_timer_request, manual) == 16 );
C_ASSERT( sizeof(struct create_timer_request) == 24 );
C_ASSERT( offsetof(struct create_timer_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_timer_reply) == 16 );
C_ASSERT( offsetof(struct open_timer_request, access) == 12 );
C_ASSERT( offsetof(struct open_timer_request, attributes) == 16 );
C_ASSERT( offsetof(struct open_timer_request, rootdir) == 20 );
C_ASSERT( sizeof(struct open_timer_request) == 24 );
C_ASSERT( offsetof(struct open_timer_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_timer_reply) == 16 );
C_ASSERT( offsetof(struct set_timer_request, handle) == 12 );
C_ASSERT( offsetof(struct set_timer_request, expire) == 16 );
C_ASSERT( offsetof(struct set_timer_request, callback) == 24 );
C_ASSERT( offsetof(struct set_timer_request, arg) == 32 );
C_ASSERT( offsetof(struct set_timer_request, period) == 40 );
C_ASSERT( sizeof(struct set_timer_request) == 48 );
C_ASSERT( offsetof(struct set_timer_reply, signaled) == 8 );
C_ASSERT( sizeof(struct set_timer_reply) == 16 );
C_ASSERT( offsetof(struct cancel_timer_request, handle) == 12 );
C_ASSERT( sizeof(struct cancel_timer_request) == 16 );
C_ASSERT( offsetof(struct cancel_timer_reply, signaled) == 8 );
C_ASSERT( sizeof(struct cancel_timer_reply) == 16 );
C_ASSERT( offsetof(struct get_timer_info_request, handle) == 12 );
C_ASSERT( sizeof(struct get_timer_info_request) == 16 );
C_ASSERT( offsetof(struct get_timer_info_reply, when) == 8 );
C_ASSERT( offsetof(struct get_timer_info_reply, signaled) == 16 );
C_ASSERT( sizeof(struct get_timer_info_reply) == 24 );
C_ASSERT( offsetof(struct get_thread_context_request, handle) == 12 );
C_ASSERT( offsetof(struct get_thread_context_request, context) == 16 );
C_ASSERT( offsetof(struct get_thread_context_request, flags) == 20 );
C_ASSERT( offsetof(struct get_thread_context_request, native_flags) == 24 );
C_ASSERT( offsetof(struct get_thread_context_request, machine) == 28 );
C_ASSERT( sizeof(struct get_thread_context_request) == 32 );
C_ASSERT( offsetof(struct get_thread_context_reply, self) == 8 );
C_ASSERT( offsetof(struct get_thread_context_reply, handle) == 12 );
C_ASSERT( sizeof(struct get_thread_context_reply) == 16 );
C_ASSERT( offsetof(struct set_thread_context_request, handle) == 12 );
C_ASSERT( offsetof(struct set_thread_context_request, native_flags) == 16 );
C_ASSERT( sizeof(struct set_thread_context_request) == 24 );
C_ASSERT( offsetof(struct set_thread_context_reply, self) == 8 );
C_ASSERT( sizeof(struct set_thread_context_reply) == 16 );
C_ASSERT( offsetof(struct get_selector_entry_request, handle) == 12 );
C_ASSERT( offsetof(struct get_selector_entry_request, entry) == 16 );
C_ASSERT( sizeof(struct get_selector_entry_request) == 24 );
C_ASSERT( offsetof(struct get_selector_entry_reply, base) == 8 );
C_ASSERT( offsetof(struct get_selector_entry_reply, limit) == 12 );
C_ASSERT( offsetof(struct get_selector_entry_reply, flags) == 16 );
C_ASSERT( sizeof(struct get_selector_entry_reply) == 24 );
C_ASSERT( sizeof(struct add_atom_request) == 16 );
C_ASSERT( offsetof(struct add_atom_reply, atom) == 8 );
C_ASSERT( sizeof(struct add_atom_reply) == 16 );
C_ASSERT( offsetof(struct delete_atom_request, atom) == 12 );
C_ASSERT( sizeof(struct delete_atom_request) == 16 );
C_ASSERT( sizeof(struct find_atom_request) == 16 );
C_ASSERT( offsetof(struct find_atom_reply, atom) == 8 );
C_ASSERT( sizeof(struct find_atom_reply) == 16 );
C_ASSERT( offsetof(struct get_atom_information_request, atom) == 12 );
C_ASSERT( sizeof(struct get_atom_information_request) == 16 );
C_ASSERT( offsetof(struct get_atom_information_reply, count) == 8 );
C_ASSERT( offsetof(struct get_atom_information_reply, pinned) == 12 );
C_ASSERT( offsetof(struct get_atom_information_reply, total) == 16 );
C_ASSERT( sizeof(struct get_atom_information_reply) == 24 );
C_ASSERT( sizeof(struct get_msg_queue_handle_request) == 16 );
C_ASSERT( offsetof(struct get_msg_queue_handle_reply, handle) == 8 );
C_ASSERT( sizeof(struct get_msg_queue_handle_reply) == 16 );
C_ASSERT( sizeof(struct get_msg_queue_request) == 16 );
C_ASSERT( offsetof(struct get_msg_queue_reply, locator) == 8 );
C_ASSERT( sizeof(struct get_msg_queue_reply) == 24 );
C_ASSERT( offsetof(struct set_queue_fd_request, handle) == 12 );
C_ASSERT( sizeof(struct set_queue_fd_request) == 16 );
C_ASSERT( offsetof(struct set_queue_mask_request, wake_mask) == 12 );
C_ASSERT( offsetof(struct set_queue_mask_request, changed_mask) == 16 );
C_ASSERT( offsetof(struct set_queue_mask_request, skip_wait) == 20 );
C_ASSERT( sizeof(struct set_queue_mask_request) == 24 );
C_ASSERT( offsetof(struct set_queue_mask_reply, wake_bits) == 8 );
C_ASSERT( offsetof(struct set_queue_mask_reply, changed_bits) == 12 );
C_ASSERT( sizeof(struct set_queue_mask_reply) == 16 );
C_ASSERT( offsetof(struct get_queue_status_request, clear_bits) == 12 );
C_ASSERT( sizeof(struct get_queue_status_request) == 16 );
C_ASSERT( offsetof(struct get_queue_status_reply, wake_bits) == 8 );
C_ASSERT( offsetof(struct get_queue_status_reply, changed_bits) == 12 );
C_ASSERT( sizeof(struct get_queue_status_reply) == 16 );
C_ASSERT( offsetof(struct get_process_idle_event_request, handle) == 12 );
C_ASSERT( sizeof(struct get_process_idle_event_request) == 16 );
C_ASSERT( offsetof(struct get_process_idle_event_reply, event) == 8 );
C_ASSERT( sizeof(struct get_process_idle_event_reply) == 16 );
C_ASSERT( offsetof(struct send_message_request, id) == 12 );
C_ASSERT( offsetof(struct send_message_request, type) == 16 );
C_ASSERT( offsetof(struct send_message_request, flags) == 20 );
C_ASSERT( offsetof(struct send_message_request, win) == 24 );
C_ASSERT( offsetof(struct send_message_request, msg) == 28 );
C_ASSERT( offsetof(struct send_message_request, wparam) == 32 );
C_ASSERT( offsetof(struct send_message_request, lparam) == 40 );
C_ASSERT( offsetof(struct send_message_request, timeout) == 48 );
C_ASSERT( sizeof(struct send_message_request) == 56 );
C_ASSERT( offsetof(struct post_quit_message_request, exit_code) == 12 );
C_ASSERT( sizeof(struct post_quit_message_request) == 16 );
C_ASSERT( offsetof(struct send_hardware_message_request, win) == 12 );
C_ASSERT( offsetof(struct send_hardware_message_request, input) == 16 );
C_ASSERT( offsetof(struct send_hardware_message_request, flags) == 56 );
C_ASSERT( sizeof(struct send_hardware_message_request) == 64 );
C_ASSERT( offsetof(struct send_hardware_message_reply, wait) == 8 );
C_ASSERT( offsetof(struct send_hardware_message_reply, prev_x) == 12 );
C_ASSERT( offsetof(struct send_hardware_message_reply, prev_y) == 16 );
C_ASSERT( offsetof(struct send_hardware_message_reply, new_x) == 20 );
C_ASSERT( offsetof(struct send_hardware_message_reply, new_y) == 24 );
C_ASSERT( sizeof(struct send_hardware_message_reply) == 32 );
C_ASSERT( offsetof(struct get_message_request, flags) == 12 );
C_ASSERT( offsetof(struct get_message_request, get_win) == 16 );
C_ASSERT( offsetof(struct get_message_request, get_first) == 20 );
C_ASSERT( offsetof(struct get_message_request, get_last) == 24 );
C_ASSERT( offsetof(struct get_message_request, hw_id) == 28 );
C_ASSERT( offsetof(struct get_message_request, wake_mask) == 32 );
C_ASSERT( offsetof(struct get_message_request, changed_mask) == 36 );
C_ASSERT( offsetof(struct get_message_request, internal) == 40 );
C_ASSERT( sizeof(struct get_message_request) == 48 );
C_ASSERT( offsetof(struct get_message_reply, win) == 8 );
C_ASSERT( offsetof(struct get_message_reply, msg) == 12 );
C_ASSERT( offsetof(struct get_message_reply, wparam) == 16 );
C_ASSERT( offsetof(struct get_message_reply, lparam) == 24 );
C_ASSERT( offsetof(struct get_message_reply, type) == 32 );
C_ASSERT( offsetof(struct get_message_reply, x) == 36 );
C_ASSERT( offsetof(struct get_message_reply, y) == 40 );
C_ASSERT( offsetof(struct get_message_reply, time) == 44 );
C_ASSERT( offsetof(struct get_message_reply, total) == 48 );
C_ASSERT( sizeof(struct get_message_reply) == 56 );
C_ASSERT( offsetof(struct reply_message_request, remove) == 12 );
C_ASSERT( offsetof(struct reply_message_request, result) == 16 );
C_ASSERT( sizeof(struct reply_message_request) == 24 );
C_ASSERT( offsetof(struct accept_hardware_message_request, hw_id) == 12 );
C_ASSERT( sizeof(struct accept_hardware_message_request) == 16 );
C_ASSERT( offsetof(struct get_message_reply_request, cancel) == 12 );
C_ASSERT( sizeof(struct get_message_reply_request) == 16 );
C_ASSERT( offsetof(struct get_message_reply_reply, result) == 8 );
C_ASSERT( sizeof(struct get_message_reply_reply) == 16 );
C_ASSERT( offsetof(struct set_win_timer_request, win) == 12 );
C_ASSERT( offsetof(struct set_win_timer_request, msg) == 16 );
C_ASSERT( offsetof(struct set_win_timer_request, rate) == 20 );
C_ASSERT( offsetof(struct set_win_timer_request, id) == 24 );
C_ASSERT( offsetof(struct set_win_timer_request, lparam) == 32 );
C_ASSERT( sizeof(struct set_win_timer_request) == 40 );
C_ASSERT( offsetof(struct set_win_timer_reply, id) == 8 );
C_ASSERT( sizeof(struct set_win_timer_reply) == 16 );
C_ASSERT( offsetof(struct kill_win_timer_request, win) == 12 );
C_ASSERT( offsetof(struct kill_win_timer_request, id) == 16 );
C_ASSERT( offsetof(struct kill_win_timer_request, msg) == 24 );
C_ASSERT( sizeof(struct kill_win_timer_request) == 32 );
C_ASSERT( offsetof(struct is_window_hung_request, win) == 12 );
C_ASSERT( sizeof(struct is_window_hung_request) == 16 );
C_ASSERT( offsetof(struct is_window_hung_reply, is_hung) == 8 );
C_ASSERT( sizeof(struct is_window_hung_reply) == 16 );
C_ASSERT( offsetof(struct get_serial_info_request, handle) == 12 );
C_ASSERT( offsetof(struct get_serial_info_request, flags) == 16 );
C_ASSERT( sizeof(struct get_serial_info_request) == 24 );
C_ASSERT( offsetof(struct get_serial_info_reply, eventmask) == 8 );
C_ASSERT( offsetof(struct get_serial_info_reply, pending_write) == 12 );
C_ASSERT( sizeof(struct get_serial_info_reply) == 16 );
C_ASSERT( offsetof(struct set_serial_info_request, handle) == 12 );
C_ASSERT( offsetof(struct set_serial_info_request, flags) == 16 );
C_ASSERT( sizeof(struct set_serial_info_request) == 24 );
C_ASSERT( offsetof(struct cancel_sync_request, handle) == 12 );
C_ASSERT( offsetof(struct cancel_sync_request, iosb) == 16 );
C_ASSERT( sizeof(struct cancel_sync_request) == 24 );
C_ASSERT( offsetof(struct register_async_request, type) == 12 );
C_ASSERT( offsetof(struct register_async_request, async) == 16 );
C_ASSERT( offsetof(struct register_async_request, count) == 56 );
C_ASSERT( sizeof(struct register_async_request) == 64 );
C_ASSERT( offsetof(struct cancel_async_request, handle) == 12 );
C_ASSERT( offsetof(struct cancel_async_request, iosb) == 16 );
C_ASSERT( offsetof(struct cancel_async_request, only_thread) == 24 );
C_ASSERT( sizeof(struct cancel_async_request) == 32 );
C_ASSERT( offsetof(struct get_async_result_request, user_arg) == 16 );
C_ASSERT( sizeof(struct get_async_result_request) == 24 );
C_ASSERT( sizeof(struct get_async_result_reply) == 8 );
C_ASSERT( offsetof(struct set_async_direct_result_request, handle) == 12 );
C_ASSERT( offsetof(struct set_async_direct_result_request, information) == 16 );
C_ASSERT( offsetof(struct set_async_direct_result_request, status) == 24 );
C_ASSERT( offsetof(struct set_async_direct_result_request, mark_pending) == 28 );
C_ASSERT( sizeof(struct set_async_direct_result_request) == 32 );
C_ASSERT( offsetof(struct set_async_direct_result_reply, handle) == 8 );
C_ASSERT( sizeof(struct set_async_direct_result_reply) == 16 );
C_ASSERT( offsetof(struct read_request, async) == 16 );
C_ASSERT( offsetof(struct read_request, pos) == 56 );
C_ASSERT( sizeof(struct read_request) == 64 );
C_ASSERT( offsetof(struct read_reply, wait) == 8 );
C_ASSERT( offsetof(struct read_reply, options) == 12 );
C_ASSERT( sizeof(struct read_reply) == 16 );
C_ASSERT( offsetof(struct write_request, async) == 16 );
C_ASSERT( offsetof(struct write_request, pos) == 56 );
C_ASSERT( sizeof(struct write_request) == 64 );
C_ASSERT( offsetof(struct write_reply, wait) == 8 );
C_ASSERT( offsetof(struct write_reply, options) == 12 );
C_ASSERT( offsetof(struct write_reply, size) == 16 );
C_ASSERT( sizeof(struct write_reply) == 24 );
C_ASSERT( offsetof(struct ioctl_request, code) == 12 );
C_ASSERT( offsetof(struct ioctl_request, async) == 16 );
C_ASSERT( sizeof(struct ioctl_request) == 56 );
C_ASSERT( offsetof(struct ioctl_reply, wait) == 8 );
C_ASSERT( offsetof(struct ioctl_reply, options) == 12 );
C_ASSERT( sizeof(struct ioctl_reply) == 16 );
C_ASSERT( offsetof(struct set_irp_result_request, handle) == 12 );
C_ASSERT( offsetof(struct set_irp_result_request, status) == 16 );
C_ASSERT( offsetof(struct set_irp_result_request, size) == 20 );
C_ASSERT( sizeof(struct set_irp_result_request) == 24 );
C_ASSERT( offsetof(struct create_named_pipe_request, access) == 12 );
C_ASSERT( offsetof(struct create_named_pipe_request, options) == 16 );
C_ASSERT( offsetof(struct create_named_pipe_request, sharing) == 20 );
C_ASSERT( offsetof(struct create_named_pipe_request, disposition) == 24 );
C_ASSERT( offsetof(struct create_named_pipe_request, maxinstances) == 28 );
C_ASSERT( offsetof(struct create_named_pipe_request, outsize) == 32 );
C_ASSERT( offsetof(struct create_named_pipe_request, insize) == 36 );
C_ASSERT( offsetof(struct create_named_pipe_request, timeout) == 40 );
C_ASSERT( offsetof(struct create_named_pipe_request, flags) == 48 );
C_ASSERT( sizeof(struct create_named_pipe_request) == 56 );
C_ASSERT( offsetof(struct create_named_pipe_reply, handle) == 8 );
C_ASSERT( offsetof(struct create_named_pipe_reply, created) == 12 );
C_ASSERT( sizeof(struct create_named_pipe_reply) == 16 );
C_ASSERT( offsetof(struct set_named_pipe_info_request, handle) == 12 );
C_ASSERT( offsetof(struct set_named_pipe_info_request, flags) == 16 );
C_ASSERT( sizeof(struct set_named_pipe_info_request) == 24 );
C_ASSERT( offsetof(struct create_window_request, parent) == 12 );
C_ASSERT( offsetof(struct create_window_request, owner) == 16 );
C_ASSERT( offsetof(struct create_window_request, atom) == 20 );
C_ASSERT( offsetof(struct create_window_request, instance) == 24 );
C_ASSERT( offsetof(struct create_window_request, dpi_context) == 32 );
C_ASSERT( offsetof(struct create_window_request, style) == 36 );
C_ASSERT( offsetof(struct create_window_request, ex_style) == 40 );
C_ASSERT( sizeof(struct create_window_request) == 48 );
C_ASSERT( offsetof(struct create_window_reply, handle) == 8 );
C_ASSERT( offsetof(struct create_window_reply, parent) == 12 );
C_ASSERT( offsetof(struct create_window_reply, owner) == 16 );
C_ASSERT( offsetof(struct create_window_reply, extra) == 20 );
C_ASSERT( offsetof(struct create_window_reply, class_ptr) == 24 );
C_ASSERT( offsetof(struct create_window_reply, dpi_context) == 32 );
C_ASSERT( sizeof(struct create_window_reply) == 40 );
C_ASSERT( offsetof(struct destroy_window_request, handle) == 12 );
C_ASSERT( sizeof(struct destroy_window_request) == 16 );
C_ASSERT( offsetof(struct get_desktop_window_request, force) == 12 );
C_ASSERT( sizeof(struct get_desktop_window_request) == 16 );
C_ASSERT( offsetof(struct get_desktop_window_reply, top_window) == 8 );
C_ASSERT( offsetof(struct get_desktop_window_reply, msg_window) == 12 );
C_ASSERT( sizeof(struct get_desktop_window_reply) == 16 );
C_ASSERT( offsetof(struct set_window_owner_request, handle) == 12 );
C_ASSERT( offsetof(struct set_window_owner_request, owner) == 16 );
C_ASSERT( sizeof(struct set_window_owner_request) == 24 );
C_ASSERT( offsetof(struct set_window_owner_reply, full_owner) == 8 );
C_ASSERT( offsetof(struct set_window_owner_reply, prev_owner) == 12 );
C_ASSERT( sizeof(struct set_window_owner_reply) == 16 );
C_ASSERT( offsetof(struct get_window_info_request, handle) == 12 );
C_ASSERT( sizeof(struct get_window_info_request) == 16 );
C_ASSERT( offsetof(struct get_window_info_reply, full_handle) == 8 );
C_ASSERT( offsetof(struct get_window_info_reply, last_active) == 12 );
C_ASSERT( offsetof(struct get_window_info_reply, pid) == 16 );
C_ASSERT( offsetof(struct get_window_info_reply, tid) == 20 );
C_ASSERT( offsetof(struct get_window_info_reply, atom) == 24 );
C_ASSERT( offsetof(struct get_window_info_reply, is_unicode) == 28 );
C_ASSERT( offsetof(struct get_window_info_reply, dpi_context) == 32 );
C_ASSERT( sizeof(struct get_window_info_reply) == 40 );
C_ASSERT( offsetof(struct set_window_info_request, flags) == 12 );
C_ASSERT( offsetof(struct set_window_info_request, is_unicode) == 14 );
C_ASSERT( offsetof(struct set_window_info_request, handle) == 16 );
C_ASSERT( offsetof(struct set_window_info_request, style) == 20 );
C_ASSERT( offsetof(struct set_window_info_request, ex_style) == 24 );
C_ASSERT( offsetof(struct set_window_info_request, extra_size) == 28 );
C_ASSERT( offsetof(struct set_window_info_request, instance) == 32 );
C_ASSERT( offsetof(struct set_window_info_request, user_data) == 40 );
C_ASSERT( offsetof(struct set_window_info_request, extra_value) == 48 );
C_ASSERT( offsetof(struct set_window_info_request, extra_offset) == 56 );
C_ASSERT( sizeof(struct set_window_info_request) == 64 );
C_ASSERT( offsetof(struct set_window_info_reply, old_style) == 8 );
C_ASSERT( offsetof(struct set_window_info_reply, old_ex_style) == 12 );
C_ASSERT( offsetof(struct set_window_info_reply, old_instance) == 16 );
C_ASSERT( offsetof(struct set_window_info_reply, old_user_data) == 24 );
C_ASSERT( offsetof(struct set_window_info_reply, old_extra_value) == 32 );
C_ASSERT( offsetof(struct set_window_info_reply, old_id) == 40 );
C_ASSERT( sizeof(struct set_window_info_reply) == 48 );
C_ASSERT( offsetof(struct set_parent_request, handle) == 12 );
C_ASSERT( offsetof(struct set_parent_request, parent) == 16 );
C_ASSERT( sizeof(struct set_parent_request) == 24 );
C_ASSERT( offsetof(struct set_parent_reply, old_parent) == 8 );
C_ASSERT( offsetof(struct set_parent_reply, full_parent) == 12 );
C_ASSERT( offsetof(struct set_parent_reply, dpi_context) == 16 );
C_ASSERT( sizeof(struct set_parent_reply) == 24 );
C_ASSERT( offsetof(struct get_window_parents_request, handle) == 12 );
C_ASSERT( sizeof(struct get_window_parents_request) == 16 );
C_ASSERT( offsetof(struct get_window_parents_reply, count) == 8 );
C_ASSERT( sizeof(struct get_window_parents_reply) == 16 );
C_ASSERT( offsetof(struct get_window_children_request, desktop) == 12 );
C_ASSERT( offsetof(struct get_window_children_request, parent) == 16 );
C_ASSERT( offsetof(struct get_window_children_request, atom) == 20 );
C_ASSERT( offsetof(struct get_window_children_request, tid) == 24 );
C_ASSERT( sizeof(struct get_window_children_request) == 32 );
C_ASSERT( offsetof(struct get_window_children_reply, count) == 8 );
C_ASSERT( sizeof(struct get_window_children_reply) == 16 );
C_ASSERT( offsetof(struct get_window_children_from_point_request, parent) == 12 );
C_ASSERT( offsetof(struct get_window_children_from_point_request, x) == 16 );
C_ASSERT( offsetof(struct get_window_children_from_point_request, y) == 20 );
C_ASSERT( offsetof(struct get_window_children_from_point_request, dpi) == 24 );
C_ASSERT( sizeof(struct get_window_children_from_point_request) == 32 );
C_ASSERT( offsetof(struct get_window_children_from_point_reply, count) == 8 );
C_ASSERT( sizeof(struct get_window_children_from_point_reply) == 16 );
C_ASSERT( offsetof(struct get_window_tree_request, handle) == 12 );
C_ASSERT( sizeof(struct get_window_tree_request) == 16 );
C_ASSERT( offsetof(struct get_window_tree_reply, parent) == 8 );
C_ASSERT( offsetof(struct get_window_tree_reply, owner) == 12 );
C_ASSERT( offsetof(struct get_window_tree_reply, next_sibling) == 16 );
C_ASSERT( offsetof(struct get_window_tree_reply, prev_sibling) == 20 );
C_ASSERT( offsetof(struct get_window_tree_reply, first_sibling) == 24 );
C_ASSERT( offsetof(struct get_window_tree_reply, last_sibling) == 28 );
C_ASSERT( offsetof(struct get_window_tree_reply, first_child) == 32 );
C_ASSERT( offsetof(struct get_window_tree_reply, last_child) == 36 );
C_ASSERT( sizeof(struct get_window_tree_reply) == 40 );
C_ASSERT( offsetof(struct set_window_pos_request, swp_flags) == 12 );
C_ASSERT( offsetof(struct set_window_pos_request, paint_flags) == 14 );
C_ASSERT( offsetof(struct set_window_pos_request, monitor_dpi) == 16 );
C_ASSERT( offsetof(struct set_window_pos_request, handle) == 20 );
C_ASSERT( offsetof(struct set_window_pos_request, previous) == 24 );
C_ASSERT( offsetof(struct set_window_pos_request, window) == 28 );
C_ASSERT( offsetof(struct set_window_pos_request, client) == 44 );
C_ASSERT( sizeof(struct set_window_pos_request) == 64 );
C_ASSERT( offsetof(struct set_window_pos_reply, new_style) == 8 );
C_ASSERT( offsetof(struct set_window_pos_reply, new_ex_style) == 12 );
C_ASSERT( offsetof(struct set_window_pos_reply, surface_win) == 16 );
C_ASSERT( offsetof(struct set_window_pos_reply, needs_update) == 20 );
C_ASSERT( sizeof(struct set_window_pos_reply) == 24 );
C_ASSERT( offsetof(struct get_window_rectangles_request, handle) == 12 );
C_ASSERT( offsetof(struct get_window_rectangles_request, relative) == 16 );
C_ASSERT( offsetof(struct get_window_rectangles_request, dpi) == 20 );
C_ASSERT( sizeof(struct get_window_rectangles_request) == 24 );
C_ASSERT( offsetof(struct get_window_rectangles_reply, window) == 8 );
C_ASSERT( offsetof(struct get_window_rectangles_reply, client) == 24 );
C_ASSERT( sizeof(struct get_window_rectangles_reply) == 40 );
C_ASSERT( offsetof(struct get_window_text_request, handle) == 12 );
C_ASSERT( sizeof(struct get_window_text_request) == 16 );
C_ASSERT( offsetof(struct get_window_text_reply, length) == 8 );
C_ASSERT( sizeof(struct get_window_text_reply) == 16 );
C_ASSERT( offsetof(struct set_window_text_request, handle) == 12 );
C_ASSERT( sizeof(struct set_window_text_request) == 16 );
C_ASSERT( offsetof(struct get_windows_offset_request, from) == 12 );
C_ASSERT( offsetof(struct get_windows_offset_request, to) == 16 );
C_ASSERT( offsetof(struct get_windows_offset_request, dpi) == 20 );
C_ASSERT( sizeof(struct get_windows_offset_request) == 24 );
C_ASSERT( offsetof(struct get_windows_offset_reply, x) == 8 );
C_ASSERT( offsetof(struct get_windows_offset_reply, y) == 12 );
C_ASSERT( offsetof(struct get_windows_offset_reply, mirror) == 16 );
C_ASSERT( sizeof(struct get_windows_offset_reply) == 24 );
C_ASSERT( offsetof(struct get_visible_region_request, window) == 12 );
C_ASSERT( offsetof(struct get_visible_region_request, flags) == 16 );
C_ASSERT( sizeof(struct get_visible_region_request) == 24 );
C_ASSERT( offsetof(struct get_visible_region_reply, top_win) == 8 );
C_ASSERT( offsetof(struct get_visible_region_reply, top_rect) == 12 );
C_ASSERT( offsetof(struct get_visible_region_reply, win_rect) == 28 );
C_ASSERT( offsetof(struct get_visible_region_reply, paint_flags) == 44 );
C_ASSERT( offsetof(struct get_visible_region_reply, total_size) == 48 );
C_ASSERT( sizeof(struct get_visible_region_reply) == 56 );
C_ASSERT( offsetof(struct get_window_region_request, window) == 12 );
C_ASSERT( offsetof(struct get_window_region_request, surface) == 16 );
C_ASSERT( sizeof(struct get_window_region_request) == 24 );
C_ASSERT( offsetof(struct get_window_region_reply, visible_rect) == 8 );
C_ASSERT( offsetof(struct get_window_region_reply, total_size) == 24 );
C_ASSERT( sizeof(struct get_window_region_reply) == 32 );
C_ASSERT( offsetof(struct set_window_region_request, window) == 12 );
C_ASSERT( offsetof(struct set_window_region_request, redraw) == 16 );
C_ASSERT( sizeof(struct set_window_region_request) == 24 );
C_ASSERT( offsetof(struct get_update_region_request, window) == 12 );
C_ASSERT( offsetof(struct get_update_region_request, from_child) == 16 );
C_ASSERT( offsetof(struct get_update_region_request, flags) == 20 );
C_ASSERT( sizeof(struct get_update_region_request) == 24 );
C_ASSERT( offsetof(struct get_update_region_reply, child) == 8 );
C_ASSERT( offsetof(struct get_update_region_reply, flags) == 12 );
C_ASSERT( offsetof(struct get_update_region_reply, total_size) == 16 );
C_ASSERT( sizeof(struct get_update_region_reply) == 24 );
C_ASSERT( offsetof(struct update_window_zorder_request, window) == 12 );
C_ASSERT( offsetof(struct update_window_zorder_request, rect) == 16 );
C_ASSERT( sizeof(struct update_window_zorder_request) == 32 );
C_ASSERT( offsetof(struct redraw_window_request, window) == 12 );
C_ASSERT( offsetof(struct redraw_window_request, flags) == 16 );
C_ASSERT( sizeof(struct redraw_window_request) == 24 );
C_ASSERT( offsetof(struct set_window_property_request, window) == 12 );
C_ASSERT( offsetof(struct set_window_property_request, data) == 16 );
C_ASSERT( offsetof(struct set_window_property_request, atom) == 24 );
C_ASSERT( sizeof(struct set_window_property_request) == 32 );
C_ASSERT( offsetof(struct remove_window_property_request, window) == 12 );
C_ASSERT( offsetof(struct remove_window_property_request, atom) == 16 );
C_ASSERT( sizeof(struct remove_window_property_request) == 24 );
C_ASSERT( offsetof(struct remove_window_property_reply, data) == 8 );
C_ASSERT( sizeof(struct remove_window_property_reply) == 16 );
C_ASSERT( offsetof(struct get_window_property_request, window) == 12 );
C_ASSERT( offsetof(struct get_window_property_request, atom) == 16 );
C_ASSERT( sizeof(struct get_window_property_request) == 24 );
C_ASSERT( offsetof(struct get_window_property_reply, data) == 8 );
C_ASSERT( sizeof(struct get_window_property_reply) == 16 );
C_ASSERT( offsetof(struct get_window_properties_request, window) == 12 );
C_ASSERT( sizeof(struct get_window_properties_request) == 16 );
C_ASSERT( offsetof(struct get_window_properties_reply, total) == 8 );
C_ASSERT( sizeof(struct get_window_properties_reply) == 16 );
C_ASSERT( offsetof(struct create_winstation_request, flags) == 12 );
C_ASSERT( offsetof(struct create_winstation_request, access) == 16 );
C_ASSERT( offsetof(struct create_winstation_request, attributes) == 20 );
C_ASSERT( offsetof(struct create_winstation_request, rootdir) == 24 );
C_ASSERT( sizeof(struct create_winstation_request) == 32 );
C_ASSERT( offsetof(struct create_winstation_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_winstation_reply) == 16 );
C_ASSERT( offsetof(struct open_winstation_request, access) == 12 );
C_ASSERT( offsetof(struct open_winstation_request, attributes) == 16 );
C_ASSERT( offsetof(struct open_winstation_request, rootdir) == 20 );
C_ASSERT( sizeof(struct open_winstation_request) == 24 );
C_ASSERT( offsetof(struct open_winstation_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_winstation_reply) == 16 );
C_ASSERT( offsetof(struct close_winstation_request, handle) == 12 );
C_ASSERT( sizeof(struct close_winstation_request) == 16 );
C_ASSERT( sizeof(struct set_winstation_monitors_request) == 16 );
C_ASSERT( sizeof(struct get_process_winstation_request) == 16 );
C_ASSERT( offsetof(struct get_process_winstation_reply, handle) == 8 );
C_ASSERT( sizeof(struct get_process_winstation_reply) == 16 );
C_ASSERT( offsetof(struct set_process_winstation_request, handle) == 12 );
C_ASSERT( sizeof(struct set_process_winstation_request) == 16 );
C_ASSERT( offsetof(struct enum_winstation_request, handle) == 12 );
C_ASSERT( sizeof(struct enum_winstation_request) == 16 );
C_ASSERT( offsetof(struct enum_winstation_reply, count) == 8 );
C_ASSERT( offsetof(struct enum_winstation_reply, total) == 12 );
C_ASSERT( sizeof(struct enum_winstation_reply) == 16 );
C_ASSERT( offsetof(struct create_desktop_request, flags) == 12 );
C_ASSERT( offsetof(struct create_desktop_request, access) == 16 );
C_ASSERT( offsetof(struct create_desktop_request, attributes) == 20 );
C_ASSERT( sizeof(struct create_desktop_request) == 24 );
C_ASSERT( offsetof(struct create_desktop_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_desktop_reply) == 16 );
C_ASSERT( offsetof(struct open_desktop_request, winsta) == 12 );
C_ASSERT( offsetof(struct open_desktop_request, flags) == 16 );
C_ASSERT( offsetof(struct open_desktop_request, access) == 20 );
C_ASSERT( offsetof(struct open_desktop_request, attributes) == 24 );
C_ASSERT( sizeof(struct open_desktop_request) == 32 );
C_ASSERT( offsetof(struct open_desktop_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_desktop_reply) == 16 );
C_ASSERT( offsetof(struct open_input_desktop_request, flags) == 12 );
C_ASSERT( offsetof(struct open_input_desktop_request, access) == 16 );
C_ASSERT( offsetof(struct open_input_desktop_request, attributes) == 20 );
C_ASSERT( sizeof(struct open_input_desktop_request) == 24 );
C_ASSERT( offsetof(struct open_input_desktop_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_input_desktop_reply) == 16 );
C_ASSERT( offsetof(struct set_input_desktop_request, handle) == 12 );
C_ASSERT( sizeof(struct set_input_desktop_request) == 16 );
C_ASSERT( offsetof(struct close_desktop_request, handle) == 12 );
C_ASSERT( sizeof(struct close_desktop_request) == 16 );
C_ASSERT( offsetof(struct get_thread_desktop_request, tid) == 12 );
C_ASSERT( sizeof(struct get_thread_desktop_request) == 16 );
C_ASSERT( offsetof(struct get_thread_desktop_reply, locator) == 8 );
C_ASSERT( offsetof(struct get_thread_desktop_reply, handle) == 24 );
C_ASSERT( sizeof(struct get_thread_desktop_reply) == 32 );
C_ASSERT( offsetof(struct set_thread_desktop_request, handle) == 12 );
C_ASSERT( sizeof(struct set_thread_desktop_request) == 16 );
C_ASSERT( offsetof(struct set_thread_desktop_reply, locator) == 8 );
C_ASSERT( sizeof(struct set_thread_desktop_reply) == 24 );
C_ASSERT( offsetof(struct set_user_object_info_request, handle) == 12 );
C_ASSERT( offsetof(struct set_user_object_info_request, flags) == 16 );
C_ASSERT( offsetof(struct set_user_object_info_request, obj_flags) == 20 );
C_ASSERT( sizeof(struct set_user_object_info_request) == 24 );
C_ASSERT( offsetof(struct set_user_object_info_reply, is_desktop) == 8 );
C_ASSERT( offsetof(struct set_user_object_info_reply, old_obj_flags) == 12 );
C_ASSERT( sizeof(struct set_user_object_info_reply) == 16 );
C_ASSERT( offsetof(struct register_hotkey_request, window) == 12 );
C_ASSERT( offsetof(struct register_hotkey_request, id) == 16 );
C_ASSERT( offsetof(struct register_hotkey_request, flags) == 20 );
C_ASSERT( offsetof(struct register_hotkey_request, vkey) == 24 );
C_ASSERT( sizeof(struct register_hotkey_request) == 32 );
C_ASSERT( offsetof(struct register_hotkey_reply, replaced) == 8 );
C_ASSERT( offsetof(struct register_hotkey_reply, flags) == 12 );
C_ASSERT( offsetof(struct register_hotkey_reply, vkey) == 16 );
C_ASSERT( sizeof(struct register_hotkey_reply) == 24 );
C_ASSERT( offsetof(struct unregister_hotkey_request, window) == 12 );
C_ASSERT( offsetof(struct unregister_hotkey_request, id) == 16 );
C_ASSERT( sizeof(struct unregister_hotkey_request) == 24 );
C_ASSERT( offsetof(struct unregister_hotkey_reply, flags) == 8 );
C_ASSERT( offsetof(struct unregister_hotkey_reply, vkey) == 12 );
C_ASSERT( sizeof(struct unregister_hotkey_reply) == 16 );
C_ASSERT( offsetof(struct attach_thread_input_request, tid_from) == 12 );
C_ASSERT( offsetof(struct attach_thread_input_request, tid_to) == 16 );
C_ASSERT( offsetof(struct attach_thread_input_request, attach) == 20 );
C_ASSERT( sizeof(struct attach_thread_input_request) == 24 );
C_ASSERT( offsetof(struct get_thread_input_request, tid) == 12 );
C_ASSERT( sizeof(struct get_thread_input_request) == 16 );
C_ASSERT( offsetof(struct get_thread_input_reply, locator) == 8 );
C_ASSERT( sizeof(struct get_thread_input_reply) == 24 );
C_ASSERT( sizeof(struct get_last_input_time_request) == 16 );
C_ASSERT( offsetof(struct get_last_input_time_reply, time) == 8 );
C_ASSERT( sizeof(struct get_last_input_time_reply) == 16 );
C_ASSERT( offsetof(struct get_key_state_request, async) == 12 );
C_ASSERT( offsetof(struct get_key_state_request, key) == 16 );
C_ASSERT( sizeof(struct get_key_state_request) == 24 );
C_ASSERT( offsetof(struct get_key_state_reply, state) == 8 );
C_ASSERT( sizeof(struct get_key_state_reply) == 16 );
C_ASSERT( offsetof(struct set_key_state_request, async) == 12 );
C_ASSERT( sizeof(struct set_key_state_request) == 16 );
C_ASSERT( offsetof(struct set_foreground_window_request, handle) == 12 );
C_ASSERT( sizeof(struct set_foreground_window_request) == 16 );
C_ASSERT( offsetof(struct set_foreground_window_reply, previous) == 8 );
C_ASSERT( offsetof(struct set_foreground_window_reply, send_msg_old) == 12 );
C_ASSERT( offsetof(struct set_foreground_window_reply, send_msg_new) == 16 );
C_ASSERT( sizeof(struct set_foreground_window_reply) == 24 );
C_ASSERT( offsetof(struct set_focus_window_request, handle) == 12 );
C_ASSERT( sizeof(struct set_focus_window_request) == 16 );
C_ASSERT( offsetof(struct set_focus_window_reply, previous) == 8 );
C_ASSERT( sizeof(struct set_focus_window_reply) == 16 );
C_ASSERT( offsetof(struct set_active_window_request, handle) == 12 );
C_ASSERT( sizeof(struct set_active_window_request) == 16 );
C_ASSERT( offsetof(struct set_active_window_reply, previous) == 8 );
C_ASSERT( sizeof(struct set_active_window_reply) == 16 );
C_ASSERT( offsetof(struct set_capture_window_request, handle) == 12 );
C_ASSERT( offsetof(struct set_capture_window_request, flags) == 16 );
C_ASSERT( sizeof(struct set_capture_window_request) == 24 );
C_ASSERT( offsetof(struct set_capture_window_reply, previous) == 8 );
C_ASSERT( offsetof(struct set_capture_window_reply, full_handle) == 12 );
C_ASSERT( sizeof(struct set_capture_window_reply) == 16 );
C_ASSERT( offsetof(struct set_caret_window_request, handle) == 12 );
C_ASSERT( offsetof(struct set_caret_window_request, width) == 16 );
C_ASSERT( offsetof(struct set_caret_window_request, height) == 20 );
C_ASSERT( sizeof(struct set_caret_window_request) == 24 );
C_ASSERT( offsetof(struct set_caret_window_reply, previous) == 8 );
C_ASSERT( offsetof(struct set_caret_window_reply, old_rect) == 12 );
C_ASSERT( offsetof(struct set_caret_window_reply, old_hide) == 28 );
C_ASSERT( offsetof(struct set_caret_window_reply, old_state) == 32 );
C_ASSERT( sizeof(struct set_caret_window_reply) == 40 );
C_ASSERT( offsetof(struct set_caret_info_request, flags) == 12 );
C_ASSERT( offsetof(struct set_caret_info_request, handle) == 16 );
C_ASSERT( offsetof(struct set_caret_info_request, x) == 20 );
C_ASSERT( offsetof(struct set_caret_info_request, y) == 24 );
C_ASSERT( offsetof(struct set_caret_info_request, hide) == 28 );
C_ASSERT( offsetof(struct set_caret_info_request, state) == 32 );
C_ASSERT( sizeof(struct set_caret_info_request) == 40 );
C_ASSERT( offsetof(struct set_caret_info_reply, full_handle) == 8 );
C_ASSERT( offsetof(struct set_caret_info_reply, old_rect) == 12 );
C_ASSERT( offsetof(struct set_caret_info_reply, old_hide) == 28 );
C_ASSERT( offsetof(struct set_caret_info_reply, old_state) == 32 );
C_ASSERT( sizeof(struct set_caret_info_reply) == 40 );
C_ASSERT( offsetof(struct set_hook_request, id) == 12 );
C_ASSERT( offsetof(struct set_hook_request, pid) == 16 );
C_ASSERT( offsetof(struct set_hook_request, tid) == 20 );
C_ASSERT( offsetof(struct set_hook_request, event_min) == 24 );
C_ASSERT( offsetof(struct set_hook_request, event_max) == 28 );
C_ASSERT( offsetof(struct set_hook_request, proc) == 32 );
C_ASSERT( offsetof(struct set_hook_request, flags) == 40 );
C_ASSERT( offsetof(struct set_hook_request, unicode) == 44 );
C_ASSERT( sizeof(struct set_hook_request) == 48 );
C_ASSERT( offsetof(struct set_hook_reply, handle) == 8 );
C_ASSERT( sizeof(struct set_hook_reply) == 16 );
C_ASSERT( offsetof(struct remove_hook_request, handle) == 12 );
C_ASSERT( offsetof(struct remove_hook_request, proc) == 16 );
C_ASSERT( offsetof(struct remove_hook_request, id) == 24 );
C_ASSERT( sizeof(struct remove_hook_request) == 32 );
C_ASSERT( sizeof(struct remove_hook_reply) == 8 );
C_ASSERT( offsetof(struct start_hook_chain_request, id) == 12 );
C_ASSERT( offsetof(struct start_hook_chain_request, event) == 16 );
C_ASSERT( offsetof(struct start_hook_chain_request, window) == 20 );
C_ASSERT( offsetof(struct start_hook_chain_request, object_id) == 24 );
C_ASSERT( offsetof(struct start_hook_chain_request, child_id) == 28 );
C_ASSERT( sizeof(struct start_hook_chain_request) == 32 );
C_ASSERT( offsetof(struct start_hook_chain_reply, handle) == 8 );
C_ASSERT( offsetof(struct start_hook_chain_reply, pid) == 12 );
C_ASSERT( offsetof(struct start_hook_chain_reply, tid) == 16 );
C_ASSERT( offsetof(struct start_hook_chain_reply, unicode) == 20 );
C_ASSERT( offsetof(struct start_hook_chain_reply, proc) == 24 );
C_ASSERT( sizeof(struct start_hook_chain_reply) == 32 );
C_ASSERT( offsetof(struct finish_hook_chain_request, id) == 12 );
C_ASSERT( sizeof(struct finish_hook_chain_request) == 16 );
C_ASSERT( offsetof(struct get_hook_info_request, handle) == 12 );
C_ASSERT( offsetof(struct get_hook_info_request, get_next) == 16 );
C_ASSERT( offsetof(struct get_hook_info_request, event) == 20 );
C_ASSERT( offsetof(struct get_hook_info_request, window) == 24 );
C_ASSERT( offsetof(struct get_hook_info_request, object_id) == 28 );
C_ASSERT( offsetof(struct get_hook_info_request, child_id) == 32 );
C_ASSERT( sizeof(struct get_hook_info_request) == 40 );
C_ASSERT( offsetof(struct get_hook_info_reply, handle) == 8 );
C_ASSERT( offsetof(struct get_hook_info_reply, id) == 12 );
C_ASSERT( offsetof(struct get_hook_info_reply, pid) == 16 );
C_ASSERT( offsetof(struct get_hook_info_reply, tid) == 20 );
C_ASSERT( offsetof(struct get_hook_info_reply, proc) == 24 );
C_ASSERT( offsetof(struct get_hook_info_reply, unicode) == 32 );
C_ASSERT( sizeof(struct get_hook_info_reply) == 40 );
C_ASSERT( offsetof(struct create_class_request, local) == 12 );
C_ASSERT( offsetof(struct create_class_request, atom) == 16 );
C_ASSERT( offsetof(struct create_class_request, style) == 20 );
C_ASSERT( offsetof(struct create_class_request, instance) == 24 );
C_ASSERT( offsetof(struct create_class_request, extra) == 32 );
C_ASSERT( offsetof(struct create_class_request, win_extra) == 36 );
C_ASSERT( offsetof(struct create_class_request, client_ptr) == 40 );
C_ASSERT( offsetof(struct create_class_request, name_offset) == 48 );
C_ASSERT( sizeof(struct create_class_request) == 56 );
C_ASSERT( offsetof(struct create_class_reply, atom) == 8 );
C_ASSERT( sizeof(struct create_class_reply) == 16 );
C_ASSERT( offsetof(struct destroy_class_request, atom) == 12 );
C_ASSERT( offsetof(struct destroy_class_request, instance) == 16 );
C_ASSERT( sizeof(struct destroy_class_request) == 24 );
C_ASSERT( offsetof(struct destroy_class_reply, client_ptr) == 8 );
C_ASSERT( sizeof(struct destroy_class_reply) == 16 );
C_ASSERT( offsetof(struct set_class_info_request, window) == 12 );
C_ASSERT( offsetof(struct set_class_info_request, flags) == 16 );
C_ASSERT( offsetof(struct set_class_info_request, atom) == 20 );
C_ASSERT( offsetof(struct set_class_info_request, style) == 24 );
C_ASSERT( offsetof(struct set_class_info_request, win_extra) == 28 );
C_ASSERT( offsetof(struct set_class_info_request, instance) == 32 );
C_ASSERT( offsetof(struct set_class_info_request, extra_offset) == 40 );
C_ASSERT( offsetof(struct set_class_info_request, extra_size) == 44 );
C_ASSERT( offsetof(struct set_class_info_request, extra_value) == 48 );
C_ASSERT( sizeof(struct set_class_info_request) == 56 );
C_ASSERT( offsetof(struct set_class_info_reply, old_atom) == 8 );
C_ASSERT( offsetof(struct set_class_info_reply, base_atom) == 12 );
C_ASSERT( offsetof(struct set_class_info_reply, old_instance) == 16 );
C_ASSERT( offsetof(struct set_class_info_reply, old_extra_value) == 24 );
C_ASSERT( offsetof(struct set_class_info_reply, old_style) == 32 );
C_ASSERT( offsetof(struct set_class_info_reply, old_extra) == 36 );
C_ASSERT( offsetof(struct set_class_info_reply, old_win_extra) == 40 );
C_ASSERT( sizeof(struct set_class_info_reply) == 48 );
C_ASSERT( offsetof(struct open_clipboard_request, window) == 12 );
C_ASSERT( sizeof(struct open_clipboard_request) == 16 );
C_ASSERT( offsetof(struct open_clipboard_reply, owner) == 8 );
C_ASSERT( sizeof(struct open_clipboard_reply) == 16 );
C_ASSERT( sizeof(struct close_clipboard_request) == 16 );
C_ASSERT( offsetof(struct close_clipboard_reply, viewer) == 8 );
C_ASSERT( offsetof(struct close_clipboard_reply, owner) == 12 );
C_ASSERT( sizeof(struct close_clipboard_reply) == 16 );
C_ASSERT( sizeof(struct empty_clipboard_request) == 16 );
C_ASSERT( offsetof(struct set_clipboard_data_request, format) == 12 );
C_ASSERT( offsetof(struct set_clipboard_data_request, lcid) == 16 );
C_ASSERT( sizeof(struct set_clipboard_data_request) == 24 );
C_ASSERT( offsetof(struct set_clipboard_data_reply, seqno) == 8 );
C_ASSERT( sizeof(struct set_clipboard_data_reply) == 16 );
C_ASSERT( offsetof(struct get_clipboard_data_request, format) == 12 );
C_ASSERT( offsetof(struct get_clipboard_data_request, render) == 16 );
C_ASSERT( offsetof(struct get_clipboard_data_request, cached) == 20 );
C_ASSERT( offsetof(struct get_clipboard_data_request, seqno) == 24 );
C_ASSERT( sizeof(struct get_clipboard_data_request) == 32 );
C_ASSERT( offsetof(struct get_clipboard_data_reply, from) == 8 );
C_ASSERT( offsetof(struct get_clipboard_data_reply, owner) == 12 );
C_ASSERT( offsetof(struct get_clipboard_data_reply, seqno) == 16 );
C_ASSERT( offsetof(struct get_clipboard_data_reply, total) == 20 );
C_ASSERT( sizeof(struct get_clipboard_data_reply) == 24 );
C_ASSERT( offsetof(struct get_clipboard_formats_request, format) == 12 );
C_ASSERT( sizeof(struct get_clipboard_formats_request) == 16 );
C_ASSERT( offsetof(struct get_clipboard_formats_reply, count) == 8 );
C_ASSERT( sizeof(struct get_clipboard_formats_reply) == 16 );
C_ASSERT( offsetof(struct enum_clipboard_formats_request, previous) == 12 );
C_ASSERT( sizeof(struct enum_clipboard_formats_request) == 16 );
C_ASSERT( offsetof(struct enum_clipboard_formats_reply, format) == 8 );
C_ASSERT( sizeof(struct enum_clipboard_formats_reply) == 16 );
C_ASSERT( offsetof(struct release_clipboard_request, owner) == 12 );
C_ASSERT( sizeof(struct release_clipboard_request) == 16 );
C_ASSERT( offsetof(struct release_clipboard_reply, viewer) == 8 );
C_ASSERT( offsetof(struct release_clipboard_reply, owner) == 12 );
C_ASSERT( sizeof(struct release_clipboard_reply) == 16 );
C_ASSERT( sizeof(struct get_clipboard_info_request) == 16 );
C_ASSERT( offsetof(struct get_clipboard_info_reply, window) == 8 );
C_ASSERT( offsetof(struct get_clipboard_info_reply, owner) == 12 );
C_ASSERT( offsetof(struct get_clipboard_info_reply, viewer) == 16 );
C_ASSERT( offsetof(struct get_clipboard_info_reply, seqno) == 20 );
C_ASSERT( sizeof(struct get_clipboard_info_reply) == 24 );
C_ASSERT( offsetof(struct set_clipboard_viewer_request, viewer) == 12 );
C_ASSERT( offsetof(struct set_clipboard_viewer_request, previous) == 16 );
C_ASSERT( sizeof(struct set_clipboard_viewer_request) == 24 );
C_ASSERT( offsetof(struct set_clipboard_viewer_reply, old_viewer) == 8 );
C_ASSERT( offsetof(struct set_clipboard_viewer_reply, owner) == 12 );
C_ASSERT( sizeof(struct set_clipboard_viewer_reply) == 16 );
C_ASSERT( offsetof(struct add_clipboard_listener_request, window) == 12 );
C_ASSERT( sizeof(struct add_clipboard_listener_request) == 16 );
C_ASSERT( offsetof(struct remove_clipboard_listener_request, window) == 12 );
C_ASSERT( sizeof(struct remove_clipboard_listener_request) == 16 );
C_ASSERT( offsetof(struct create_token_request, token_id) == 12 );
C_ASSERT( offsetof(struct create_token_request, access) == 20 );
C_ASSERT( offsetof(struct create_token_request, primary) == 24 );
C_ASSERT( offsetof(struct create_token_request, impersonation_level) == 28 );
C_ASSERT( offsetof(struct create_token_request, expire) == 32 );
C_ASSERT( offsetof(struct create_token_request, group_count) == 40 );
C_ASSERT( offsetof(struct create_token_request, primary_group) == 44 );
C_ASSERT( offsetof(struct create_token_request, priv_count) == 48 );
C_ASSERT( sizeof(struct create_token_request) == 56 );
C_ASSERT( offsetof(struct create_token_reply, token) == 8 );
C_ASSERT( sizeof(struct create_token_reply) == 16 );
C_ASSERT( offsetof(struct open_token_request, handle) == 12 );
C_ASSERT( offsetof(struct open_token_request, access) == 16 );
C_ASSERT( offsetof(struct open_token_request, attributes) == 20 );
C_ASSERT( offsetof(struct open_token_request, flags) == 24 );
C_ASSERT( sizeof(struct open_token_request) == 32 );
C_ASSERT( offsetof(struct open_token_reply, token) == 8 );
C_ASSERT( sizeof(struct open_token_reply) == 16 );
C_ASSERT( offsetof(struct set_desktop_shell_windows_request, flags) == 12 );
C_ASSERT( offsetof(struct set_desktop_shell_windows_request, shell_window) == 16 );
C_ASSERT( offsetof(struct set_desktop_shell_windows_request, shell_listview) == 20 );
C_ASSERT( offsetof(struct set_desktop_shell_windows_request, progman_window) == 24 );
C_ASSERT( offsetof(struct set_desktop_shell_windows_request, taskman_window) == 28 );
C_ASSERT( sizeof(struct set_desktop_shell_windows_request) == 32 );
C_ASSERT( offsetof(struct set_desktop_shell_windows_reply, old_shell_window) == 8 );
C_ASSERT( offsetof(struct set_desktop_shell_windows_reply, old_shell_listview) == 12 );
C_ASSERT( offsetof(struct set_desktop_shell_windows_reply, old_progman_window) == 16 );
C_ASSERT( offsetof(struct set_desktop_shell_windows_reply, old_taskman_window) == 20 );
C_ASSERT( sizeof(struct set_desktop_shell_windows_reply) == 24 );
C_ASSERT( offsetof(struct adjust_token_privileges_request, handle) == 12 );
C_ASSERT( offsetof(struct adjust_token_privileges_request, disable_all) == 16 );
C_ASSERT( offsetof(struct adjust_token_privileges_request, get_modified_state) == 20 );
C_ASSERT( sizeof(struct adjust_token_privileges_request) == 24 );
C_ASSERT( offsetof(struct adjust_token_privileges_reply, len) == 8 );
C_ASSERT( sizeof(struct adjust_token_privileges_reply) == 16 );
C_ASSERT( offsetof(struct get_token_privileges_request, handle) == 12 );
C_ASSERT( sizeof(struct get_token_privileges_request) == 16 );
C_ASSERT( offsetof(struct get_token_privileges_reply, len) == 8 );
C_ASSERT( sizeof(struct get_token_privileges_reply) == 16 );
C_ASSERT( offsetof(struct check_token_privileges_request, handle) == 12 );
C_ASSERT( offsetof(struct check_token_privileges_request, all_required) == 16 );
C_ASSERT( sizeof(struct check_token_privileges_request) == 24 );
C_ASSERT( offsetof(struct check_token_privileges_reply, has_privileges) == 8 );
C_ASSERT( sizeof(struct check_token_privileges_reply) == 16 );
C_ASSERT( offsetof(struct duplicate_token_request, handle) == 12 );
C_ASSERT( offsetof(struct duplicate_token_request, access) == 16 );
C_ASSERT( offsetof(struct duplicate_token_request, primary) == 20 );
C_ASSERT( offsetof(struct duplicate_token_request, impersonation_level) == 24 );
C_ASSERT( sizeof(struct duplicate_token_request) == 32 );
C_ASSERT( offsetof(struct duplicate_token_reply, new_handle) == 8 );
C_ASSERT( sizeof(struct duplicate_token_reply) == 16 );
C_ASSERT( offsetof(struct filter_token_request, handle) == 12 );
C_ASSERT( offsetof(struct filter_token_request, flags) == 16 );
C_ASSERT( offsetof(struct filter_token_request, privileges_size) == 20 );
C_ASSERT( sizeof(struct filter_token_request) == 24 );
C_ASSERT( offsetof(struct filter_token_reply, new_handle) == 8 );
C_ASSERT( sizeof(struct filter_token_reply) == 16 );
C_ASSERT( offsetof(struct access_check_request, handle) == 12 );
C_ASSERT( offsetof(struct access_check_request, desired_access) == 16 );
C_ASSERT( offsetof(struct access_check_request, mapping) == 20 );
C_ASSERT( sizeof(struct access_check_request) == 40 );
C_ASSERT( offsetof(struct access_check_reply, access_granted) == 8 );
C_ASSERT( offsetof(struct access_check_reply, access_status) == 12 );
C_ASSERT( offsetof(struct access_check_reply, privileges_len) == 16 );
C_ASSERT( sizeof(struct access_check_reply) == 24 );
C_ASSERT( offsetof(struct get_token_sid_request, handle) == 12 );
C_ASSERT( offsetof(struct get_token_sid_request, which_sid) == 16 );
C_ASSERT( sizeof(struct get_token_sid_request) == 24 );
C_ASSERT( offsetof(struct get_token_sid_reply, sid_len) == 8 );
C_ASSERT( sizeof(struct get_token_sid_reply) == 16 );
C_ASSERT( offsetof(struct get_token_groups_request, handle) == 12 );
C_ASSERT( offsetof(struct get_token_groups_request, attr_mask) == 16 );
C_ASSERT( sizeof(struct get_token_groups_request) == 24 );
C_ASSERT( offsetof(struct get_token_groups_reply, attr_len) == 8 );
C_ASSERT( offsetof(struct get_token_groups_reply, sid_len) == 12 );
C_ASSERT( sizeof(struct get_token_groups_reply) == 16 );
C_ASSERT( offsetof(struct get_token_default_dacl_request, handle) == 12 );
C_ASSERT( sizeof(struct get_token_default_dacl_request) == 16 );
C_ASSERT( offsetof(struct get_token_default_dacl_reply, acl_len) == 8 );
C_ASSERT( sizeof(struct get_token_default_dacl_reply) == 16 );
C_ASSERT( offsetof(struct set_token_default_dacl_request, handle) == 12 );
C_ASSERT( sizeof(struct set_token_default_dacl_request) == 16 );
C_ASSERT( offsetof(struct set_security_object_request, handle) == 12 );
C_ASSERT( offsetof(struct set_security_object_request, security_info) == 16 );
C_ASSERT( sizeof(struct set_security_object_request) == 24 );
C_ASSERT( offsetof(struct get_security_object_request, handle) == 12 );
C_ASSERT( offsetof(struct get_security_object_request, security_info) == 16 );
C_ASSERT( sizeof(struct get_security_object_request) == 24 );
C_ASSERT( offsetof(struct get_security_object_reply, sd_len) == 8 );
C_ASSERT( sizeof(struct get_security_object_reply) == 16 );
C_ASSERT( sizeof(struct get_system_handles_request) == 16 );
C_ASSERT( offsetof(struct get_system_handles_reply, count) == 8 );
C_ASSERT( sizeof(struct get_system_handles_reply) == 16 );
C_ASSERT( offsetof(struct get_tcp_connections_request, state_filter) == 12 );
C_ASSERT( sizeof(struct get_tcp_connections_request) == 16 );
C_ASSERT( offsetof(struct get_tcp_connections_reply, count) == 8 );
C_ASSERT( sizeof(struct get_tcp_connections_reply) == 16 );
C_ASSERT( sizeof(struct get_udp_endpoints_request) == 16 );
C_ASSERT( offsetof(struct get_udp_endpoints_reply, count) == 8 );
C_ASSERT( sizeof(struct get_udp_endpoints_reply) == 16 );
C_ASSERT( offsetof(struct create_mailslot_request, access) == 12 );
C_ASSERT( offsetof(struct create_mailslot_request, options) == 16 );
C_ASSERT( offsetof(struct create_mailslot_request, read_timeout) == 24 );
C_ASSERT( offsetof(struct create_mailslot_request, max_msgsize) == 32 );
C_ASSERT( sizeof(struct create_mailslot_request) == 40 );
C_ASSERT( offsetof(struct create_mailslot_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_mailslot_reply) == 16 );
C_ASSERT( offsetof(struct set_mailslot_info_request, handle) == 12 );
C_ASSERT( offsetof(struct set_mailslot_info_request, read_timeout) == 16 );
C_ASSERT( offsetof(struct set_mailslot_info_request, flags) == 24 );
C_ASSERT( sizeof(struct set_mailslot_info_request) == 32 );
C_ASSERT( offsetof(struct set_mailslot_info_reply, read_timeout) == 8 );
C_ASSERT( offsetof(struct set_mailslot_info_reply, max_msgsize) == 16 );
C_ASSERT( sizeof(struct set_mailslot_info_reply) == 24 );
C_ASSERT( offsetof(struct create_directory_request, access) == 12 );
C_ASSERT( sizeof(struct create_directory_request) == 16 );
C_ASSERT( offsetof(struct create_directory_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_directory_reply) == 16 );
C_ASSERT( offsetof(struct open_directory_request, access) == 12 );
C_ASSERT( offsetof(struct open_directory_request, attributes) == 16 );
C_ASSERT( offsetof(struct open_directory_request, rootdir) == 20 );
C_ASSERT( sizeof(struct open_directory_request) == 24 );
C_ASSERT( offsetof(struct open_directory_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_directory_reply) == 16 );
C_ASSERT( offsetof(struct get_directory_entries_request, handle) == 12 );
C_ASSERT( offsetof(struct get_directory_entries_request, index) == 16 );
C_ASSERT( offsetof(struct get_directory_entries_request, max_count) == 20 );
C_ASSERT( sizeof(struct get_directory_entries_request) == 24 );
C_ASSERT( offsetof(struct get_directory_entries_reply, total_len) == 8 );
C_ASSERT( offsetof(struct get_directory_entries_reply, count) == 12 );
C_ASSERT( sizeof(struct get_directory_entries_reply) == 16 );
C_ASSERT( offsetof(struct create_symlink_request, access) == 12 );
C_ASSERT( sizeof(struct create_symlink_request) == 16 );
C_ASSERT( offsetof(struct create_symlink_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_symlink_reply) == 16 );
C_ASSERT( offsetof(struct open_symlink_request, access) == 12 );
C_ASSERT( offsetof(struct open_symlink_request, attributes) == 16 );
C_ASSERT( offsetof(struct open_symlink_request, rootdir) == 20 );
C_ASSERT( sizeof(struct open_symlink_request) == 24 );
C_ASSERT( offsetof(struct open_symlink_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_symlink_reply) == 16 );
C_ASSERT( offsetof(struct query_symlink_request, handle) == 12 );
C_ASSERT( sizeof(struct query_symlink_request) == 16 );
C_ASSERT( offsetof(struct query_symlink_reply, total) == 8 );
C_ASSERT( sizeof(struct query_symlink_reply) == 16 );
C_ASSERT( offsetof(struct get_object_info_request, handle) == 12 );
C_ASSERT( sizeof(struct get_object_info_request) == 16 );
C_ASSERT( offsetof(struct get_object_info_reply, access) == 8 );
C_ASSERT( offsetof(struct get_object_info_reply, ref_count) == 12 );
C_ASSERT( offsetof(struct get_object_info_reply, handle_count) == 16 );
C_ASSERT( sizeof(struct get_object_info_reply) == 24 );
C_ASSERT( offsetof(struct get_object_name_request, handle) == 12 );
C_ASSERT( sizeof(struct get_object_name_request) == 16 );
C_ASSERT( offsetof(struct get_object_name_reply, total) == 8 );
C_ASSERT( sizeof(struct get_object_name_reply) == 16 );
C_ASSERT( offsetof(struct get_object_type_request, handle) == 12 );
C_ASSERT( sizeof(struct get_object_type_request) == 16 );
C_ASSERT( sizeof(struct get_object_type_reply) == 8 );
C_ASSERT( sizeof(struct get_object_types_request) == 16 );
C_ASSERT( offsetof(struct get_object_types_reply, count) == 8 );
C_ASSERT( sizeof(struct get_object_types_reply) == 16 );
C_ASSERT( sizeof(struct allocate_locally_unique_id_request) == 16 );
C_ASSERT( offsetof(struct allocate_locally_unique_id_reply, luid) == 8 );
C_ASSERT( sizeof(struct allocate_locally_unique_id_reply) == 16 );
C_ASSERT( offsetof(struct create_device_manager_request, access) == 12 );
C_ASSERT( offsetof(struct create_device_manager_request, attributes) == 16 );
C_ASSERT( sizeof(struct create_device_manager_request) == 24 );
C_ASSERT( offsetof(struct create_device_manager_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_device_manager_reply) == 16 );
C_ASSERT( offsetof(struct create_device_request, rootdir) == 12 );
C_ASSERT( offsetof(struct create_device_request, user_ptr) == 16 );
C_ASSERT( offsetof(struct create_device_request, manager) == 24 );
C_ASSERT( sizeof(struct create_device_request) == 32 );
C_ASSERT( offsetof(struct delete_device_request, manager) == 12 );
C_ASSERT( offsetof(struct delete_device_request, device) == 16 );
C_ASSERT( sizeof(struct delete_device_request) == 24 );
C_ASSERT( offsetof(struct get_next_device_request_request, manager) == 12 );
C_ASSERT( offsetof(struct get_next_device_request_request, prev) == 16 );
C_ASSERT( offsetof(struct get_next_device_request_request, status) == 20 );
C_ASSERT( offsetof(struct get_next_device_request_request, user_ptr) == 24 );
C_ASSERT( offsetof(struct get_next_device_request_request, pending) == 32 );
C_ASSERT( offsetof(struct get_next_device_request_request, iosb_status) == 36 );
C_ASSERT( offsetof(struct get_next_device_request_request, result) == 40 );
C_ASSERT( sizeof(struct get_next_device_request_request) == 48 );
C_ASSERT( offsetof(struct get_next_device_request_reply, params) == 8 );
C_ASSERT( offsetof(struct get_next_device_request_reply, next) == 40 );
C_ASSERT( offsetof(struct get_next_device_request_reply, client_tid) == 44 );
C_ASSERT( offsetof(struct get_next_device_request_reply, client_thread) == 48 );
C_ASSERT( offsetof(struct get_next_device_request_reply, in_size) == 56 );
C_ASSERT( sizeof(struct get_next_device_request_reply) == 64 );
C_ASSERT( offsetof(struct get_kernel_object_ptr_request, manager) == 12 );
C_ASSERT( offsetof(struct get_kernel_object_ptr_request, handle) == 16 );
C_ASSERT( sizeof(struct get_kernel_object_ptr_request) == 24 );
C_ASSERT( offsetof(struct get_kernel_object_ptr_reply, user_ptr) == 8 );
C_ASSERT( sizeof(struct get_kernel_object_ptr_reply) == 16 );
C_ASSERT( offsetof(struct set_kernel_object_ptr_request, manager) == 12 );
C_ASSERT( offsetof(struct set_kernel_object_ptr_request, handle) == 16 );
C_ASSERT( offsetof(struct set_kernel_object_ptr_request, user_ptr) == 24 );
C_ASSERT( sizeof(struct set_kernel_object_ptr_request) == 32 );
C_ASSERT( offsetof(struct grab_kernel_object_request, manager) == 12 );
C_ASSERT( offsetof(struct grab_kernel_object_request, user_ptr) == 16 );
C_ASSERT( sizeof(struct grab_kernel_object_request) == 24 );
C_ASSERT( offsetof(struct release_kernel_object_request, manager) == 12 );
C_ASSERT( offsetof(struct release_kernel_object_request, user_ptr) == 16 );
C_ASSERT( sizeof(struct release_kernel_object_request) == 24 );
C_ASSERT( offsetof(struct get_kernel_object_handle_request, manager) == 12 );
C_ASSERT( offsetof(struct get_kernel_object_handle_request, user_ptr) == 16 );
C_ASSERT( offsetof(struct get_kernel_object_handle_request, access) == 24 );
C_ASSERT( sizeof(struct get_kernel_object_handle_request) == 32 );
C_ASSERT( offsetof(struct get_kernel_object_handle_reply, handle) == 8 );
C_ASSERT( sizeof(struct get_kernel_object_handle_reply) == 16 );
C_ASSERT( offsetof(struct make_process_system_request, handle) == 12 );
C_ASSERT( sizeof(struct make_process_system_request) == 16 );
C_ASSERT( offsetof(struct make_process_system_reply, event) == 8 );
C_ASSERT( sizeof(struct make_process_system_reply) == 16 );
C_ASSERT( offsetof(struct get_token_info_request, handle) == 12 );
C_ASSERT( sizeof(struct get_token_info_request) == 16 );
C_ASSERT( offsetof(struct get_token_info_reply, token_id) == 8 );
C_ASSERT( offsetof(struct get_token_info_reply, modified_id) == 16 );
C_ASSERT( offsetof(struct get_token_info_reply, session_id) == 24 );
C_ASSERT( offsetof(struct get_token_info_reply, primary) == 28 );
C_ASSERT( offsetof(struct get_token_info_reply, impersonation_level) == 32 );
C_ASSERT( offsetof(struct get_token_info_reply, elevation) == 36 );
C_ASSERT( offsetof(struct get_token_info_reply, group_count) == 40 );
C_ASSERT( offsetof(struct get_token_info_reply, privilege_count) == 44 );
C_ASSERT( sizeof(struct get_token_info_reply) == 48 );
C_ASSERT( offsetof(struct create_linked_token_request, handle) == 12 );
C_ASSERT( sizeof(struct create_linked_token_request) == 16 );
C_ASSERT( offsetof(struct create_linked_token_reply, linked) == 8 );
C_ASSERT( sizeof(struct create_linked_token_reply) == 16 );
C_ASSERT( offsetof(struct create_completion_request, access) == 12 );
C_ASSERT( offsetof(struct create_completion_request, concurrent) == 16 );
C_ASSERT( sizeof(struct create_completion_request) == 24 );
C_ASSERT( offsetof(struct create_completion_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_completion_reply) == 16 );
C_ASSERT( offsetof(struct open_completion_request, access) == 12 );
C_ASSERT( offsetof(struct open_completion_request, attributes) == 16 );
C_ASSERT( offsetof(struct open_completion_request, rootdir) == 20 );
C_ASSERT( sizeof(struct open_completion_request) == 24 );
C_ASSERT( offsetof(struct open_completion_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_completion_reply) == 16 );
C_ASSERT( offsetof(struct add_completion_request, handle) == 12 );
C_ASSERT( offsetof(struct add_completion_request, ckey) == 16 );
C_ASSERT( offsetof(struct add_completion_request, cvalue) == 24 );
C_ASSERT( offsetof(struct add_completion_request, information) == 32 );
C_ASSERT( offsetof(struct add_completion_request, reserve_handle) == 40 );
C_ASSERT( offsetof(struct add_completion_request, status) == 44 );
C_ASSERT( sizeof(struct add_completion_request) == 48 );
C_ASSERT( offsetof(struct remove_completion_request, handle) == 12 );
C_ASSERT( offsetof(struct remove_completion_request, alertable) == 16 );
C_ASSERT( sizeof(struct remove_completion_request) == 24 );
C_ASSERT( offsetof(struct remove_completion_reply, ckey) == 8 );
C_ASSERT( offsetof(struct remove_completion_reply, cvalue) == 16 );
C_ASSERT( offsetof(struct remove_completion_reply, information) == 24 );
C_ASSERT( offsetof(struct remove_completion_reply, status) == 32 );
C_ASSERT( offsetof(struct remove_completion_reply, wait_handle) == 36 );
C_ASSERT( sizeof(struct remove_completion_reply) == 40 );
C_ASSERT( sizeof(struct get_thread_completion_request) == 16 );
C_ASSERT( offsetof(struct get_thread_completion_reply, ckey) == 8 );
C_ASSERT( offsetof(struct get_thread_completion_reply, cvalue) == 16 );
C_ASSERT( offsetof(struct get_thread_completion_reply, information) == 24 );
C_ASSERT( offsetof(struct get_thread_completion_reply, status) == 32 );
C_ASSERT( sizeof(struct get_thread_completion_reply) == 40 );
C_ASSERT( offsetof(struct query_completion_request, handle) == 12 );
C_ASSERT( sizeof(struct query_completion_request) == 16 );
C_ASSERT( offsetof(struct query_completion_reply, depth) == 8 );
C_ASSERT( sizeof(struct query_completion_reply) == 16 );
C_ASSERT( offsetof(struct set_completion_info_request, handle) == 12 );
C_ASSERT( offsetof(struct set_completion_info_request, ckey) == 16 );
C_ASSERT( offsetof(struct set_completion_info_request, chandle) == 24 );
C_ASSERT( sizeof(struct set_completion_info_request) == 32 );
C_ASSERT( offsetof(struct add_fd_completion_request, handle) == 12 );
C_ASSERT( offsetof(struct add_fd_completion_request, cvalue) == 16 );
C_ASSERT( offsetof(struct add_fd_completion_request, information) == 24 );
C_ASSERT( offsetof(struct add_fd_completion_request, status) == 32 );
C_ASSERT( offsetof(struct add_fd_completion_request, async) == 36 );
C_ASSERT( sizeof(struct add_fd_completion_request) == 40 );
C_ASSERT( offsetof(struct set_fd_completion_mode_request, handle) == 12 );
C_ASSERT( offsetof(struct set_fd_completion_mode_request, flags) == 16 );
C_ASSERT( sizeof(struct set_fd_completion_mode_request) == 24 );
C_ASSERT( offsetof(struct set_fd_disp_info_request, handle) == 12 );
C_ASSERT( offsetof(struct set_fd_disp_info_request, flags) == 16 );
C_ASSERT( sizeof(struct set_fd_disp_info_request) == 24 );
C_ASSERT( offsetof(struct set_fd_name_info_request, handle) == 12 );
C_ASSERT( offsetof(struct set_fd_name_info_request, rootdir) == 16 );
C_ASSERT( offsetof(struct set_fd_name_info_request, namelen) == 20 );
C_ASSERT( offsetof(struct set_fd_name_info_request, link) == 24 );
C_ASSERT( offsetof(struct set_fd_name_info_request, flags) == 28 );
C_ASSERT( sizeof(struct set_fd_name_info_request) == 32 );
C_ASSERT( offsetof(struct set_fd_eof_info_request, handle) == 12 );
C_ASSERT( offsetof(struct set_fd_eof_info_request, eof) == 16 );
C_ASSERT( sizeof(struct set_fd_eof_info_request) == 24 );
C_ASSERT( offsetof(struct get_window_layered_info_request, handle) == 12 );
C_ASSERT( sizeof(struct get_window_layered_info_request) == 16 );
C_ASSERT( offsetof(struct get_window_layered_info_reply, color_key) == 8 );
C_ASSERT( offsetof(struct get_window_layered_info_reply, alpha) == 12 );
C_ASSERT( offsetof(struct get_window_layered_info_reply, flags) == 16 );
C_ASSERT( sizeof(struct get_window_layered_info_reply) == 24 );
C_ASSERT( offsetof(struct set_window_layered_info_request, handle) == 12 );
C_ASSERT( offsetof(struct set_window_layered_info_request, color_key) == 16 );
C_ASSERT( offsetof(struct set_window_layered_info_request, alpha) == 20 );
C_ASSERT( offsetof(struct set_window_layered_info_request, flags) == 24 );
C_ASSERT( sizeof(struct set_window_layered_info_request) == 32 );
C_ASSERT( sizeof(struct alloc_user_handle_request) == 16 );
C_ASSERT( offsetof(struct alloc_user_handle_reply, handle) == 8 );
C_ASSERT( sizeof(struct alloc_user_handle_reply) == 16 );
C_ASSERT( offsetof(struct free_user_handle_request, handle) == 12 );
C_ASSERT( sizeof(struct free_user_handle_request) == 16 );
C_ASSERT( offsetof(struct set_cursor_request, flags) == 12 );
C_ASSERT( offsetof(struct set_cursor_request, handle) == 16 );
C_ASSERT( offsetof(struct set_cursor_request, show_count) == 20 );
C_ASSERT( offsetof(struct set_cursor_request, x) == 24 );
C_ASSERT( offsetof(struct set_cursor_request, y) == 28 );
C_ASSERT( offsetof(struct set_cursor_request, clip) == 32 );
C_ASSERT( sizeof(struct set_cursor_request) == 48 );
C_ASSERT( offsetof(struct set_cursor_reply, prev_handle) == 8 );
C_ASSERT( offsetof(struct set_cursor_reply, prev_count) == 12 );
C_ASSERT( offsetof(struct set_cursor_reply, prev_x) == 16 );
C_ASSERT( offsetof(struct set_cursor_reply, prev_y) == 20 );
C_ASSERT( offsetof(struct set_cursor_reply, new_x) == 24 );
C_ASSERT( offsetof(struct set_cursor_reply, new_y) == 28 );
C_ASSERT( offsetof(struct set_cursor_reply, new_clip) == 32 );
C_ASSERT( offsetof(struct set_cursor_reply, last_change) == 48 );
C_ASSERT( sizeof(struct set_cursor_reply) == 56 );
C_ASSERT( sizeof(struct get_cursor_history_request) == 16 );
C_ASSERT( sizeof(struct get_cursor_history_reply) == 8 );
C_ASSERT( offsetof(struct get_rawinput_buffer_request, header_size) == 12 );
C_ASSERT( offsetof(struct get_rawinput_buffer_request, read_data) == 16 );
C_ASSERT( sizeof(struct get_rawinput_buffer_request) == 24 );
C_ASSERT( offsetof(struct get_rawinput_buffer_reply, next_size) == 8 );
C_ASSERT( offsetof(struct get_rawinput_buffer_reply, time) == 12 );
C_ASSERT( offsetof(struct get_rawinput_buffer_reply, count) == 16 );
C_ASSERT( sizeof(struct get_rawinput_buffer_reply) == 24 );
C_ASSERT( sizeof(struct update_rawinput_devices_request) == 16 );
C_ASSERT( offsetof(struct create_job_request, access) == 12 );
C_ASSERT( sizeof(struct create_job_request) == 16 );
C_ASSERT( offsetof(struct create_job_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_job_reply) == 16 );
C_ASSERT( offsetof(struct open_job_request, access) == 12 );
C_ASSERT( offsetof(struct open_job_request, attributes) == 16 );
C_ASSERT( offsetof(struct open_job_request, rootdir) == 20 );
C_ASSERT( sizeof(struct open_job_request) == 24 );
C_ASSERT( offsetof(struct open_job_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_job_reply) == 16 );
C_ASSERT( offsetof(struct assign_job_request, job) == 12 );
C_ASSERT( offsetof(struct assign_job_request, process) == 16 );
C_ASSERT( sizeof(struct assign_job_request) == 24 );
C_ASSERT( offsetof(struct process_in_job_request, job) == 12 );
C_ASSERT( offsetof(struct process_in_job_request, process) == 16 );
C_ASSERT( sizeof(struct process_in_job_request) == 24 );
C_ASSERT( offsetof(struct set_job_limits_request, handle) == 12 );
C_ASSERT( offsetof(struct set_job_limits_request, limit_flags) == 16 );
C_ASSERT( sizeof(struct set_job_limits_request) == 24 );
C_ASSERT( offsetof(struct set_job_completion_port_request, job) == 12 );
C_ASSERT( offsetof(struct set_job_completion_port_request, port) == 16 );
C_ASSERT( offsetof(struct set_job_completion_port_request, key) == 24 );
C_ASSERT( sizeof(struct set_job_completion_port_request) == 32 );
C_ASSERT( offsetof(struct get_job_info_request, handle) == 12 );
C_ASSERT( sizeof(struct get_job_info_request) == 16 );
C_ASSERT( offsetof(struct get_job_info_reply, total_processes) == 8 );
C_ASSERT( offsetof(struct get_job_info_reply, active_processes) == 12 );
C_ASSERT( sizeof(struct get_job_info_reply) == 16 );
C_ASSERT( offsetof(struct terminate_job_request, handle) == 12 );
C_ASSERT( offsetof(struct terminate_job_request, status) == 16 );
C_ASSERT( sizeof(struct terminate_job_request) == 24 );
C_ASSERT( offsetof(struct suspend_process_request, handle) == 12 );
C_ASSERT( sizeof(struct suspend_process_request) == 16 );
C_ASSERT( offsetof(struct resume_process_request, handle) == 12 );
C_ASSERT( sizeof(struct resume_process_request) == 16 );
C_ASSERT( offsetof(struct get_next_thread_request, process) == 12 );
C_ASSERT( offsetof(struct get_next_thread_request, last) == 16 );
C_ASSERT( offsetof(struct get_next_thread_request, access) == 20 );
C_ASSERT( offsetof(struct get_next_thread_request, attributes) == 24 );
C_ASSERT( offsetof(struct get_next_thread_request, flags) == 28 );
C_ASSERT( sizeof(struct get_next_thread_request) == 32 );
C_ASSERT( offsetof(struct get_next_thread_reply, handle) == 8 );
C_ASSERT( sizeof(struct get_next_thread_reply) == 16 );
C_ASSERT( offsetof(struct set_keyboard_repeat_request, enable) == 12 );
C_ASSERT( offsetof(struct set_keyboard_repeat_request, delay) == 16 );
C_ASSERT( offsetof(struct set_keyboard_repeat_request, period) == 20 );
C_ASSERT( sizeof(struct set_keyboard_repeat_request) == 24 );
C_ASSERT( offsetof(struct set_keyboard_repeat_reply, enable) == 8 );
C_ASSERT( sizeof(struct set_keyboard_repeat_reply) == 16 );