server: Generate padding in request structures from make_requests.

include/wine/server_protocol.h

@@ -488,6 +488,7 @@ struct new_process_reply
     obj_handle_t phandle;
     thread_id_t  tid;
     obj_handle_t thandle;
+    char __pad_28[4];
 };
 
 
@@ -589,6 +590,7 @@ struct terminate_process_reply
 {
     struct reply_header __header;
     int          self;
+    char __pad_12[4];
 };
 
 
@@ -624,6 +626,7 @@ struct get_process_info_reply
     timeout_t    start_time;
     timeout_t    end_time;
     int          exit_code;
+    char __pad_52[4];
 };
 
 
@@ -635,6 +638,7 @@ struct set_process_info_request
     int          mask;
     int          priority;
     unsigned int affinity;
+    char __pad_28[4];
 };
 struct set_process_info_reply
 {
@@ -712,6 +716,7 @@ struct suspend_thread_reply
 {
     struct reply_header __header;
     int          count;
+    char __pad_12[4];
 };
 
 
@@ -725,6 +730,7 @@ struct resume_thread_reply
 {
     struct reply_header __header;
     int          count;
+    char __pad_12[4];
 };
 
 
@@ -739,6 +745,7 @@ struct load_dll_request
     int          dbg_offset;
     int          dbg_size;
     /* VARARG(filename,unicode_str); */
+    char __pad_44[4];
 };
 struct load_dll_reply
 {
@@ -750,7 +757,7 @@ struct load_dll_reply
 struct unload_dll_request
 {
     struct request_header __header;
-    int          __pad;
+    char __pad_12[4];
     mod_handle_t base;
 };
 struct unload_dll_reply
@@ -811,6 +818,7 @@ struct set_handle_info_reply
 {
     struct reply_header __header;
     int          old_flags;
+    char __pad_12[4];
 };
 
 
@@ -831,6 +839,7 @@ struct dup_handle_reply
     obj_handle_t handle;
     int          self;
     int          closed;
+    char __pad_20[4];
 };
 #define DUP_HANDLE_CLOSE_SOURCE  DUPLICATE_CLOSE_SOURCE
 #define DUP_HANDLE_SAME_ACCESS   DUPLICATE_SAME_ACCESS
@@ -849,6 +858,7 @@ struct open_process_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -864,6 +874,7 @@ struct open_thread_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -885,6 +896,7 @@ struct select_reply
     timeout_t    timeout;
     apc_call_t   call;
     obj_handle_t apc_handle;
+    char __pad_60[4];
 };
 #define SELECT_ALL           1
 #define SELECT_ALERTABLE     2
@@ -905,6 +917,7 @@ struct create_event_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -913,6 +926,7 @@ struct event_op_request
     struct request_header __header;
     obj_handle_t  handle;
     int           op;
+    char __pad_20[4];
 };
 struct event_op_reply
 {
@@ -934,6 +948,7 @@ struct open_event_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -950,6 +965,7 @@ struct create_mutex_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -963,6 +979,7 @@ struct release_mutex_reply
 {
     struct reply_header __header;
     unsigned int prev_count;
+    char __pad_12[4];
 };
 
 
@@ -979,6 +996,7 @@ struct open_mutex_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -996,6 +1014,7 @@ struct create_semaphore_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -1010,6 +1029,7 @@ struct release_semaphore_reply
 {
     struct reply_header __header;
     unsigned int prev_count;
+    char __pad_12[4];
 };
 
 
@@ -1026,6 +1046,7 @@ struct open_semaphore_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -1046,6 +1067,7 @@ struct create_file_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -1064,6 +1086,7 @@ struct open_file_object_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -1079,6 +1102,7 @@ struct alloc_file_handle_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -1121,6 +1145,7 @@ struct flush_file_reply
 {
     struct reply_header __header;
     obj_handle_t event;
+    char __pad_12[4];
 };
 
 
@@ -1171,6 +1196,7 @@ struct create_socket_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -1186,6 +1212,7 @@ struct accept_socket_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -1220,6 +1247,7 @@ struct get_socket_event_reply
     unsigned int pmask;
     unsigned int state;
     /* VARARG(errors,ints); */
+    char __pad_20[4];
 };
 
 
@@ -1231,6 +1259,7 @@ struct enable_socket_event_request
     unsigned int mask;
     unsigned int sstate;
     unsigned int cstate;
+    char __pad_28[4];
 };
 struct enable_socket_event_reply
 {
@@ -1242,6 +1271,7 @@ struct set_socket_deferred_request
     struct request_header __header;
     obj_handle_t handle;
     obj_handle_t deferred;
+    char __pad_20[4];
 };
 struct set_socket_deferred_reply
 {
@@ -1268,6 +1298,7 @@ struct alloc_console_reply
 struct free_console_request
 {
     struct request_header __header;
+    char __pad_12[4];
 };
 struct free_console_reply
 {
@@ -1346,6 +1377,7 @@ struct open_console_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -1358,6 +1390,7 @@ struct get_console_wait_event_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -1370,6 +1403,7 @@ struct get_console_mode_reply
 {
     struct reply_header __header;
     int          mode;
+    char __pad_12[4];
 };
 
 
@@ -1379,6 +1413,7 @@ struct set_console_mode_request
     struct request_header __header;
     obj_handle_t handle;
     int          mode;
+    char __pad_20[4];
 };
 struct set_console_mode_reply
 {
@@ -1432,6 +1467,7 @@ struct get_console_input_info_reply
     int           output_cp;
     user_handle_t win;
     /* VARARG(title,unicode_str); */
+    char __pad_36[4];
 };
 
 
@@ -1460,6 +1496,7 @@ struct get_console_input_history_reply
     struct reply_header __header;
     int          total;
     /* VARARG(line,unicode_str); */
+    char __pad_12[4];
 };
 
 
@@ -1476,6 +1513,7 @@ struct create_console_output_reply
 {
     struct reply_header __header;
     obj_handle_t handle_out;
+    char __pad_12[4];
 };
 
 
@@ -1498,6 +1536,7 @@ struct set_console_output_info_request
     short int    win_bottom;
     short int    max_width;
     short int    max_height;
+    char __pad_46[2];
 };
 struct set_console_output_info_reply
 {
@@ -1533,6 +1572,7 @@ struct get_console_output_info_reply
     short int    win_bottom;
     short int    max_width;
     short int    max_height;
+    char __pad_34[6];
 };
 
 
@@ -1546,6 +1586,7 @@ struct write_console_input_reply
 {
     struct reply_header __header;
     int          written;
+    char __pad_12[4];
 };
 
 
@@ -1561,6 +1602,7 @@ struct read_console_input_reply
     struct reply_header __header;
     int          read;
     /* VARARG(rec,input_records); */
+    char __pad_12[4];
 };
 
 
@@ -1581,6 +1623,7 @@ struct write_console_output_reply
     int          written;
     int          width;
     int          height;
+    char __pad_20[4];
 };
 enum char_info_mode
 {
@@ -1607,6 +1650,7 @@ struct fill_console_output_reply
 {
     struct reply_header __header;
     int          written;
+    char __pad_12[4];
 };
 
 
@@ -1640,6 +1684,7 @@ struct move_console_output_request
     short int    y_dst;
     short int    w;
     short int    h;
+    char __pad_28[4];
 };
 struct move_console_output_reply
 {
@@ -1653,6 +1698,7 @@ struct send_console_signal_request
     struct request_header __header;
     int          signal;
     process_id_t group_id;
+    char __pad_20[4];
 };
 struct send_console_signal_reply
 {
@@ -1685,6 +1731,7 @@ struct read_change_reply
     struct reply_header __header;
     int          action;
     /* VARARG(name,string); */
+    char __pad_12[4];
 };
 
 
@@ -1703,6 +1750,7 @@ struct create_mapping_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 #define VPROT_READ       0x01
@@ -1733,6 +1781,7 @@ struct open_mapping_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -1767,6 +1816,7 @@ struct get_mapping_committed_range_reply
     struct reply_header __header;
     mem_size_t   size;
     int          committed;
+    char __pad_20[4];
 };
 
 
@@ -1797,6 +1847,7 @@ struct create_snapshot_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -1835,6 +1886,7 @@ struct next_thread_reply
     thread_id_t  tid;
     int          base_pri;
     int          delta_pri;
+    char __pad_28[4];
 };
 
 
@@ -1851,6 +1903,7 @@ struct wait_debug_event_reply
     thread_id_t   tid;
     obj_handle_t  wait;
     /* VARARG(event,debug_event); */
+    char __pad_20[4];
 };
 
 
@@ -1871,6 +1924,7 @@ struct queue_exception_event_reply
 {
     struct reply_header __header;
     obj_handle_t     handle;
+    char __pad_12[4];
 };
 
 
@@ -1894,6 +1948,7 @@ struct output_debug_string_request
     data_size_t   length;
     client_ptr_t  string;
     int           unicode;
+    char __pad_28[4];
 };
 struct output_debug_string_reply
 {
@@ -1921,6 +1976,7 @@ struct debug_process_request
     struct request_header __header;
     process_id_t pid;
     int          attach;
+    char __pad_20[4];
 };
 struct debug_process_reply
 {
@@ -1938,6 +1994,7 @@ struct debug_break_reply
 {
     struct reply_header __header;
     int          self;
+    char __pad_12[4];
 };
 
 
@@ -2013,6 +2070,7 @@ struct open_key_reply
 {
     struct reply_header __header;
     obj_handle_t hkey;
+    char __pad_12[4];
 };
 
 
@@ -2113,6 +2171,7 @@ struct enum_key_value_reply
     data_size_t  namelen;
     /* VARARG(name,unicode_str,namelen); */
     /* VARARG(data,bytes); */
+    char __pad_20[4];
 };
 
 
@@ -2136,6 +2195,7 @@ struct load_registry_request
     obj_handle_t hkey;
     obj_handle_t file;
     /* VARARG(name,unicode_str); */
+    char __pad_20[4];
 };
 struct load_registry_reply
 {
@@ -2161,6 +2221,7 @@ struct save_registry_request
     struct request_header __header;
     obj_handle_t hkey;
     obj_handle_t file;
+    char __pad_20[4];
 };
 struct save_registry_reply
 {
@@ -2176,6 +2237,7 @@ struct set_registry_notification_request
     obj_handle_t event;
     int          subtree;
     unsigned int filter;
+    char __pad_28[4];
 };
 struct set_registry_notification_reply
 {
@@ -2197,6 +2259,7 @@ struct create_timer_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -2213,6 +2276,7 @@ struct open_timer_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -2229,6 +2293,7 @@ struct set_timer_reply
 {
     struct reply_header __header;
     int          signaled;
+    char __pad_12[4];
 };
 
 
@@ -2241,6 +2306,7 @@ struct cancel_timer_reply
 {
     struct reply_header __header;
      int         signaled;
+    char __pad_12[4];
 };
 
 
@@ -2254,6 +2320,7 @@ struct get_timer_info_reply
     struct reply_header __header;
     timeout_t    when;
     int          signaled;
+    char __pad_20[4];
 };
 
 
@@ -2270,6 +2337,7 @@ struct get_thread_context_reply
     struct reply_header __header;
     int          self;
     /* VARARG(context,context); */
+    char __pad_12[4];
 };
 
 
@@ -2286,6 +2354,7 @@ struct set_thread_context_reply
 {
     struct reply_header __header;
     int          self;
+    char __pad_12[4];
 };
 
 
@@ -2302,6 +2371,7 @@ struct get_selector_entry_reply
     unsigned int  base;
     unsigned int  limit;
     unsigned char flags;
+    char __pad_17[7];
 };
 
 
@@ -2316,6 +2386,7 @@ struct add_atom_reply
 {
     struct reply_header __header;
     atom_t        atom;
+    char __pad_12[4];
 };
 
 
@@ -2325,6 +2396,7 @@ struct delete_atom_request
     struct request_header __header;
     obj_handle_t  table;
     atom_t        atom;
+    char __pad_20[4];
 };
 struct delete_atom_reply
 {
@@ -2343,6 +2415,7 @@ struct find_atom_reply
 {
     struct reply_header __header;
     atom_t       atom;
+    char __pad_12[4];
 };
 
 
@@ -2360,6 +2433,7 @@ struct get_atom_information_reply
     int          pinned;
     data_size_t  total;
     /* VARARG(name,unicode_str); */
+    char __pad_20[4];
 };
 
 
@@ -2383,6 +2457,7 @@ struct empty_atom_table_request
     struct request_header __header;
     obj_handle_t table;
     int          if_pinned;
+    char __pad_20[4];
 };
 struct empty_atom_table_reply
 {
@@ -2400,6 +2475,7 @@ struct init_atom_table_reply
 {
     struct reply_header __header;
     obj_handle_t table;
+    char __pad_12[4];
 };
 
 
@@ -2412,6 +2488,7 @@ struct get_msg_queue_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -2467,6 +2544,7 @@ struct get_process_idle_event_reply
 {
     struct reply_header __header;
     obj_handle_t event;
+    char __pad_12[4];
 };
 
 
@@ -2527,6 +2605,7 @@ struct send_hardware_message_request
     int             x;
     int             y;
     unsigned int    time;
+    char __pad_60[4];
 };
 struct send_hardware_message_reply
 {
@@ -2627,6 +2706,7 @@ struct kill_win_timer_request
     user_handle_t   win;
     lparam_t        id;
     unsigned int    msg;
+    char __pad_28[4];
 };
 struct kill_win_timer_reply
 {
@@ -2644,6 +2724,7 @@ struct is_window_hung_reply
 {
     struct reply_header __header;
     int is_hung;
+    char __pad_12[4];
 };
 
 
@@ -2677,6 +2758,7 @@ struct set_serial_info_request
     unsigned int writeconst;
     unsigned int writemult;
     unsigned int eventmask;
+    char __pad_44[4];
 };
 struct set_serial_info_reply
 {
@@ -2693,6 +2775,7 @@ struct register_async_request
     int          type;
     async_data_t async;
     int          count;
+    char __pad_60[4];
 };
 struct register_async_reply
 {
@@ -2766,6 +2849,7 @@ struct create_named_pipe_reply
 {
     struct reply_header __header;
     obj_handle_t   handle;
+    char __pad_12[4];
 };
 
 
@@ -2788,6 +2872,7 @@ struct get_named_pipe_info_reply
     unsigned int   instances;
     unsigned int   outsize;
     unsigned int   insize;
+    char __pad_28[4];
 };
 
 
@@ -2896,6 +2981,7 @@ struct set_window_info_reply
     lparam_t       old_user_data;
     lparam_t       old_extra_value;
     unsigned int   old_id;
+    char __pad_44[4];
 };
 #define SET_WIN_STYLE     0x01
 #define SET_WIN_EXSTYLE   0x02
@@ -2932,6 +3018,7 @@ struct get_window_parents_reply
     struct reply_header __header;
     int            count;
     /* VARARG(parents,user_handles); */
+    char __pad_12[4];
 };
 
 
@@ -2950,6 +3037,7 @@ struct get_window_children_reply
     struct reply_header __header;
     int            count;
     /* VARARG(children,user_handles); */
+    char __pad_12[4];
 };
 
 
@@ -2966,6 +3054,7 @@ struct get_window_children_from_point_reply
     struct reply_header __header;
     int            count;
     /* VARARG(children,user_handles); */
+    char __pad_12[4];
 };
 
 
@@ -3092,6 +3181,7 @@ struct get_window_region_reply
     struct reply_header __header;
     data_size_t    total_size;
     /* VARARG(region,rectangles); */
+    char __pad_12[4];
 };
 
 
@@ -3102,6 +3192,7 @@ struct set_window_region_request
     user_handle_t  window;
     int            redraw;
     /* VARARG(region,rectangles); */
+    char __pad_20[4];
 };
 struct set_window_region_reply
 {
@@ -3124,6 +3215,7 @@ struct get_update_region_reply
     unsigned int   flags;
     data_size_t    total_size;
     /* VARARG(region,rectangles); */
+    char __pad_20[4];
 };
 #define UPDATE_NONCLIENT       0x01
 #define UPDATE_ERASE           0x02
@@ -3155,6 +3247,7 @@ struct redraw_window_request
     user_handle_t  window;
     unsigned int   flags;
     /* VARARG(region,rectangles); */
+    char __pad_20[4];
 };
 struct redraw_window_reply
 {
@@ -3170,6 +3263,7 @@ struct set_window_property_request
     lparam_t       data;
     atom_t         atom;
     /* VARARG(name,unicode_str); */
+    char __pad_28[4];
 };
 struct set_window_property_reply
 {
@@ -3218,6 +3312,7 @@ struct get_window_properties_reply
     struct reply_header __header;
     int            total;
     /* VARARG(props,properties); */
+    char __pad_12[4];
 };
 
 
@@ -3234,6 +3329,7 @@ struct create_winstation_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -3249,6 +3345,7 @@ struct open_winstation_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -3273,6 +3370,7 @@ struct get_process_winstation_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -3299,6 +3397,7 @@ struct enum_winstation_reply
     struct reply_header __header;
     unsigned int next;
     /* VARARG(name,unicode_str); */
+    char __pad_12[4];
 };
 
 
@@ -3315,6 +3414,7 @@ struct create_desktop_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -3332,6 +3432,7 @@ struct open_desktop_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -3357,6 +3458,7 @@ struct get_thread_desktop_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -3384,6 +3486,7 @@ struct enum_desktop_reply
     struct reply_header __header;
     unsigned int next;
     /* VARARG(name,unicode_str); */
+    char __pad_12[4];
 };
 
 
@@ -3436,6 +3539,7 @@ struct get_thread_input_reply
     user_handle_t  move_size;
     user_handle_t  caret;
     rectangle_t    rect;
+    char __pad_52[4];
 };
 
 
@@ -3448,6 +3552,7 @@ struct get_last_input_time_reply
 {
     struct reply_header __header;
     unsigned int time;
+    char __pad_12[4];
 };
 
 
@@ -3463,6 +3568,7 @@ struct get_key_state_reply
     struct reply_header __header;
     unsigned char  state;
     /* VARARG(keystate,bytes); */
+    char __pad_9[7];
 };
 
 
@@ -3489,6 +3595,7 @@ struct set_foreground_window_reply
     user_handle_t  previous;
     int            send_msg_old;
     int            send_msg_new;
+    char __pad_20[4];
 };
 
 
@@ -3501,6 +3608,7 @@ struct set_focus_window_reply
 {
     struct reply_header __header;
     user_handle_t  previous;
+    char __pad_12[4];
 };
 
 
@@ -3513,6 +3621,7 @@ struct set_active_window_reply
 {
     struct reply_header __header;
     user_handle_t  previous;
+    char __pad_12[4];
 };
 
 
@@ -3547,6 +3656,7 @@ struct set_caret_window_reply
     rectangle_t    old_rect;
     int            old_hide;
     int            old_state;
+    char __pad_36[4];
 };
 
 
@@ -3568,6 +3678,7 @@ struct set_caret_info_reply
     rectangle_t    old_rect;
     int            old_hide;
     int            old_state;
+    char __pad_36[4];
 };
 #define SET_CARET_POS        0x01
 #define SET_CARET_HIDE       0x02
@@ -3608,6 +3719,7 @@ struct remove_hook_reply
 {
     struct reply_header __header;
     unsigned int   active_hooks;
+    char __pad_12[4];
 };
 
 
@@ -3631,6 +3743,7 @@ struct start_hook_chain_reply
     client_ptr_t   proc;
     unsigned int   active_hooks;
     /* VARARG(module,unicode_str); */
+    char __pad_36[4];
 };
 
 
@@ -3667,6 +3780,7 @@ struct get_hook_info_reply
     client_ptr_t   proc;
     int            unicode;
     /* VARARG(module,unicode_str); */
+    char __pad_36[4];
 };
 
 
@@ -3687,6 +3801,7 @@ struct create_class_reply
 {
     struct reply_header __header;
     atom_t         atom;
+    char __pad_12[4];
 };
 
 
@@ -3754,6 +3869,7 @@ struct set_clipboard_info_reply
     user_handle_t  old_owner;
     user_handle_t  old_viewer;
     unsigned int   seqno;
+    char __pad_28[4];
 };
 
 #define SET_CB_OPEN      0x001
@@ -3780,6 +3896,7 @@ struct open_token_reply
 {
     struct reply_header __header;
     obj_handle_t   token;
+    char __pad_12[4];
 };
 #define OPEN_TOKEN_THREAD   1
 #define OPEN_TOKEN_AS_SELF  2
@@ -3821,6 +3938,7 @@ struct adjust_token_privileges_reply
     struct reply_header __header;
     unsigned int  len;
     /* VARARG(privileges,LUID_AND_ATTRIBUTES); */
+    char __pad_12[4];
 };
 
 
@@ -3834,6 +3952,7 @@ struct get_token_privileges_reply
     struct reply_header __header;
     unsigned int  len;
     /* VARARG(privileges,LUID_AND_ATTRIBUTES); */
+    char __pad_12[4];
 };
 
 
@@ -3849,6 +3968,7 @@ struct check_token_privileges_reply
     struct reply_header __header;
     int           has_privileges;
     /* VARARG(privileges,LUID_AND_ATTRIBUTES); */
+    char __pad_12[4];
 };
 
 struct duplicate_token_request
@@ -3864,6 +3984,7 @@ struct duplicate_token_reply
 {
     struct reply_header __header;
     obj_handle_t  new_handle;
+    char __pad_12[4];
 };
 
 struct access_check_request
@@ -3884,6 +4005,7 @@ struct access_check_reply
     unsigned int    access_status;
     unsigned int    privileges_len;
     /* VARARG(privileges,LUID_AND_ATTRIBUTES); */
+    char __pad_20[4];
 };
 
 struct get_token_user_request
@@ -3896,6 +4018,7 @@ struct get_token_user_reply
     struct reply_header __header;
     data_size_t     user_len;
     /* VARARG(user,SID); */
+    char __pad_12[4];
 };
 
 struct get_token_groups_request
@@ -3908,6 +4031,7 @@ struct get_token_groups_reply
     struct reply_header __header;
     data_size_t     user_len;
     /* VARARG(user,token_groups); */
+    char __pad_12[4];
 };
 
 struct set_security_object_request
@@ -3916,6 +4040,7 @@ struct set_security_object_request
     obj_handle_t    handle;
     unsigned int    security_info;
     /* VARARG(sd,security_descriptor); */
+    char __pad_20[4];
 };
 struct set_security_object_reply
 {
@@ -3933,6 +4058,7 @@ struct get_security_object_reply
     struct reply_header __header;
     unsigned int    sd_len;
     /* VARARG(sd,security_descriptor); */
+    char __pad_12[4];
 };
 
 
@@ -3950,6 +4076,7 @@ struct create_mailslot_reply
 {
     struct reply_header __header;
     obj_handle_t   handle;
+    char __pad_12[4];
 };
 
 
@@ -3966,6 +4093,7 @@ struct set_mailslot_info_reply
     struct reply_header __header;
     timeout_t      read_timeout;
     unsigned int   max_msgsize;
+    char __pad_20[4];
 };
 #define MAILSLOT_SET_READ_TIMEOUT  1
 
@@ -3983,6 +4111,7 @@ struct create_directory_reply
 {
     struct reply_header __header;
     obj_handle_t   handle;
+    char __pad_12[4];
 };
 
 
@@ -3999,6 +4128,7 @@ struct open_directory_reply
 {
     struct reply_header __header;
     obj_handle_t   handle;
+    char __pad_12[4];
 };
 
 
@@ -4015,6 +4145,7 @@ struct get_directory_entry_reply
     data_size_t    name_len;
     /* VARARG(name,unicode_str,name_len); */
     /* VARARG(type,unicode_str); */
+    char __pad_12[4];
 };
 
 
@@ -4033,6 +4164,7 @@ struct create_symlink_reply
 {
     struct reply_header __header;
     obj_handle_t   handle;
+    char __pad_12[4];
 };
 
 
@@ -4049,6 +4181,7 @@ struct open_symlink_reply
 {
     struct reply_header __header;
     obj_handle_t   handle;
+    char __pad_12[4];
 };
 
 
@@ -4101,6 +4234,7 @@ struct get_token_impersonation_level_reply
 {
     struct reply_header __header;
     int            impersonation_level;
+    char __pad_12[4];
 };
 
 
@@ -4126,6 +4260,7 @@ struct create_device_manager_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -4144,6 +4279,7 @@ struct create_device_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -4189,6 +4325,7 @@ struct make_process_system_reply
 {
     struct reply_header __header;
     obj_handle_t event;
+    char __pad_12[4];
 };
 
 
@@ -4224,6 +4361,7 @@ struct create_completion_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -4240,6 +4378,7 @@ struct open_completion_reply
 {
     struct reply_header __header;
     obj_handle_t handle;
+    char __pad_12[4];
 };
 
 
@@ -4285,6 +4424,7 @@ struct query_completion_reply
 {
     struct reply_header __header;
     unsigned int  depth;
+    char __pad_12[4];
 };
 
 
@@ -4295,6 +4435,7 @@ struct set_completion_info_request
     obj_handle_t  handle;
     apc_param_t   ckey;
     obj_handle_t  chandle;
+    char __pad_28[4];
 };
 struct set_completion_info_reply
 {
@@ -4329,6 +4470,7 @@ struct get_window_layered_info_reply
     unsigned int   color_key;
     unsigned int   alpha;
     unsigned int   flags;
+    char __pad_20[4];
 };
 
 
@@ -4340,6 +4482,7 @@ struct set_window_layered_info_request
     unsigned int   color_key;
     unsigned int   alpha;
     unsigned int   flags;
+    char __pad_28[4];
 };
 struct set_window_layered_info_reply
 {

server/protocol.def

@@ -680,7 +680,6 @@ typedef union
 
 /* Notify the server that a dll is being unloaded */
 @REQ(unload_dll)
-    int          __pad;
     mod_handle_t base;         /* base address */
 @END
 

server/request.h

@@ -590,6 +590,1300 @@ static const req_handler req_handlers[REQ_NB_REQUESTS] =
     (req_handler)req_get_window_layered_info,
     (req_handler)req_set_window_layered_info,
 };
+
+C_ASSERT( sizeof(apc_call_t) == 40 );
+C_ASSERT( sizeof(apc_param_t) == 8 );
+C_ASSERT( sizeof(apc_result_t) == 40 );
+C_ASSERT( sizeof(async_data_t) == 40 );
+C_ASSERT( sizeof(atom_t) == 4 );
+C_ASSERT( sizeof(char) == 1 );
+C_ASSERT( sizeof(char_info_t) == 4 );
+C_ASSERT( sizeof(client_ptr_t) == 8 );
+C_ASSERT( sizeof(data_size_t) == 4 );
+C_ASSERT( sizeof(file_pos_t) == 8 );
+C_ASSERT( sizeof(int) == 4 );
+C_ASSERT( sizeof(ioctl_code_t) == 4 );
+C_ASSERT( sizeof(lparam_t) == 8 );
+C_ASSERT( sizeof(luid_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(process_id_t) == 4 );
+C_ASSERT( sizeof(rectangle_t) == 16 );
+C_ASSERT( sizeof(short int) == 2 );
+C_ASSERT( sizeof(thread_id_t) == 4 );
+C_ASSERT( sizeof(timeout_t) == 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( FIELD_OFFSET(struct new_process_request, inherit_all) == 12 );
+C_ASSERT( FIELD_OFFSET(struct new_process_request, create_flags) == 16 );
+C_ASSERT( FIELD_OFFSET(struct new_process_request, socket_fd) == 20 );
+C_ASSERT( FIELD_OFFSET(struct new_process_request, exe_file) == 24 );
+C_ASSERT( FIELD_OFFSET(struct new_process_request, hstdin) == 28 );
+C_ASSERT( FIELD_OFFSET(struct new_process_request, hstdout) == 32 );
+C_ASSERT( FIELD_OFFSET(struct new_process_request, hstderr) == 36 );
+C_ASSERT( FIELD_OFFSET(struct new_process_request, process_access) == 40 );
+C_ASSERT( FIELD_OFFSET(struct new_process_request, process_attr) == 44 );
+C_ASSERT( FIELD_OFFSET(struct new_process_request, thread_access) == 48 );
+C_ASSERT( FIELD_OFFSET(struct new_process_request, thread_attr) == 52 );
+C_ASSERT( FIELD_OFFSET(struct new_process_reply, info) == 8 );
+C_ASSERT( FIELD_OFFSET(struct new_process_reply, pid) == 12 );
+C_ASSERT( FIELD_OFFSET(struct new_process_reply, phandle) == 16 );
+C_ASSERT( FIELD_OFFSET(struct new_process_reply, tid) == 20 );
+C_ASSERT( FIELD_OFFSET(struct new_process_reply, thandle) == 24 );
+C_ASSERT( sizeof(struct new_process_reply) == 32 );
+C_ASSERT( FIELD_OFFSET(struct get_new_process_info_request, info) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_new_process_info_reply, success) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_new_process_info_reply, exit_code) == 12 );
+C_ASSERT( sizeof(struct get_new_process_info_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct new_thread_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct new_thread_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct new_thread_request, suspend) == 20 );
+C_ASSERT( FIELD_OFFSET(struct new_thread_request, request_fd) == 24 );
+C_ASSERT( FIELD_OFFSET(struct new_thread_reply, tid) == 8 );
+C_ASSERT( FIELD_OFFSET(struct new_thread_reply, handle) == 12 );
+C_ASSERT( sizeof(struct new_thread_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_startup_info_reply, exe_file) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_startup_info_reply, hstdin) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_startup_info_reply, hstdout) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_startup_info_reply, hstderr) == 20 );
+C_ASSERT( sizeof(struct get_startup_info_reply) == 24 );
+C_ASSERT( FIELD_OFFSET(struct init_process_done_request, gui) == 12 );
+C_ASSERT( FIELD_OFFSET(struct init_process_done_request, module) == 16 );
+C_ASSERT( FIELD_OFFSET(struct init_process_done_request, ldt_copy) == 24 );
+C_ASSERT( FIELD_OFFSET(struct init_process_done_request, entry) == 32 );
+C_ASSERT( sizeof(struct init_process_done_request) == 40 );
+C_ASSERT( FIELD_OFFSET(struct init_thread_request, unix_pid) == 12 );
+C_ASSERT( FIELD_OFFSET(struct init_thread_request, unix_tid) == 16 );
+C_ASSERT( FIELD_OFFSET(struct init_thread_request, debug_level) == 20 );
+C_ASSERT( FIELD_OFFSET(struct init_thread_request, teb) == 24 );
+C_ASSERT( FIELD_OFFSET(struct init_thread_request, entry) == 32 );
+C_ASSERT( FIELD_OFFSET(struct init_thread_request, reply_fd) == 40 );
+C_ASSERT( FIELD_OFFSET(struct init_thread_request, wait_fd) == 44 );
+C_ASSERT( FIELD_OFFSET(struct init_thread_request, peb) == 48 );
+C_ASSERT( FIELD_OFFSET(struct init_thread_reply, pid) == 8 );
+C_ASSERT( FIELD_OFFSET(struct init_thread_reply, tid) == 12 );
+C_ASSERT( FIELD_OFFSET(struct init_thread_reply, server_start) == 16 );
+C_ASSERT( FIELD_OFFSET(struct init_thread_reply, info_size) == 24 );
+C_ASSERT( FIELD_OFFSET(struct init_thread_reply, version) == 28 );
+C_ASSERT( sizeof(struct init_thread_reply) == 32 );
+C_ASSERT( FIELD_OFFSET(struct terminate_process_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct terminate_process_request, exit_code) == 16 );
+C_ASSERT( FIELD_OFFSET(struct terminate_process_reply, self) == 8 );
+C_ASSERT( sizeof(struct terminate_process_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct terminate_thread_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct terminate_thread_request, exit_code) == 16 );
+C_ASSERT( FIELD_OFFSET(struct terminate_thread_reply, self) == 8 );
+C_ASSERT( FIELD_OFFSET(struct terminate_thread_reply, last) == 12 );
+C_ASSERT( sizeof(struct terminate_thread_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_process_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, pid) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, ppid) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, priority) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, affinity) == 20 );
+C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, peb) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, start_time) == 32 );
+C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, end_time) == 40 );
+C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, exit_code) == 48 );
+C_ASSERT( sizeof(struct get_process_info_reply) == 56 );
+C_ASSERT( FIELD_OFFSET(struct set_process_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_process_info_request, mask) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_process_info_request, priority) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_process_info_request, affinity) == 24 );
+C_ASSERT( sizeof(struct set_process_info_request) == 32 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_info_request, tid_in) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, pid) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, tid) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, teb) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, priority) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, affinity) == 28 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, creation_time) == 32 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, exit_time) == 40 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, exit_code) == 48 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, last) == 52 );
+C_ASSERT( sizeof(struct get_thread_info_reply) == 56 );
+C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, mask) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, priority) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, affinity) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, token) == 28 );
+C_ASSERT( sizeof(struct set_thread_info_request) == 32 );
+C_ASSERT( FIELD_OFFSET(struct get_dll_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_dll_info_request, base_address) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_dll_info_reply, entry_point) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_dll_info_reply, size) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_dll_info_reply, filename_len) == 20 );
+C_ASSERT( sizeof(struct get_dll_info_reply) == 24 );
+C_ASSERT( FIELD_OFFSET(struct suspend_thread_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct suspend_thread_reply, count) == 8 );
+C_ASSERT( sizeof(struct suspend_thread_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct resume_thread_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct resume_thread_reply, count) == 8 );
+C_ASSERT( sizeof(struct resume_thread_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct load_dll_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct load_dll_request, base) == 16 );
+C_ASSERT( FIELD_OFFSET(struct load_dll_request, name) == 24 );
+C_ASSERT( FIELD_OFFSET(struct load_dll_request, size) == 32 );
+C_ASSERT( FIELD_OFFSET(struct load_dll_request, dbg_offset) == 36 );
+C_ASSERT( FIELD_OFFSET(struct load_dll_request, dbg_size) == 40 );
+C_ASSERT( sizeof(struct load_dll_request) == 48 );
+C_ASSERT( FIELD_OFFSET(struct unload_dll_request, base) == 16 );
+C_ASSERT( sizeof(struct unload_dll_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct queue_apc_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct queue_apc_request, call) == 16 );
+C_ASSERT( FIELD_OFFSET(struct queue_apc_reply, handle) == 8 );
+C_ASSERT( FIELD_OFFSET(struct queue_apc_reply, self) == 12 );
+C_ASSERT( sizeof(struct queue_apc_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_apc_result_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_apc_result_reply, result) == 8 );
+C_ASSERT( sizeof(struct get_apc_result_reply) == 48 );
+C_ASSERT( FIELD_OFFSET(struct close_handle_request, handle) == 12 );
+C_ASSERT( sizeof(struct close_handle_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_handle_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_handle_info_request, flags) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_handle_info_request, mask) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_handle_info_reply, old_flags) == 8 );
+C_ASSERT( sizeof(struct set_handle_info_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct dup_handle_request, src_process) == 12 );
+C_ASSERT( FIELD_OFFSET(struct dup_handle_request, src_handle) == 16 );
+C_ASSERT( FIELD_OFFSET(struct dup_handle_request, dst_process) == 20 );
+C_ASSERT( FIELD_OFFSET(struct dup_handle_request, access) == 24 );
+C_ASSERT( FIELD_OFFSET(struct dup_handle_request, attributes) == 28 );
+C_ASSERT( FIELD_OFFSET(struct dup_handle_request, options) == 32 );
+C_ASSERT( FIELD_OFFSET(struct dup_handle_reply, handle) == 8 );
+C_ASSERT( FIELD_OFFSET(struct dup_handle_reply, self) == 12 );
+C_ASSERT( FIELD_OFFSET(struct dup_handle_reply, closed) == 16 );
+C_ASSERT( sizeof(struct dup_handle_reply) == 24 );
+C_ASSERT( FIELD_OFFSET(struct open_process_request, pid) == 12 );
+C_ASSERT( FIELD_OFFSET(struct open_process_request, access) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_process_request, attributes) == 20 );
+C_ASSERT( FIELD_OFFSET(struct open_process_reply, handle) == 8 );
+C_ASSERT( sizeof(struct open_process_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_thread_request, tid) == 12 );
+C_ASSERT( FIELD_OFFSET(struct open_thread_request, access) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_thread_request, attributes) == 20 );
+C_ASSERT( FIELD_OFFSET(struct open_thread_reply, handle) == 8 );
+C_ASSERT( sizeof(struct open_thread_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct select_request, flags) == 12 );
+C_ASSERT( FIELD_OFFSET(struct select_request, cookie) == 16 );
+C_ASSERT( FIELD_OFFSET(struct select_request, signal) == 24 );
+C_ASSERT( FIELD_OFFSET(struct select_request, prev_apc) == 28 );
+C_ASSERT( FIELD_OFFSET(struct select_request, timeout) == 32 );
+C_ASSERT( FIELD_OFFSET(struct select_reply, timeout) == 8 );
+C_ASSERT( FIELD_OFFSET(struct select_reply, call) == 16 );
+C_ASSERT( FIELD_OFFSET(struct select_reply, apc_handle) == 56 );
+C_ASSERT( sizeof(struct select_reply) == 64 );
+C_ASSERT( FIELD_OFFSET(struct create_event_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_event_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_event_request, manual_reset) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_event_request, initial_state) == 24 );
+C_ASSERT( FIELD_OFFSET(struct create_event_reply, handle) == 8 );
+C_ASSERT( sizeof(struct create_event_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct event_op_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct event_op_request, op) == 16 );
+C_ASSERT( sizeof(struct event_op_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct open_event_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct open_event_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_event_request, rootdir) == 20 );
+C_ASSERT( FIELD_OFFSET(struct open_event_reply, handle) == 8 );
+C_ASSERT( sizeof(struct open_event_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_mutex_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_mutex_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_mutex_request, owned) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_mutex_reply, handle) == 8 );
+C_ASSERT( sizeof(struct create_mutex_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct release_mutex_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct release_mutex_reply, prev_count) == 8 );
+C_ASSERT( sizeof(struct release_mutex_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_mutex_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct open_mutex_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_mutex_request, rootdir) == 20 );
+C_ASSERT( FIELD_OFFSET(struct open_mutex_reply, handle) == 8 );
+C_ASSERT( sizeof(struct open_mutex_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, initial) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, max) == 24 );
+C_ASSERT( FIELD_OFFSET(struct create_semaphore_reply, handle) == 8 );
+C_ASSERT( sizeof(struct create_semaphore_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct release_semaphore_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct release_semaphore_request, count) == 16 );
+C_ASSERT( FIELD_OFFSET(struct release_semaphore_reply, prev_count) == 8 );
+C_ASSERT( sizeof(struct release_semaphore_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_semaphore_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct open_semaphore_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_semaphore_request, rootdir) == 20 );
+C_ASSERT( FIELD_OFFSET(struct open_semaphore_reply, handle) == 8 );
+C_ASSERT( sizeof(struct open_semaphore_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_file_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_file_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_file_request, sharing) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_file_request, create) == 24 );
+C_ASSERT( FIELD_OFFSET(struct create_file_request, options) == 28 );
+C_ASSERT( FIELD_OFFSET(struct create_file_request, attrs) == 32 );
+C_ASSERT( FIELD_OFFSET(struct create_file_reply, handle) == 8 );
+C_ASSERT( sizeof(struct create_file_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_file_object_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct open_file_object_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_file_object_request, rootdir) == 20 );
+C_ASSERT( FIELD_OFFSET(struct open_file_object_request, sharing) == 24 );
+C_ASSERT( FIELD_OFFSET(struct open_file_object_request, options) == 28 );
+C_ASSERT( FIELD_OFFSET(struct open_file_object_reply, handle) == 8 );
+C_ASSERT( sizeof(struct open_file_object_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request, fd) == 20 );
+C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_reply, handle) == 8 );
+C_ASSERT( sizeof(struct alloc_file_handle_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_handle_fd_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, type) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, removable) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, access) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, options) == 20 );
+C_ASSERT( sizeof(struct get_handle_fd_reply) == 24 );
+C_ASSERT( FIELD_OFFSET(struct flush_file_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct flush_file_reply, event) == 8 );
+C_ASSERT( sizeof(struct flush_file_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct lock_file_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct lock_file_request, offset) == 16 );
+C_ASSERT( FIELD_OFFSET(struct lock_file_request, count) == 24 );
+C_ASSERT( FIELD_OFFSET(struct lock_file_request, shared) == 32 );
+C_ASSERT( FIELD_OFFSET(struct lock_file_request, wait) == 36 );
+C_ASSERT( FIELD_OFFSET(struct lock_file_reply, handle) == 8 );
+C_ASSERT( FIELD_OFFSET(struct lock_file_reply, overlapped) == 12 );
+C_ASSERT( sizeof(struct lock_file_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct unlock_file_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct unlock_file_request, offset) == 16 );
+C_ASSERT( FIELD_OFFSET(struct unlock_file_request, count) == 24 );
+C_ASSERT( sizeof(struct unlock_file_request) == 32 );
+C_ASSERT( FIELD_OFFSET(struct create_socket_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_socket_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_socket_request, family) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_socket_request, type) == 24 );
+C_ASSERT( FIELD_OFFSET(struct create_socket_request, protocol) == 28 );
+C_ASSERT( FIELD_OFFSET(struct create_socket_request, flags) == 32 );
+C_ASSERT( FIELD_OFFSET(struct create_socket_reply, handle) == 8 );
+C_ASSERT( sizeof(struct create_socket_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct accept_socket_request, lhandle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct accept_socket_request, access) == 16 );
+C_ASSERT( FIELD_OFFSET(struct accept_socket_request, attributes) == 20 );
+C_ASSERT( FIELD_OFFSET(struct accept_socket_reply, handle) == 8 );
+C_ASSERT( sizeof(struct accept_socket_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_socket_event_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_socket_event_request, mask) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_socket_event_request, event) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_socket_event_request, window) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_socket_event_request, msg) == 28 );
+C_ASSERT( sizeof(struct set_socket_event_request) == 32 );
+C_ASSERT( FIELD_OFFSET(struct get_socket_event_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_socket_event_request, service) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_socket_event_request, c_event) == 20 );
+C_ASSERT( FIELD_OFFSET(struct get_socket_event_reply, mask) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_socket_event_reply, pmask) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_socket_event_reply, state) == 16 );
+C_ASSERT( sizeof(struct get_socket_event_reply) == 24 );
+C_ASSERT( FIELD_OFFSET(struct enable_socket_event_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct enable_socket_event_request, mask) == 16 );
+C_ASSERT( FIELD_OFFSET(struct enable_socket_event_request, sstate) == 20 );
+C_ASSERT( FIELD_OFFSET(struct enable_socket_event_request, cstate) == 24 );
+C_ASSERT( sizeof(struct enable_socket_event_request) == 32 );
+C_ASSERT( FIELD_OFFSET(struct set_socket_deferred_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_socket_deferred_request, deferred) == 16 );
+C_ASSERT( sizeof(struct set_socket_deferred_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct alloc_console_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct alloc_console_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct alloc_console_request, pid) == 20 );
+C_ASSERT( FIELD_OFFSET(struct alloc_console_reply, handle_in) == 8 );
+C_ASSERT( FIELD_OFFSET(struct alloc_console_reply, event) == 12 );
+C_ASSERT( sizeof(struct alloc_console_reply) == 16 );
+C_ASSERT( sizeof(struct free_console_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_console_renderer_events_request, handle) == 12 );
+C_ASSERT( sizeof(struct get_console_renderer_events_reply) == 8 );
+C_ASSERT( FIELD_OFFSET(struct open_console_request, from) == 12 );
+C_ASSERT( FIELD_OFFSET(struct open_console_request, access) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_console_request, attributes) == 20 );
+C_ASSERT( FIELD_OFFSET(struct open_console_request, share) == 24 );
+C_ASSERT( FIELD_OFFSET(struct open_console_reply, handle) == 8 );
+C_ASSERT( sizeof(struct open_console_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_console_wait_event_reply, handle) == 8 );
+C_ASSERT( sizeof(struct get_console_wait_event_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_console_mode_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_console_mode_reply, mode) == 8 );
+C_ASSERT( sizeof(struct get_console_mode_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_console_mode_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_console_mode_request, mode) == 16 );
+C_ASSERT( sizeof(struct set_console_mode_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, mask) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, active_sb) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, history_mode) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, history_size) == 28 );
+C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, edition_mode) == 32 );
+C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, input_cp) == 36 );
+C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, output_cp) == 40 );
+C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, win) == 44 );
+C_ASSERT( sizeof(struct set_console_input_info_request) == 48 );
+C_ASSERT( FIELD_OFFSET(struct get_console_input_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, history_mode) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, history_size) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, history_index) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, edition_mode) == 20 );
+C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, input_cp) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, output_cp) == 28 );
+C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, win) == 32 );
+C_ASSERT( sizeof(struct get_console_input_info_reply) == 40 );
+C_ASSERT( FIELD_OFFSET(struct append_console_input_history_request, handle) == 12 );
+C_ASSERT( sizeof(struct append_console_input_history_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_console_input_history_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_console_input_history_request, index) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_console_input_history_reply, total) == 8 );
+C_ASSERT( sizeof(struct get_console_input_history_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_console_output_request, handle_in) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_console_output_request, access) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_console_output_request, attributes) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_console_output_request, share) == 24 );
+C_ASSERT( FIELD_OFFSET(struct create_console_output_reply, handle_out) == 8 );
+C_ASSERT( sizeof(struct create_console_output_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, mask) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, cursor_size) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, cursor_visible) == 22 );
+C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, cursor_x) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, cursor_y) == 26 );
+C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, width) == 28 );
+C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, height) == 30 );
+C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, attr) == 32 );
+C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, win_left) == 34 );
+C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, win_top) == 36 );
+C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, win_right) == 38 );
+C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, win_bottom) == 40 );
+C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, max_width) == 42 );
+C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, max_height) == 44 );
+C_ASSERT( sizeof(struct set_console_output_info_request) == 48 );
+C_ASSERT( FIELD_OFFSET(struct get_console_output_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, cursor_size) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, cursor_visible) == 10 );
+C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, cursor_x) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, cursor_y) == 14 );
+C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, width) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, height) == 18 );
+C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, attr) == 20 );
+C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, win_left) == 22 );
+C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, win_top) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, win_right) == 26 );
+C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, win_bottom) == 28 );
+C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, max_width) == 30 );
+C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, max_height) == 32 );
+C_ASSERT( sizeof(struct get_console_output_info_reply) == 40 );
+C_ASSERT( FIELD_OFFSET(struct write_console_input_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct write_console_input_reply, written) == 8 );
+C_ASSERT( sizeof(struct write_console_input_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct read_console_input_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct read_console_input_request, flush) == 16 );
+C_ASSERT( FIELD_OFFSET(struct read_console_input_reply, read) == 8 );
+C_ASSERT( sizeof(struct read_console_input_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct write_console_output_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct write_console_output_request, x) == 16 );
+C_ASSERT( FIELD_OFFSET(struct write_console_output_request, y) == 20 );
+C_ASSERT( FIELD_OFFSET(struct write_console_output_request, mode) == 24 );
+C_ASSERT( FIELD_OFFSET(struct write_console_output_request, wrap) == 28 );
+C_ASSERT( FIELD_OFFSET(struct write_console_output_reply, written) == 8 );
+C_ASSERT( FIELD_OFFSET(struct write_console_output_reply, width) == 12 );
+C_ASSERT( FIELD_OFFSET(struct write_console_output_reply, height) == 16 );
+C_ASSERT( sizeof(struct write_console_output_reply) == 24 );
+C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, x) == 16 );
+C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, y) == 20 );
+C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, mode) == 24 );
+C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, count) == 28 );
+C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, wrap) == 32 );
+C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, data) == 36 );
+C_ASSERT( FIELD_OFFSET(struct fill_console_output_reply, written) == 8 );
+C_ASSERT( sizeof(struct fill_console_output_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct read_console_output_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct read_console_output_request, x) == 16 );
+C_ASSERT( FIELD_OFFSET(struct read_console_output_request, y) == 20 );
+C_ASSERT( FIELD_OFFSET(struct read_console_output_request, mode) == 24 );
+C_ASSERT( FIELD_OFFSET(struct read_console_output_request, wrap) == 28 );
+C_ASSERT( FIELD_OFFSET(struct read_console_output_reply, width) == 8 );
+C_ASSERT( FIELD_OFFSET(struct read_console_output_reply, height) == 12 );
+C_ASSERT( sizeof(struct read_console_output_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct move_console_output_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct move_console_output_request, x_src) == 16 );
+C_ASSERT( FIELD_OFFSET(struct move_console_output_request, y_src) == 18 );
+C_ASSERT( FIELD_OFFSET(struct move_console_output_request, x_dst) == 20 );
+C_ASSERT( FIELD_OFFSET(struct move_console_output_request, y_dst) == 22 );
+C_ASSERT( FIELD_OFFSET(struct move_console_output_request, w) == 24 );
+C_ASSERT( FIELD_OFFSET(struct move_console_output_request, h) == 26 );
+C_ASSERT( sizeof(struct move_console_output_request) == 32 );
+C_ASSERT( FIELD_OFFSET(struct send_console_signal_request, signal) == 12 );
+C_ASSERT( FIELD_OFFSET(struct send_console_signal_request, group_id) == 16 );
+C_ASSERT( sizeof(struct send_console_signal_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, filter) == 12 );
+C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, subtree) == 16 );
+C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, want_data) == 20 );
+C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, async) == 24 );
+C_ASSERT( sizeof(struct read_directory_changes_request) == 64 );
+C_ASSERT( FIELD_OFFSET(struct read_change_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct read_change_reply, action) == 8 );
+C_ASSERT( sizeof(struct read_change_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_mapping_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_mapping_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_mapping_request, protect) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_mapping_request, size) == 24 );
+C_ASSERT( FIELD_OFFSET(struct create_mapping_request, file_handle) == 32 );
+C_ASSERT( FIELD_OFFSET(struct create_mapping_reply, handle) == 8 );
+C_ASSERT( sizeof(struct create_mapping_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_mapping_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct open_mapping_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_mapping_request, rootdir) == 20 );
+C_ASSERT( FIELD_OFFSET(struct open_mapping_reply, handle) == 8 );
+C_ASSERT( sizeof(struct open_mapping_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_mapping_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_mapping_info_request, access) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, size) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, protect) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, header_size) == 20 );
+C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, base) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, mapping) == 32 );
+C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, shared_file) == 36 );
+C_ASSERT( sizeof(struct get_mapping_info_reply) == 40 );
+C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_request, offset) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_reply, size) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_reply, committed) == 16 );
+C_ASSERT( sizeof(struct get_mapping_committed_range_reply) == 24 );
+C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request, offset) == 16 );
+C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request, size) == 24 );
+C_ASSERT( sizeof(struct add_mapping_committed_range_request) == 32 );
+C_ASSERT( FIELD_OFFSET(struct create_snapshot_request, attributes) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_snapshot_request, flags) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_snapshot_reply, handle) == 8 );
+C_ASSERT( sizeof(struct create_snapshot_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct next_process_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct next_process_request, reset) == 16 );
+C_ASSERT( FIELD_OFFSET(struct next_process_reply, count) == 8 );
+C_ASSERT( FIELD_OFFSET(struct next_process_reply, pid) == 12 );
+C_ASSERT( FIELD_OFFSET(struct next_process_reply, ppid) == 16 );
+C_ASSERT( FIELD_OFFSET(struct next_process_reply, threads) == 20 );
+C_ASSERT( FIELD_OFFSET(struct next_process_reply, priority) == 24 );
+C_ASSERT( FIELD_OFFSET(struct next_process_reply, handles) == 28 );
+C_ASSERT( sizeof(struct next_process_reply) == 32 );
+C_ASSERT( FIELD_OFFSET(struct next_thread_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct next_thread_request, reset) == 16 );
+C_ASSERT( FIELD_OFFSET(struct next_thread_reply, count) == 8 );
+C_ASSERT( FIELD_OFFSET(struct next_thread_reply, pid) == 12 );
+C_ASSERT( FIELD_OFFSET(struct next_thread_reply, tid) == 16 );
+C_ASSERT( FIELD_OFFSET(struct next_thread_reply, base_pri) == 20 );
+C_ASSERT( FIELD_OFFSET(struct next_thread_reply, delta_pri) == 24 );
+C_ASSERT( sizeof(struct next_thread_reply) == 32 );
+C_ASSERT( FIELD_OFFSET(struct wait_debug_event_request, get_handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply, pid) == 8 );
+C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply, tid) == 12 );
+C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply, wait) == 16 );
+C_ASSERT( sizeof(struct wait_debug_event_reply) == 24 );
+C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, first) == 12 );
+C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, code) == 16 );
+C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, flags) == 20 );
+C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, record) == 24 );
+C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, address) == 32 );
+C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, len) == 40 );
+C_ASSERT( FIELD_OFFSET(struct queue_exception_event_reply, handle) == 8 );
+C_ASSERT( sizeof(struct queue_exception_event_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_exception_status_request, handle) == 12 );
+C_ASSERT( sizeof(struct get_exception_status_reply) == 8 );
+C_ASSERT( FIELD_OFFSET(struct output_debug_string_request, length) == 12 );
+C_ASSERT( FIELD_OFFSET(struct output_debug_string_request, string) == 16 );
+C_ASSERT( FIELD_OFFSET(struct output_debug_string_request, unicode) == 24 );
+C_ASSERT( sizeof(struct output_debug_string_request) == 32 );
+C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request, pid) == 12 );
+C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request, tid) == 16 );
+C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request, status) == 20 );
+C_ASSERT( sizeof(struct continue_debug_event_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct debug_process_request, pid) == 12 );
+C_ASSERT( FIELD_OFFSET(struct debug_process_request, attach) == 16 );
+C_ASSERT( sizeof(struct debug_process_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct debug_break_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct debug_break_reply, self) == 8 );
+C_ASSERT( sizeof(struct debug_break_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_debugger_kill_on_exit_request, kill_on_exit) == 12 );
+C_ASSERT( sizeof(struct set_debugger_kill_on_exit_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct read_process_memory_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct read_process_memory_request, addr) == 16 );
+C_ASSERT( sizeof(struct read_process_memory_reply) == 8 );
+C_ASSERT( FIELD_OFFSET(struct write_process_memory_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct write_process_memory_request, addr) == 16 );
+C_ASSERT( sizeof(struct write_process_memory_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct create_key_request, parent) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_key_request, access) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_key_request, attributes) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_key_request, options) == 24 );
+C_ASSERT( FIELD_OFFSET(struct create_key_request, namelen) == 28 );
+C_ASSERT( FIELD_OFFSET(struct create_key_reply, hkey) == 8 );
+C_ASSERT( FIELD_OFFSET(struct create_key_reply, created) == 12 );
+C_ASSERT( sizeof(struct create_key_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_key_request, parent) == 12 );
+C_ASSERT( FIELD_OFFSET(struct open_key_request, access) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_key_request, attributes) == 20 );
+C_ASSERT( FIELD_OFFSET(struct open_key_reply, hkey) == 8 );
+C_ASSERT( sizeof(struct open_key_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct delete_key_request, hkey) == 12 );
+C_ASSERT( sizeof(struct delete_key_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct flush_key_request, hkey) == 12 );
+C_ASSERT( sizeof(struct flush_key_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct enum_key_request, hkey) == 12 );
+C_ASSERT( FIELD_OFFSET(struct enum_key_request, index) == 16 );
+C_ASSERT( FIELD_OFFSET(struct enum_key_request, info_class) == 20 );
+C_ASSERT( FIELD_OFFSET(struct enum_key_reply, subkeys) == 8 );
+C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_subkey) == 12 );
+C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_class) == 16 );
+C_ASSERT( FIELD_OFFSET(struct enum_key_reply, values) == 20 );
+C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_value) == 24 );
+C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_data) == 28 );
+C_ASSERT( FIELD_OFFSET(struct enum_key_reply, modif) == 32 );
+C_ASSERT( FIELD_OFFSET(struct enum_key_reply, total) == 40 );
+C_ASSERT( FIELD_OFFSET(struct enum_key_reply, namelen) == 44 );
+C_ASSERT( sizeof(struct enum_key_reply) == 48 );
+C_ASSERT( FIELD_OFFSET(struct set_key_value_request, hkey) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_key_value_request, type) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_key_value_request, namelen) == 20 );
+C_ASSERT( sizeof(struct set_key_value_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_key_value_request, hkey) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_key_value_reply, type) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_key_value_reply, total) == 12 );
+C_ASSERT( sizeof(struct get_key_value_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct enum_key_value_request, hkey) == 12 );
+C_ASSERT( FIELD_OFFSET(struct enum_key_value_request, index) == 16 );
+C_ASSERT( FIELD_OFFSET(struct enum_key_value_request, info_class) == 20 );
+C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply, type) == 8 );
+C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply, total) == 12 );
+C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply, namelen) == 16 );
+C_ASSERT( sizeof(struct enum_key_value_reply) == 24 );
+C_ASSERT( FIELD_OFFSET(struct delete_key_value_request, hkey) == 12 );
+C_ASSERT( sizeof(struct delete_key_value_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct load_registry_request, hkey) == 12 );
+C_ASSERT( FIELD_OFFSET(struct load_registry_request, file) == 16 );
+C_ASSERT( sizeof(struct load_registry_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct unload_registry_request, hkey) == 12 );
+C_ASSERT( sizeof(struct unload_registry_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct save_registry_request, hkey) == 12 );
+C_ASSERT( FIELD_OFFSET(struct save_registry_request, file) == 16 );
+C_ASSERT( sizeof(struct save_registry_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, hkey) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, event) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, subtree) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, filter) == 24 );
+C_ASSERT( sizeof(struct set_registry_notification_request) == 32 );
+C_ASSERT( FIELD_OFFSET(struct create_timer_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_timer_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_timer_request, rootdir) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_timer_request, manual) == 24 );
+C_ASSERT( FIELD_OFFSET(struct create_timer_reply, handle) == 8 );
+C_ASSERT( sizeof(struct create_timer_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_timer_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct open_timer_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_timer_request, rootdir) == 20 );
+C_ASSERT( FIELD_OFFSET(struct open_timer_reply, handle) == 8 );
+C_ASSERT( sizeof(struct open_timer_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_timer_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_timer_request, expire) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_timer_request, callback) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_timer_request, arg) == 32 );
+C_ASSERT( FIELD_OFFSET(struct set_timer_request, period) == 40 );
+C_ASSERT( FIELD_OFFSET(struct set_timer_reply, signaled) == 8 );
+C_ASSERT( sizeof(struct set_timer_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct cancel_timer_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct cancel_timer_reply, signaled) == 8 );
+C_ASSERT( sizeof(struct cancel_timer_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_timer_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_timer_info_reply, when) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_timer_info_reply, signaled) == 16 );
+C_ASSERT( sizeof(struct get_timer_info_reply) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, flags) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, suspend) == 20 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_context_reply, self) == 8 );
+C_ASSERT( sizeof(struct get_thread_context_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_thread_context_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_thread_context_request, flags) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_thread_context_request, suspend) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_thread_context_reply, self) == 8 );
+C_ASSERT( sizeof(struct set_thread_context_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_selector_entry_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_selector_entry_request, entry) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply, base) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply, limit) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply, flags) == 16 );
+C_ASSERT( sizeof(struct get_selector_entry_reply) == 24 );
+C_ASSERT( FIELD_OFFSET(struct add_atom_request, table) == 12 );
+C_ASSERT( FIELD_OFFSET(struct add_atom_reply, atom) == 8 );
+C_ASSERT( sizeof(struct add_atom_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct delete_atom_request, table) == 12 );
+C_ASSERT( FIELD_OFFSET(struct delete_atom_request, atom) == 16 );
+C_ASSERT( sizeof(struct delete_atom_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct find_atom_request, table) == 12 );
+C_ASSERT( FIELD_OFFSET(struct find_atom_reply, atom) == 8 );
+C_ASSERT( sizeof(struct find_atom_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_atom_information_request, table) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_atom_information_request, atom) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply, count) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply, pinned) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply, total) == 16 );
+C_ASSERT( sizeof(struct get_atom_information_reply) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_atom_information_request, table) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_atom_information_request, atom) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_atom_information_request, pinned) == 20 );
+C_ASSERT( sizeof(struct set_atom_information_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct empty_atom_table_request, table) == 12 );
+C_ASSERT( FIELD_OFFSET(struct empty_atom_table_request, if_pinned) == 16 );
+C_ASSERT( sizeof(struct empty_atom_table_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct init_atom_table_request, entries) == 12 );
+C_ASSERT( FIELD_OFFSET(struct init_atom_table_reply, table) == 8 );
+C_ASSERT( sizeof(struct init_atom_table_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_msg_queue_reply, handle) == 8 );
+C_ASSERT( sizeof(struct get_msg_queue_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_queue_fd_request, handle) == 12 );
+C_ASSERT( sizeof(struct set_queue_fd_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request, wake_mask) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request, changed_mask) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request, skip_wait) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_queue_mask_reply, wake_bits) == 8 );
+C_ASSERT( FIELD_OFFSET(struct set_queue_mask_reply, changed_bits) == 12 );
+C_ASSERT( sizeof(struct set_queue_mask_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_queue_status_request, clear) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_queue_status_reply, wake_bits) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_queue_status_reply, changed_bits) == 12 );
+C_ASSERT( sizeof(struct get_queue_status_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_process_idle_event_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_process_idle_event_reply, event) == 8 );
+C_ASSERT( sizeof(struct get_process_idle_event_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct send_message_request, id) == 12 );
+C_ASSERT( FIELD_OFFSET(struct send_message_request, type) == 16 );
+C_ASSERT( FIELD_OFFSET(struct send_message_request, flags) == 20 );
+C_ASSERT( FIELD_OFFSET(struct send_message_request, win) == 24 );
+C_ASSERT( FIELD_OFFSET(struct send_message_request, msg) == 28 );
+C_ASSERT( FIELD_OFFSET(struct send_message_request, wparam) == 32 );
+C_ASSERT( FIELD_OFFSET(struct send_message_request, lparam) == 40 );
+C_ASSERT( FIELD_OFFSET(struct send_message_request, timeout) == 48 );
+C_ASSERT( sizeof(struct send_message_request) == 56 );
+C_ASSERT( FIELD_OFFSET(struct post_quit_message_request, exit_code) == 12 );
+C_ASSERT( sizeof(struct post_quit_message_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, id) == 12 );
+C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, win) == 16 );
+C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, msg) == 20 );
+C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, wparam) == 24 );
+C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, lparam) == 32 );
+C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, info) == 40 );
+C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, x) == 48 );
+C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, y) == 52 );
+C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, time) == 56 );
+C_ASSERT( sizeof(struct send_hardware_message_request) == 64 );
+C_ASSERT( FIELD_OFFSET(struct get_message_request, flags) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_message_request, get_win) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_message_request, get_first) == 20 );
+C_ASSERT( FIELD_OFFSET(struct get_message_request, get_last) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_message_request, hw_id) == 28 );
+C_ASSERT( FIELD_OFFSET(struct get_message_request, wake_mask) == 32 );
+C_ASSERT( FIELD_OFFSET(struct get_message_request, changed_mask) == 36 );
+C_ASSERT( FIELD_OFFSET(struct get_message_reply, win) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_message_reply, msg) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_message_reply, wparam) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_message_reply, lparam) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_message_reply, type) == 32 );
+C_ASSERT( FIELD_OFFSET(struct get_message_reply, time) == 36 );
+C_ASSERT( FIELD_OFFSET(struct get_message_reply, active_hooks) == 40 );
+C_ASSERT( FIELD_OFFSET(struct get_message_reply, total) == 44 );
+C_ASSERT( sizeof(struct get_message_reply) == 48 );
+C_ASSERT( FIELD_OFFSET(struct reply_message_request, remove) == 12 );
+C_ASSERT( FIELD_OFFSET(struct reply_message_request, result) == 16 );
+C_ASSERT( sizeof(struct reply_message_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct accept_hardware_message_request, hw_id) == 12 );
+C_ASSERT( FIELD_OFFSET(struct accept_hardware_message_request, remove) == 16 );
+C_ASSERT( FIELD_OFFSET(struct accept_hardware_message_request, new_win) == 20 );
+C_ASSERT( sizeof(struct accept_hardware_message_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_message_reply_request, cancel) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_message_reply_reply, result) == 8 );
+C_ASSERT( sizeof(struct get_message_reply_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, win) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, msg) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, rate) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, id) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, lparam) == 32 );
+C_ASSERT( FIELD_OFFSET(struct set_win_timer_reply, id) == 8 );
+C_ASSERT( sizeof(struct set_win_timer_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request, win) == 12 );
+C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request, id) == 16 );
+C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request, msg) == 24 );
+C_ASSERT( sizeof(struct kill_win_timer_request) == 32 );
+C_ASSERT( FIELD_OFFSET(struct is_window_hung_request, win) == 12 );
+C_ASSERT( FIELD_OFFSET(struct is_window_hung_reply, is_hung) == 8 );
+C_ASSERT( sizeof(struct is_window_hung_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_serial_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, readinterval) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, readconst) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, readmult) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, writeconst) == 20 );
+C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, writemult) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, eventmask) == 28 );
+C_ASSERT( sizeof(struct get_serial_info_reply) == 32 );
+C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, flags) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, readinterval) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, readconst) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, readmult) == 28 );
+C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, writeconst) == 32 );
+C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, writemult) == 36 );
+C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, eventmask) == 40 );
+C_ASSERT( sizeof(struct set_serial_info_request) == 48 );
+C_ASSERT( FIELD_OFFSET(struct register_async_request, type) == 12 );
+C_ASSERT( FIELD_OFFSET(struct register_async_request, async) == 16 );
+C_ASSERT( FIELD_OFFSET(struct register_async_request, count) == 56 );
+C_ASSERT( sizeof(struct register_async_request) == 64 );
+C_ASSERT( FIELD_OFFSET(struct cancel_async_request, handle) == 12 );
+C_ASSERT( sizeof(struct cancel_async_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct ioctl_request, code) == 12 );
+C_ASSERT( FIELD_OFFSET(struct ioctl_request, async) == 16 );
+C_ASSERT( FIELD_OFFSET(struct ioctl_request, blocking) == 56 );
+C_ASSERT( FIELD_OFFSET(struct ioctl_reply, wait) == 8 );
+C_ASSERT( FIELD_OFFSET(struct ioctl_reply, options) == 12 );
+C_ASSERT( sizeof(struct ioctl_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_ioctl_result_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_ioctl_result_request, user_arg) == 16 );
+C_ASSERT( sizeof(struct get_ioctl_result_reply) == 8 );
+C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, rootdir) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, options) == 24 );
+C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, maxinstances) == 28 );
+C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, outsize) == 32 );
+C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, insize) == 36 );
+C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, timeout) == 40 );
+C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, flags) == 48 );
+C_ASSERT( FIELD_OFFSET(struct create_named_pipe_reply, handle) == 8 );
+C_ASSERT( sizeof(struct create_named_pipe_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply, flags) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply, maxinstances) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply, instances) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply, outsize) == 20 );
+C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply, insize) == 24 );
+C_ASSERT( sizeof(struct get_named_pipe_info_reply) == 32 );
+C_ASSERT( FIELD_OFFSET(struct create_window_request, parent) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_window_request, owner) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_window_request, atom) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_window_request, instance) == 24 );
+C_ASSERT( FIELD_OFFSET(struct create_window_reply, handle) == 8 );
+C_ASSERT( FIELD_OFFSET(struct create_window_reply, parent) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_window_reply, owner) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_window_reply, extra) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_window_reply, class_ptr) == 24 );
+C_ASSERT( sizeof(struct create_window_reply) == 32 );
+C_ASSERT( FIELD_OFFSET(struct destroy_window_request, handle) == 12 );
+C_ASSERT( sizeof(struct destroy_window_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_desktop_window_request, force) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_desktop_window_reply, top_window) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_desktop_window_reply, msg_window) == 12 );
+C_ASSERT( sizeof(struct get_desktop_window_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_window_owner_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_window_owner_request, owner) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_window_owner_reply, full_owner) == 8 );
+C_ASSERT( FIELD_OFFSET(struct set_window_owner_reply, prev_owner) == 12 );
+C_ASSERT( sizeof(struct set_window_owner_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_window_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, full_handle) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, last_active) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, pid) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, tid) == 20 );
+C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, atom) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, is_unicode) == 28 );
+C_ASSERT( sizeof(struct get_window_info_reply) == 32 );
+C_ASSERT( FIELD_OFFSET(struct set_window_info_request, flags) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_window_info_request, is_unicode) == 14 );
+C_ASSERT( FIELD_OFFSET(struct set_window_info_request, handle) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_window_info_request, style) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_window_info_request, ex_style) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_window_info_request, id) == 28 );
+C_ASSERT( FIELD_OFFSET(struct set_window_info_request, instance) == 32 );
+C_ASSERT( FIELD_OFFSET(struct set_window_info_request, user_data) == 40 );
+C_ASSERT( FIELD_OFFSET(struct set_window_info_request, extra_offset) == 48 );
+C_ASSERT( FIELD_OFFSET(struct set_window_info_request, extra_size) == 52 );
+C_ASSERT( FIELD_OFFSET(struct set_window_info_request, extra_value) == 56 );
+C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_style) == 8 );
+C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_ex_style) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_instance) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_user_data) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_extra_value) == 32 );
+C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_id) == 40 );
+C_ASSERT( sizeof(struct set_window_info_reply) == 48 );
+C_ASSERT( FIELD_OFFSET(struct set_parent_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_parent_request, parent) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_parent_reply, old_parent) == 8 );
+C_ASSERT( FIELD_OFFSET(struct set_parent_reply, full_parent) == 12 );
+C_ASSERT( sizeof(struct set_parent_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_window_parents_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_window_parents_reply, count) == 8 );
+C_ASSERT( sizeof(struct get_window_parents_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_window_children_request, desktop) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_window_children_request, parent) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_window_children_request, atom) == 20 );
+C_ASSERT( FIELD_OFFSET(struct get_window_children_request, tid) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_window_children_reply, count) == 8 );
+C_ASSERT( sizeof(struct get_window_children_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, parent) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, x) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, y) == 20 );
+C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_reply, count) == 8 );
+C_ASSERT( sizeof(struct get_window_children_from_point_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_window_tree_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, parent) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, owner) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, next_sibling) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, prev_sibling) == 20 );
+C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, first_sibling) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, last_sibling) == 28 );
+C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, first_child) == 32 );
+C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, last_child) == 36 );
+C_ASSERT( sizeof(struct get_window_tree_reply) == 40 );
+C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, flags) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, handle) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, previous) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, window) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, client) == 40 );
+C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, new_style) == 8 );
+C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, new_ex_style) == 12 );
+C_ASSERT( sizeof(struct set_window_pos_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply, window) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply, visible) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply, client) == 40 );
+C_ASSERT( sizeof(struct get_window_rectangles_reply) == 56 );
+C_ASSERT( FIELD_OFFSET(struct get_window_text_request, handle) == 12 );
+C_ASSERT( sizeof(struct get_window_text_reply) == 8 );
+C_ASSERT( FIELD_OFFSET(struct set_window_text_request, handle) == 12 );
+C_ASSERT( sizeof(struct set_window_text_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_windows_offset_request, from) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_windows_offset_request, to) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply, x) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply, y) == 12 );
+C_ASSERT( sizeof(struct get_windows_offset_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_visible_region_request, window) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_visible_region_request, flags) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, top_win) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, top_rect) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, win_rect) == 28 );
+C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, total_size) == 44 );
+C_ASSERT( sizeof(struct get_visible_region_reply) == 48 );
+C_ASSERT( FIELD_OFFSET(struct get_window_region_request, window) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_window_region_reply, total_size) == 8 );
+C_ASSERT( sizeof(struct get_window_region_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_window_region_request, window) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_window_region_request, redraw) == 16 );
+C_ASSERT( sizeof(struct set_window_region_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_update_region_request, window) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_update_region_request, from_child) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_update_region_request, flags) == 20 );
+C_ASSERT( FIELD_OFFSET(struct get_update_region_reply, child) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_update_region_reply, flags) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_update_region_reply, total_size) == 16 );
+C_ASSERT( sizeof(struct get_update_region_reply) == 24 );
+C_ASSERT( FIELD_OFFSET(struct update_window_zorder_request, window) == 12 );
+C_ASSERT( FIELD_OFFSET(struct update_window_zorder_request, rect) == 16 );
+C_ASSERT( sizeof(struct update_window_zorder_request) == 32 );
+C_ASSERT( FIELD_OFFSET(struct redraw_window_request, window) == 12 );
+C_ASSERT( FIELD_OFFSET(struct redraw_window_request, flags) == 16 );
+C_ASSERT( sizeof(struct redraw_window_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_window_property_request, window) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_window_property_request, data) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_window_property_request, atom) == 24 );
+C_ASSERT( sizeof(struct set_window_property_request) == 32 );
+C_ASSERT( FIELD_OFFSET(struct remove_window_property_request, window) == 12 );
+C_ASSERT( FIELD_OFFSET(struct remove_window_property_request, atom) == 16 );
+C_ASSERT( FIELD_OFFSET(struct remove_window_property_reply, data) == 8 );
+C_ASSERT( sizeof(struct remove_window_property_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_window_property_request, window) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_window_property_request, atom) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_window_property_reply, data) == 8 );
+C_ASSERT( sizeof(struct get_window_property_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_window_properties_request, window) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_window_properties_reply, total) == 8 );
+C_ASSERT( sizeof(struct get_window_properties_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_winstation_request, flags) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_winstation_request, access) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_winstation_request, attributes) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_winstation_reply, handle) == 8 );
+C_ASSERT( sizeof(struct create_winstation_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_winstation_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct open_winstation_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_winstation_reply, handle) == 8 );
+C_ASSERT( sizeof(struct open_winstation_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct close_winstation_request, handle) == 12 );
+C_ASSERT( sizeof(struct close_winstation_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_process_winstation_reply, handle) == 8 );
+C_ASSERT( sizeof(struct get_process_winstation_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_process_winstation_request, handle) == 12 );
+C_ASSERT( sizeof(struct set_process_winstation_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct enum_winstation_request, index) == 12 );
+C_ASSERT( FIELD_OFFSET(struct enum_winstation_reply, next) == 8 );
+C_ASSERT( sizeof(struct enum_winstation_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_desktop_request, flags) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_desktop_request, access) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_desktop_request, attributes) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_desktop_reply, handle) == 8 );
+C_ASSERT( sizeof(struct create_desktop_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_desktop_request, winsta) == 12 );
+C_ASSERT( FIELD_OFFSET(struct open_desktop_request, flags) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_desktop_request, access) == 20 );
+C_ASSERT( FIELD_OFFSET(struct open_desktop_request, attributes) == 24 );
+C_ASSERT( FIELD_OFFSET(struct open_desktop_reply, handle) == 8 );
+C_ASSERT( sizeof(struct open_desktop_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct close_desktop_request, handle) == 12 );
+C_ASSERT( sizeof(struct close_desktop_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_desktop_request, tid) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_desktop_reply, handle) == 8 );
+C_ASSERT( sizeof(struct get_thread_desktop_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_thread_desktop_request, handle) == 12 );
+C_ASSERT( sizeof(struct set_thread_desktop_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct enum_desktop_request, winstation) == 12 );
+C_ASSERT( FIELD_OFFSET(struct enum_desktop_request, index) == 16 );
+C_ASSERT( FIELD_OFFSET(struct enum_desktop_reply, next) == 8 );
+C_ASSERT( sizeof(struct enum_desktop_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request, flags) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request, obj_flags) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_user_object_info_reply, is_desktop) == 8 );
+C_ASSERT( FIELD_OFFSET(struct set_user_object_info_reply, old_obj_flags) == 12 );
+C_ASSERT( sizeof(struct set_user_object_info_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request, tid_from) == 12 );
+C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request, tid_to) == 16 );
+C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request, attach) == 20 );
+C_ASSERT( sizeof(struct attach_thread_input_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_input_request, tid) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, focus) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, capture) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, active) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, foreground) == 20 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, menu_owner) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, move_size) == 28 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, caret) == 32 );
+C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, rect) == 36 );
+C_ASSERT( sizeof(struct get_thread_input_reply) == 56 );
+C_ASSERT( FIELD_OFFSET(struct get_last_input_time_reply, time) == 8 );
+C_ASSERT( sizeof(struct get_last_input_time_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_key_state_request, tid) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_key_state_request, key) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_key_state_reply, state) == 8 );
+C_ASSERT( sizeof(struct get_key_state_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_key_state_request, tid) == 12 );
+C_ASSERT( sizeof(struct set_key_state_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_foreground_window_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply, previous) == 8 );
+C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply, send_msg_old) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply, send_msg_new) == 16 );
+C_ASSERT( sizeof(struct set_foreground_window_reply) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_focus_window_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_focus_window_reply, previous) == 8 );
+C_ASSERT( sizeof(struct set_focus_window_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_active_window_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_active_window_reply, previous) == 8 );
+C_ASSERT( sizeof(struct set_active_window_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_capture_window_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_capture_window_request, flags) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_capture_window_reply, previous) == 8 );
+C_ASSERT( FIELD_OFFSET(struct set_capture_window_reply, full_handle) == 12 );
+C_ASSERT( sizeof(struct set_capture_window_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_caret_window_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_caret_window_request, width) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_caret_window_request, height) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, previous) == 8 );
+C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, old_rect) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, old_hide) == 28 );
+C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, old_state) == 32 );
+C_ASSERT( sizeof(struct set_caret_window_reply) == 40 );
+C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, flags) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, handle) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, x) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, y) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, hide) == 28 );
+C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, state) == 32 );
+C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, full_handle) == 8 );
+C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, old_rect) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, old_hide) == 28 );
+C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, old_state) == 32 );
+C_ASSERT( sizeof(struct set_caret_info_reply) == 40 );
+C_ASSERT( FIELD_OFFSET(struct set_hook_request, id) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_hook_request, pid) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_hook_request, tid) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_hook_request, event_min) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_hook_request, event_max) == 28 );
+C_ASSERT( FIELD_OFFSET(struct set_hook_request, proc) == 32 );
+C_ASSERT( FIELD_OFFSET(struct set_hook_request, flags) == 40 );
+C_ASSERT( FIELD_OFFSET(struct set_hook_request, unicode) == 44 );
+C_ASSERT( FIELD_OFFSET(struct set_hook_reply, handle) == 8 );
+C_ASSERT( FIELD_OFFSET(struct set_hook_reply, active_hooks) == 12 );
+C_ASSERT( sizeof(struct set_hook_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct remove_hook_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct remove_hook_request, proc) == 16 );
+C_ASSERT( FIELD_OFFSET(struct remove_hook_request, id) == 24 );
+C_ASSERT( FIELD_OFFSET(struct remove_hook_reply, active_hooks) == 8 );
+C_ASSERT( sizeof(struct remove_hook_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, id) == 12 );
+C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, event) == 16 );
+C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, window) == 20 );
+C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, object_id) == 24 );
+C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, child_id) == 28 );
+C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, handle) == 8 );
+C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, pid) == 12 );
+C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, tid) == 16 );
+C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, unicode) == 20 );
+C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, proc) == 24 );
+C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, active_hooks) == 32 );
+C_ASSERT( sizeof(struct start_hook_chain_reply) == 40 );
+C_ASSERT( FIELD_OFFSET(struct finish_hook_chain_request, id) == 12 );
+C_ASSERT( sizeof(struct finish_hook_chain_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, get_next) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, event) == 20 );
+C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, window) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, object_id) == 28 );
+C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, child_id) == 32 );
+C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, handle) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, id) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, pid) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, tid) == 20 );
+C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, proc) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, unicode) == 32 );
+C_ASSERT( sizeof(struct get_hook_info_reply) == 40 );
+C_ASSERT( FIELD_OFFSET(struct create_class_request, local) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_class_request, atom) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_class_request, style) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_class_request, instance) == 24 );
+C_ASSERT( FIELD_OFFSET(struct create_class_request, extra) == 32 );
+C_ASSERT( FIELD_OFFSET(struct create_class_request, win_extra) == 36 );
+C_ASSERT( FIELD_OFFSET(struct create_class_request, client_ptr) == 40 );
+C_ASSERT( FIELD_OFFSET(struct create_class_reply, atom) == 8 );
+C_ASSERT( sizeof(struct create_class_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct destroy_class_request, atom) == 12 );
+C_ASSERT( FIELD_OFFSET(struct destroy_class_request, instance) == 16 );
+C_ASSERT( FIELD_OFFSET(struct destroy_class_reply, client_ptr) == 8 );
+C_ASSERT( sizeof(struct destroy_class_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_class_info_request, window) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_class_info_request, flags) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_class_info_request, atom) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_class_info_request, style) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_class_info_request, win_extra) == 28 );
+C_ASSERT( FIELD_OFFSET(struct set_class_info_request, instance) == 32 );
+C_ASSERT( FIELD_OFFSET(struct set_class_info_request, extra_offset) == 40 );
+C_ASSERT( FIELD_OFFSET(struct set_class_info_request, extra_size) == 44 );
+C_ASSERT( FIELD_OFFSET(struct set_class_info_request, extra_value) == 48 );
+C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_atom) == 8 );
+C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_style) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_extra) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_win_extra) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_instance) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_extra_value) == 32 );
+C_ASSERT( sizeof(struct set_class_info_reply) == 40 );
+C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_request, flags) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_request, clipboard) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_request, owner) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_request, viewer) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_request, seqno) == 28 );
+C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_reply, flags) == 8 );
+C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_reply, old_clipboard) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_reply, old_owner) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_reply, old_viewer) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_reply, seqno) == 24 );
+C_ASSERT( sizeof(struct set_clipboard_info_reply) == 32 );
+C_ASSERT( FIELD_OFFSET(struct open_token_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct open_token_request, access) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_token_request, attributes) == 20 );
+C_ASSERT( FIELD_OFFSET(struct open_token_request, flags) == 24 );
+C_ASSERT( FIELD_OFFSET(struct open_token_reply, token) == 8 );
+C_ASSERT( sizeof(struct open_token_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, flags) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, shell_window) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, shell_listview) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, progman_window) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, taskman_window) == 28 );
+C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_shell_window) == 8 );
+C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_shell_listview) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_progman_window) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_taskman_window) == 20 );
+C_ASSERT( sizeof(struct set_global_windows_reply) == 24 );
+C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request, disable_all) == 16 );
+C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request, get_modified_state) == 20 );
+C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_reply, len) == 8 );
+C_ASSERT( sizeof(struct adjust_token_privileges_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_token_privileges_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_token_privileges_reply, len) == 8 );
+C_ASSERT( sizeof(struct get_token_privileges_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct check_token_privileges_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct check_token_privileges_request, all_required) == 16 );
+C_ASSERT( FIELD_OFFSET(struct check_token_privileges_reply, has_privileges) == 8 );
+C_ASSERT( sizeof(struct check_token_privileges_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, access) == 16 );
+C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, attributes) == 20 );
+C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, primary) == 24 );
+C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, impersonation_level) == 28 );
+C_ASSERT( FIELD_OFFSET(struct duplicate_token_reply, new_handle) == 8 );
+C_ASSERT( sizeof(struct duplicate_token_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct access_check_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct access_check_request, desired_access) == 16 );
+C_ASSERT( FIELD_OFFSET(struct access_check_request, mapping_read) == 20 );
+C_ASSERT( FIELD_OFFSET(struct access_check_request, mapping_write) == 24 );
+C_ASSERT( FIELD_OFFSET(struct access_check_request, mapping_execute) == 28 );
+C_ASSERT( FIELD_OFFSET(struct access_check_request, mapping_all) == 32 );
+C_ASSERT( FIELD_OFFSET(struct access_check_reply, access_granted) == 8 );
+C_ASSERT( FIELD_OFFSET(struct access_check_reply, access_status) == 12 );
+C_ASSERT( FIELD_OFFSET(struct access_check_reply, privileges_len) == 16 );
+C_ASSERT( sizeof(struct access_check_reply) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_token_user_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_token_user_reply, user_len) == 8 );
+C_ASSERT( sizeof(struct get_token_user_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_token_groups_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_token_groups_reply, user_len) == 8 );
+C_ASSERT( sizeof(struct get_token_groups_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_security_object_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_security_object_request, security_info) == 16 );
+C_ASSERT( sizeof(struct set_security_object_request) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_security_object_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_security_object_request, security_info) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_security_object_reply, sd_len) == 8 );
+C_ASSERT( sizeof(struct get_security_object_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, rootdir) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, read_timeout) == 24 );
+C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, max_msgsize) == 32 );
+C_ASSERT( FIELD_OFFSET(struct create_mailslot_reply, handle) == 8 );
+C_ASSERT( sizeof(struct create_mailslot_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request, read_timeout) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request, flags) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_reply, read_timeout) == 8 );
+C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_reply, max_msgsize) == 16 );
+C_ASSERT( sizeof(struct set_mailslot_info_reply) == 24 );
+C_ASSERT( FIELD_OFFSET(struct create_directory_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_directory_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_directory_request, rootdir) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_directory_reply, handle) == 8 );
+C_ASSERT( sizeof(struct create_directory_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_directory_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct open_directory_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_directory_request, rootdir) == 20 );
+C_ASSERT( FIELD_OFFSET(struct open_directory_reply, handle) == 8 );
+C_ASSERT( sizeof(struct open_directory_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_directory_entry_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_directory_entry_request, index) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_directory_entry_reply, name_len) == 8 );
+C_ASSERT( sizeof(struct get_directory_entry_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_symlink_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_symlink_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_symlink_request, rootdir) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_symlink_request, name_len) == 24 );
+C_ASSERT( FIELD_OFFSET(struct create_symlink_reply, handle) == 8 );
+C_ASSERT( sizeof(struct create_symlink_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_symlink_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct open_symlink_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_symlink_request, rootdir) == 20 );
+C_ASSERT( FIELD_OFFSET(struct open_symlink_reply, handle) == 8 );
+C_ASSERT( sizeof(struct open_symlink_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct query_symlink_request, handle) == 12 );
+C_ASSERT( sizeof(struct query_symlink_reply) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_object_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, access) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, ref_count) == 12 );
+C_ASSERT( sizeof(struct get_object_info_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct unlink_object_request, handle) == 12 );
+C_ASSERT( sizeof(struct unlink_object_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_token_impersonation_level_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_token_impersonation_level_reply, impersonation_level) == 8 );
+C_ASSERT( sizeof(struct get_token_impersonation_level_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct allocate_locally_unique_id_reply, luid) == 8 );
+C_ASSERT( sizeof(struct allocate_locally_unique_id_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_device_manager_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_device_manager_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_device_manager_reply, handle) == 8 );
+C_ASSERT( sizeof(struct create_device_manager_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_device_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_device_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_device_request, rootdir) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_device_request, user_ptr) == 24 );
+C_ASSERT( FIELD_OFFSET(struct create_device_request, manager) == 32 );
+C_ASSERT( FIELD_OFFSET(struct create_device_reply, handle) == 8 );
+C_ASSERT( sizeof(struct create_device_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct delete_device_request, handle) == 12 );
+C_ASSERT( sizeof(struct delete_device_request) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, manager) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, prev) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, status) == 20 );
+C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, next) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, code) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, user_ptr) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, in_size) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, out_size) == 28 );
+C_ASSERT( sizeof(struct get_next_device_request_reply) == 32 );
+C_ASSERT( FIELD_OFFSET(struct make_process_system_reply, event) == 8 );
+C_ASSERT( sizeof(struct make_process_system_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_token_statistics_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, token_id) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, modified_id) == 16 );
+C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, primary) == 24 );
+C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, impersonation_level) == 28 );
+C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, group_count) == 32 );
+C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, privilege_count) == 36 );
+C_ASSERT( sizeof(struct get_token_statistics_reply) == 40 );
+C_ASSERT( FIELD_OFFSET(struct create_completion_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct create_completion_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct create_completion_request, concurrent) == 20 );
+C_ASSERT( FIELD_OFFSET(struct create_completion_request, rootdir) == 24 );
+C_ASSERT( FIELD_OFFSET(struct create_completion_reply, handle) == 8 );
+C_ASSERT( sizeof(struct create_completion_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_completion_request, access) == 12 );
+C_ASSERT( FIELD_OFFSET(struct open_completion_request, attributes) == 16 );
+C_ASSERT( FIELD_OFFSET(struct open_completion_request, rootdir) == 20 );
+C_ASSERT( FIELD_OFFSET(struct open_completion_reply, handle) == 8 );
+C_ASSERT( sizeof(struct open_completion_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct add_completion_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct add_completion_request, ckey) == 16 );
+C_ASSERT( FIELD_OFFSET(struct add_completion_request, cvalue) == 24 );
+C_ASSERT( FIELD_OFFSET(struct add_completion_request, information) == 32 );
+C_ASSERT( FIELD_OFFSET(struct add_completion_request, status) == 36 );
+C_ASSERT( sizeof(struct add_completion_request) == 40 );
+C_ASSERT( FIELD_OFFSET(struct remove_completion_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, ckey) == 8 );
+C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, cvalue) == 16 );
+C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, information) == 24 );
+C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, status) == 28 );
+C_ASSERT( sizeof(struct remove_completion_reply) == 32 );
+C_ASSERT( FIELD_OFFSET(struct query_completion_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct query_completion_reply, depth) == 8 );
+C_ASSERT( sizeof(struct query_completion_reply) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_completion_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_completion_info_request, ckey) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_completion_info_request, chandle) == 24 );
+C_ASSERT( sizeof(struct set_completion_info_request) == 32 );
+C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, cvalue) == 16 );
+C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, status) == 24 );
+C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, information) == 28 );
+C_ASSERT( sizeof(struct add_fd_completion_request) == 32 );
+C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply, color_key) == 8 );
+C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply, alpha) == 12 );
+C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply, flags) == 16 );
+C_ASSERT( sizeof(struct get_window_layered_info_reply) == 24 );
+C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, handle) == 12 );
+C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, color_key) == 16 );
+C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, alpha) == 20 );
+C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, flags) == 24 );
+C_ASSERT( sizeof(struct set_window_layered_info_request) == 32 );
+
 #endif  /* WANT_REQUEST_HANDLERS */
 
 /* ### make_requests end ### */

tools/make_requests

@@ -53,6 +53,7 @@ my %formats =
 
 my @requests = ();
 my %replies = ();
+my @asserts = ();
 
 my @trace_lines = ();
 
@@ -167,11 +168,18 @@ sub PARSE_REQUESTS()
         if (/^\@END/)
         {
             die "Misplaced \@END" unless ($state == 2 || $state == 3);
-            print SERVER_PROT "};\n";
 
+            if ($offset & 7)  # all requests should be 8-byte aligned
+            {
+                my $count = 8 - ($offset & 7);
+                print SERVER_PROT "    char __pad_$offset\[$count\];\n";
+                $offset += $count;
+            }
+            print SERVER_PROT "};\n";
             if ($state == 2)  # build dummy reply struct
             {
                 die "request $name too large ($offset)" if ($offset > $max_req_size);
+                push @asserts, "C_ASSERT( sizeof(struct ${name}_request) == $offset );\n";
                 print SERVER_PROT "struct ${name}_reply\n{\n";
                 print SERVER_PROT "    struct reply_header __header;\n";
                 print SERVER_PROT "};\n";
@@ -179,6 +187,7 @@ sub PARSE_REQUESTS()
             else
             {
                 die "reply $name too large ($offset)" if ($offset > $max_req_size);
+                push @asserts, "C_ASSERT( sizeof(struct ${name}_reply) == $offset );\n";
             }
             # got a complete request
             push @requests, $name;
@@ -221,9 +230,19 @@ sub PARSE_REQUESTS()
                 my @fmt = @{$formats{$type}};
                 if ($offset & ($fmt[1] - 1))
                 {
+                    my $count = $fmt[1] - ($offset & ($fmt[1] - 1));
                     print "protocol.def:$.: warning: $name $offset $type $var needs padding\n" if $warnings;
+                    print SERVER_PROT "    char __pad_$offset\[$count\];\n";
+                    $offset += $count;
+                }
+                if ($state == 2)
+                {
+                    push @asserts, "C_ASSERT( FIELD_OFFSET(struct ${name}_request, $var) == $offset );\n";
+                }
+                else
+                {
+                    push @asserts, "C_ASSERT( FIELD_OFFSET(struct ${name}_reply, $var) == $offset );\n";
                 }
-                $offset = ($offset + $fmt[1] - 1) & ~($fmt[1] - 1);
                 $offset += $fmt[0];
             }
             else
@@ -428,7 +447,15 @@ foreach my $req (@requests)
 {
     push @request_lines, "    (req_handler)req_$req,\n";
 }
-push @request_lines, "};\n#endif  /* WANT_REQUEST_HANDLERS */\n";
+push @request_lines, "};\n\n";
+
+foreach my $type (sort keys %formats)
+{
+    my $size = ${$formats{$type}}[0];
+    push @request_lines, "C_ASSERT( sizeof($type) == $size );\n";
+}
+push @request_lines, @asserts;
+push @request_lines, "\n#endif  /* WANT_REQUEST_HANDLERS */\n";
 
 replace_in_file( "server/request.h",
                  "### make_requests begin ###",