diff --git a/lsteamclient/Makefile.in b/lsteamclient/Makefile.in index bc34251c..cb37117a 100644 --- a/lsteamclient/Makefile.in +++ b/lsteamclient/Makefile.in @@ -297,3 +297,4 @@ SOURCES = \ struct_converters_157.cpp \ struct_converters_158.cpp \ unix_steam_client_manual.cpp \ + unixlib_generated.cpp \ diff --git a/lsteamclient/gen_wrapper.py b/lsteamclient/gen_wrapper.py index f1949527..ee7669c0 100755 --- a/lsteamclient/gen_wrapper.py +++ b/lsteamclient/gen_wrapper.py @@ -510,6 +510,31 @@ class Struct: def fields(self): return [f for f in self.padded_fields if type(f) is not Padding] + def write_definition(self, out, prefix): + version = all_versions[sdkver][self.name] + kind = 'union' if type(self) is Union else 'struct' + wrapped = len(prefix) > 0 + + out(f'#pragma pack( push, {self.align} )\n') + out(f'{kind} {prefix}{version}\n') + out(u'{\n') + for f in self.padded_fields: + if type(f) is Field: + out(f' {declspec(f._cursor, f.name, prefix, wrapped)};\n') + else: + out(f' uint8_t __pad_{f.offset}[{f.size}];\n') + out(u'};\n') + out(u'#pragma pack( pop )\n\n') + + def write_checks(self, out, prefix): + version = all_versions[sdkver][self.name] + + out(f'C_ASSERT( sizeof({prefix}{version}) >= {self.size} );\n') + for f in self.fields: + out(f'C_ASSERT( offsetof({prefix}{version}, {f.name}) == {f.offset} );\n') + out(f'C_ASSERT( sizeof({prefix}{version}().{f.name}) >= {f.size} );\n') + out(u'\n') + def needs_conversion(self, other): if other.id in self._conv_cache: return self._conv_cache[other.id] @@ -751,13 +776,13 @@ def callconv(cursor, prefix): def declspec_func(decl, name, prefix): - ret = declspec(decl.get_result(), "", prefix) - params = [declspec(a, "", prefix) for a in decl.argument_types()] + ret = declspec(decl.get_result(), "", prefix, False) + params = [declspec(a, "", prefix, False) for a in decl.argument_types()] params = ", ".join(params) if len(params) else "void" return f'{ret} ({name})({params})' -def declspec(decl, name, prefix): +def declspec(decl, name, prefix, wrapped=False): call = callconv(decl, prefix) if type(decl) is Cursor: decl = decl.type @@ -768,10 +793,16 @@ def declspec(decl, name, prefix): return declspec_func(decl, name, prefix) if decl.kind in (TypeKind.POINTER, TypeKind.LVALUEREFERENCE): decl = decl.get_pointee() - return declspec(decl, f"*{call}{const}{name}", prefix) + spec = declspec(decl, f"*{call}{const}{name}", prefix, False) + if wrapped: + return f'{prefix.upper()}PTR({spec}, {name})' + return spec if decl.kind == TypeKind.CONSTANTARRAY: decl, count = decl.element_type, decl.element_count - return declspec(decl, f"({const}{name})[{count}]", prefix) + if wrapped: + spec = declspec(decl, const, prefix, False) + return f'{prefix.upper()}ARRAY({spec}, {count}, {name})' + return declspec(decl, f"({const}{name})[{count}]", prefix, False) if len(name): name = f' {name}' @@ -782,6 +813,13 @@ def declspec(decl, name, prefix): return f'uint{decl.get_size() * 8}_t{name}' type_name = decl.spelling.removeprefix("const ") + if prefix not in (None, "win") and decl.kind == TypeKind.RECORD \ + and type_name in all_versions[sdkver] \ + and type_name not in EXEMPT_STRUCTS: + if type_name in unique_structs: + return f'{const}{all_versions[sdkver][type_name]}{name}' + return f'{const}{prefix}{all_versions[sdkver][type_name]}{name}' + if prefix == "win" and param_needs_conversion(decl): return f"{const}win{type_name}_{sdkver}{name}" if type_name.startswith('ISteam'): @@ -793,6 +831,8 @@ def declspec(decl, name, prefix): if type_name.startswith(('uint', 'unsigned')): return f'{const}uint{decl.get_size() * 8}_t{name}' + if 'unnamed union' in decl.spelling: + return f'{const}struct {{ uint8_t _[{decl.get_size()}]; }}{name}' return f'{decl.spelling}{name}' @@ -861,20 +901,20 @@ def handle_method_cpp(method, classname, cppname, out): type_name = underlying_typename(param) if param.type.kind != TypeKind.POINTER: - out(f' {declspec(param, f"lin_{name}", "u_")};\n') + out(f' {declspec(param, f"lin_{name}", None)};\n') out(f' win_to_lin_struct_{type_name}_{sdkver}( ¶ms->{name}, &lin_{name} );\n') continue pointee = param.type.get_pointee() if pointee.kind == TypeKind.POINTER: need_output[name] = param - out(f' {declspec(pointee, f"lin_{name}", "u_")};\n') + out(f' {declspec(pointee, f"lin_{name}", None)};\n') continue if not pointee.is_const_qualified(): need_output[name] = param - out(f' {declspec(pointee, f"lin_{name}", "u_")};\n') + out(f' {declspec(pointee, f"lin_{name}", None)};\n') out(f' win_to_lin_struct_{type_name}_{sdkver}( params->{name}, &lin_{name} );\n') for name, param in sorted(manual_convert.items()): @@ -1506,8 +1546,8 @@ for i, name in enumerate(all_structs.keys()): if not versions or sdkver not in versions: continue all_versions[sdkver][name] = versions[sdkver] -def struct_order(tuple): - name, structs = tuple +def struct_order(x): + name, structs = x if type(x) is tuple else (x, all_structs[x]) order = (struct.order for abis in structs.values() for struct in abis.values()) return (min(order), name) @@ -1559,6 +1599,129 @@ with open('struct_converters.h', 'a') as file: out(u'#endif /* __STRUCT_CONVERTERS_H */\n') + +declared = {} + +with open('steamclient_structs_generated.h', 'w') as file: + out = file.write + + for name in sorted(unique_structs, key=struct_order): + if name in EXEMPT_STRUCTS: continue + for sdkver, abis in all_structs[name].items(): + if name not in all_versions[sdkver]: continue + + version = all_versions[sdkver][name] + if f'struct {version}' in declared: continue + declared[f'struct {version}'] = True + + kind = 'union' if type(abis['w64']) is Union else 'struct' + + out(f'typedef {kind} {version} {version};\n') + abis['w64'].write_definition(out, "") + + for name, structs in all_structs.items(): + if name in EXEMPT_STRUCTS: continue + if name in unique_structs: continue + for sdkver, abis in structs.items(): + if name not in all_versions[sdkver]: continue + + version = all_versions[sdkver][name] + if f'typedef {version}' in declared: continue + declared[f'typedef {version}'] = True + + kind = 'union' if type(abis['w64']) is Union else 'struct' + + if type(abis['w64']) is Class: + out(f'typedef {kind} u_{version} u_{version};\n') + out(f'typedef {kind} u_{version} u64_{version};\n') + out(f'typedef {kind} u_{version} u32_{version};\n') + out(f'typedef {kind} w_{version} w_{version};\n') + out(f'typedef {kind} w_{version} w64_{version};\n') + out(f'typedef {kind} w_{version} w32_{version};\n') + continue + + if abis["w64"].needs_conversion(abis["u64"]): + out(f'typedef {kind} u64_{version} u64_{version};\n') + else: + out(f'typedef {kind} w64_{version} u64_{version};\n') + out(f'typedef {kind} w64_{version} w64_{version};\n') + + if abis["w32"].needs_conversion(abis["u32"]): + out(f'typedef {kind} u32_{version} u32_{version};\n') + else: + out(f'typedef {kind} w32_{version} u32_{version};\n') + out(f'typedef {kind} w32_{version} w32_{version};\n') + + for name, structs in all_structs.items(): + if name in EXEMPT_STRUCTS: continue + if name in unique_structs: continue + for sdkver, abis in structs.items(): + if name not in all_versions[sdkver]: continue + + version = all_versions[sdkver][name] + if f'struct {version}' in declared: continue + declared[f'struct {version}'] = True + + kind = 'union' if type(abis['w64']) is Union else 'struct' + + if type(abis['w64']) is Class: + abis['w64'].write_definition(out, "w_") + abis['u64'].write_definition(out, "u_") + continue + + abis['w64'].write_definition(out, "w64_") + if abis["w64"].needs_conversion(abis["u64"]): + abis['u64'].write_definition(out, "u64_") + + abis['w32'].write_definition(out, "w32_") + if abis["w32"].needs_conversion(abis["u32"]): + abis['u32'].write_definition(out, "u32_") + + out(u'#ifdef __i386__\n') + out(f'typedef w32_{version} w_{version};\n') + out(f'typedef u32_{version} u_{version};\n') + out(u'#endif\n') + out(u'#ifdef __x86_64__\n') + out(f'typedef w64_{version} w_{version};\n') + out(f'typedef u64_{version} u_{version};\n') + out(u'#endif\n') + out(u'\n') + + +with open('unixlib_generated.cpp', 'w') as file: + out = file.write + + out(u'/* This file is auto-generated, do not edit. */\n\n') + out(u'#include "steamclient_structs.h"\n\n') + + for name in sorted(unique_structs, key=struct_order): + for sdkver, abis in all_structs[name].items(): + if name not in all_versions[sdkver]: continue + + version = all_versions[sdkver][name] + if f'checks {version}' in declared: continue + declared[f'checks {version}'] = True + + abis['w64'].write_checks(out, "") + + for name, structs in all_structs.items(): + if name in EXEMPT_STRUCTS: continue + if name in unique_structs: continue + for sdkver, abis in structs.items(): + if name not in all_versions[sdkver]: continue + + version = all_versions[sdkver][name] + if f'checks {version}' in declared: continue + declared[f'checks {version}'] = True + + if type(abis['w64']) is Class: + continue + + abis['w64'].write_checks(out, "w64_") + abis['u64'].write_checks(out, "u64_") + abis['w32'].write_checks(out, "w32_") + abis['u32'].write_checks(out, "u32_") + getapifile = open("cb_getapi_table.dat", "w") cbsizefile = open("cb_getapi_sizes.dat", "w") diff --git a/lsteamclient/steamclient_structs.h b/lsteamclient/steamclient_structs.h new file mode 100644 index 00000000..0473561e --- /dev/null +++ b/lsteamclient/steamclient_structs.h @@ -0,0 +1,58 @@ +#include +#include +#include +#include + +#include +#include + +#ifdef __cplusplus +#include +extern "C" +{ +#endif /* __cplusplus */ + +#ifdef __cplusplus +#define U64_ARRAY( type, count, name ) std::array name +#define U32_ARRAY( type, count, name ) std::array name +#define W64_ARRAY( type, count, name ) std::array name +#define W32_ARRAY( type, count, name ) std::array name +#else +#define U64_ARRAY( type, count, name ) type name[count] +#define U32_ARRAY( type, count, name ) type name[count] +#define W64_ARRAY( type, count, name ) type name[count] +#define W32_ARRAY( type, count, name ) type name[count] +#endif + +#define W_CDECL __cdecl +#define W_STDCALL __stdcall +#define U_CDECL __attribute__((sysv_abi)) +#define U_STDCALL __attribute__((sysv_abi)) + +#ifdef __i386__ +#define U64_PTR( decl, name ) uint64_t name +#define U32_PTR( decl, name ) decl +#define W64_PTR( decl, name ) uint64_t name +#define W32_PTR( decl, name ) decl +#define U_PTR U32_PTR +#define W_PTR W32_PTR +#endif + +#ifdef __x86_64__ +#define U64_PTR( decl, name ) decl +#define U32_PTR( decl, name ) uint32_t name +#define W64_PTR( decl, name ) decl +#define W32_PTR( decl, name ) uint32_t name +#define U_PTR U64_PTR +#define W_PTR W64_PTR +#endif + +typedef struct { uint8_t _[8]; } CSteamID; +typedef struct { uint8_t _[8]; } CGameID; +typedef struct { uint8_t _[20]; } SteamIPAddress_t; + +#include "steamclient_structs_generated.h" + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* __cplusplus */ diff --git a/lsteamclient/steamclient_structs_generated.h b/lsteamclient/steamclient_structs_generated.h new file mode 100644 index 00000000..6135bd2b --- /dev/null +++ b/lsteamclient/steamclient_structs_generated.h @@ -0,0 +1,9510 @@ +typedef struct SteamNetworkingIPAddr SteamNetworkingIPAddr; +#pragma pack( push, 1 ) +struct SteamNetworkingIPAddr +{ + struct { uint8_t _[16]; } data; + uint16_t m_port; +}; +#pragma pack( pop ) + +typedef struct SteamNetworkingIdentity_144 SteamNetworkingIdentity_144; +#pragma pack( push, 1 ) +struct SteamNetworkingIdentity_144 +{ + uint32_t m_eType; + int32_t m_cbSize; + struct { uint8_t _[128]; } data; +}; +#pragma pack( pop ) + +typedef struct SteamNetworkingIdentity_151 SteamNetworkingIdentity_151; +#pragma pack( push, 1 ) +struct SteamNetworkingIdentity_151 +{ + uint32_t m_eType; + int32_t m_cbSize; +}; +#pragma pack( pop ) + +typedef struct SteamNetConnectionInfo_t_153a SteamNetConnectionInfo_t_153a; +#pragma pack( push, 8 ) +struct SteamNetConnectionInfo_t_153a +{ + SteamNetworkingIdentity_144 m_identityRemote; + int64_t m_nUserData; + uint32_t m_hListenSocket; + SteamNetworkingIPAddr m_addrRemote; + uint16_t m__pad1; + uint32_t m_idPOPRemote; + uint32_t m_idPOPRelay; + uint32_t m_eState; + int32_t m_eEndReason; + char (m_szEndDebug)[128]; + char (m_szConnectionDescription)[128]; + int32_t m_nFlags; + uint32_t (reserved)[63]; +}; +#pragma pack( pop ) + +typedef struct SteamNetConnectionInfo_t_144 SteamNetConnectionInfo_t_144; +#pragma pack( push, 8 ) +struct SteamNetConnectionInfo_t_144 +{ + SteamNetworkingIdentity_144 m_identityRemote; + int64_t m_nUserData; + uint32_t m_hListenSocket; + SteamNetworkingIPAddr m_addrRemote; + uint16_t m__pad1; + uint32_t m_idPOPRemote; + uint32_t m_idPOPRelay; + uint32_t m_eState; + int32_t m_eEndReason; + char (m_szEndDebug)[128]; + char (m_szConnectionDescription)[128]; + uint32_t (reserved)[64]; +}; +#pragma pack( pop ) + +typedef struct SteamNetConnectionInfo_t_151 SteamNetConnectionInfo_t_151; +#pragma pack( push, 8 ) +struct SteamNetConnectionInfo_t_151 +{ + SteamNetworkingIdentity_151 m_identityRemote; + int64_t m_nUserData; + uint32_t m_hListenSocket; + SteamNetworkingIPAddr m_addrRemote; + uint16_t m__pad1; + uint32_t m_idPOPRemote; + uint32_t m_idPOPRelay; + uint32_t m_eState; + int32_t m_eEndReason; + char (m_szEndDebug)[128]; + char (m_szConnectionDescription)[128]; + uint32_t (reserved)[64]; +}; +#pragma pack( pop ) + +typedef struct servernetadr_t servernetadr_t; +#pragma pack( push, 4 ) +struct servernetadr_t +{ + uint16_t m_usConnectionPort; + uint16_t m_usQueryPort; + uint32_t m_unIP; +}; +#pragma pack( pop ) + +typedef struct ActiveBeaconsUpdated_t ActiveBeaconsUpdated_t; +#pragma pack( push, 1 ) +struct ActiveBeaconsUpdated_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct AppDataChanged_t AppDataChanged_t; +#pragma pack( push, 4 ) +struct AppDataChanged_t +{ + uint32_t m_nAppID; + bool m_bBySteamUI; + bool m_bCDDBUpdate; + uint8_t __pad_6[2]; +}; +#pragma pack( pop ) + +typedef struct AppProofOfPurchaseKeyResponse_t_137 AppProofOfPurchaseKeyResponse_t_137; +#pragma pack( push, 4 ) +struct AppProofOfPurchaseKeyResponse_t_137 +{ + uint32_t m_eResult; + uint32_t m_nAppID; + uint32_t m_cchKeyLength; + char (m_rgchKey)[240]; +}; +#pragma pack( pop ) + +typedef struct AppProofOfPurchaseKeyResponse_t_118 AppProofOfPurchaseKeyResponse_t_118; +#pragma pack( push, 4 ) +struct AppProofOfPurchaseKeyResponse_t_118 +{ + uint32_t m_eResult; + uint32_t m_nAppID; + char (m_rgchKey)[64]; +}; +#pragma pack( pop ) + +typedef struct AppResumingFromSuspend_t AppResumingFromSuspend_t; +#pragma pack( push, 1 ) +struct AppResumingFromSuspend_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct AssociateWithClanResult_t AssociateWithClanResult_t; +#pragma pack( push, 4 ) +struct AssociateWithClanResult_t +{ + uint32_t m_eResult; +}; +#pragma pack( pop ) + +typedef struct AvailableBeaconLocationsUpdated_t AvailableBeaconLocationsUpdated_t; +#pragma pack( push, 1 ) +struct AvailableBeaconLocationsUpdated_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct AvatarImageLoaded_t AvatarImageLoaded_t; +#pragma pack( push, 4 ) +struct AvatarImageLoaded_t +{ + CSteamID m_steamID; + int32_t m_iImage; + int32_t m_iWide; + int32_t m_iTall; +}; +#pragma pack( pop ) + +typedef struct BroadcastUploadStart_t BroadcastUploadStart_t; +#pragma pack( push, 1 ) +struct BroadcastUploadStart_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct BroadcastUploadStop_t BroadcastUploadStop_t; +#pragma pack( push, 4 ) +struct BroadcastUploadStop_t +{ + uint32_t m_eResult; +}; +#pragma pack( pop ) + +typedef struct CallbackPipeFailure_t CallbackPipeFailure_t; +#pragma pack( push, 1 ) +struct CallbackPipeFailure_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct ChangeNumOpenSlotsCallback_t ChangeNumOpenSlotsCallback_t; +#pragma pack( push, 4 ) +struct ChangeNumOpenSlotsCallback_t +{ + uint32_t m_eResult; +}; +#pragma pack( pop ) + +typedef struct CheckFileSignature_t CheckFileSignature_t; +#pragma pack( push, 4 ) +struct CheckFileSignature_t +{ + uint32_t m_eCheckFileSignature; +}; +#pragma pack( pop ) + +typedef struct ClanOfficerListResponse_t ClanOfficerListResponse_t; +#pragma pack( push, 4 ) +struct ClanOfficerListResponse_t +{ + CSteamID m_steamIDClan; + int32_t m_cOfficers; + uint8_t m_bSuccess; + uint8_t __pad_13[3]; +}; +#pragma pack( pop ) + +typedef struct ClientGameServerDeny_t ClientGameServerDeny_t; +#pragma pack( push, 4 ) +struct ClientGameServerDeny_t +{ + uint32_t m_uAppID; + uint32_t m_unGameServerIP; + uint16_t m_usGameServerPort; + uint16_t m_bSecure; + uint32_t m_uReason; +}; +#pragma pack( pop ) + +typedef struct ComputeNewPlayerCompatibilityResult_t_119 ComputeNewPlayerCompatibilityResult_t_119; +#pragma pack( push, 4 ) +struct ComputeNewPlayerCompatibilityResult_t_119 +{ + uint32_t m_eResult; + int32_t m_cPlayersThatDontLikeCandidate; + int32_t m_cPlayersThatCandidateDoesntLike; + int32_t m_cClanPlayersThatDontLikeCandidate; + CSteamID m_SteamIDCandidate; +}; +#pragma pack( pop ) + +typedef struct ComputeNewPlayerCompatibilityResult_t_116x ComputeNewPlayerCompatibilityResult_t_116x; +#pragma pack( push, 4 ) +struct ComputeNewPlayerCompatibilityResult_t_116x +{ + uint32_t m_eResult; + int32_t m_cPlayersThatDontLikeCandidate; + int32_t m_cPlayersThatCandidateDoesntLike; + int32_t m_cClanPlayersThatDontLikeCandidate; +}; +#pragma pack( pop ) + +typedef struct ControllerAnalogActionData_t ControllerAnalogActionData_t; +#pragma pack( push, 1 ) +struct ControllerAnalogActionData_t +{ + uint32_t eMode; + float x; + float y; + bool bActive; +}; +#pragma pack( pop ) + +typedef struct ControllerDigitalActionData_t ControllerDigitalActionData_t; +#pragma pack( push, 1 ) +struct ControllerDigitalActionData_t +{ + bool bState; + bool bActive; +}; +#pragma pack( pop ) + +typedef struct ControllerMotionData_t ControllerMotionData_t; +#pragma pack( push, 1 ) +struct ControllerMotionData_t +{ + float rotQuatX; + float rotQuatY; + float rotQuatZ; + float rotQuatW; + float posAccelX; + float posAccelY; + float posAccelZ; + float rotVelX; + float rotVelY; + float rotVelZ; +}; +#pragma pack( pop ) + +typedef struct DlcInstalled_t DlcInstalled_t; +#pragma pack( push, 4 ) +struct DlcInstalled_t +{ + uint32_t m_nAppID; +}; +#pragma pack( pop ) + +typedef struct DownloadClanActivityCountsResult_t DownloadClanActivityCountsResult_t; +#pragma pack( push, 1 ) +struct DownloadClanActivityCountsResult_t +{ + bool m_bSuccess; +}; +#pragma pack( pop ) + +typedef struct DurationControl_t_147 DurationControl_t_147; +#pragma pack( push, 4 ) +struct DurationControl_t_147 +{ + uint32_t m_eResult; + uint32_t m_appid; + bool m_bApplicable; + uint8_t __pad_9[3]; + int32_t m_csecsLast5h; + uint32_t m_progress; + uint32_t m_notification; + int32_t m_csecsToday; + int32_t m_csecsRemaining; +}; +#pragma pack( pop ) + +typedef struct DurationControl_t_145 DurationControl_t_145; +#pragma pack( push, 4 ) +struct DurationControl_t_145 +{ + uint32_t m_eResult; + uint32_t m_appid; + bool m_bApplicable; + uint8_t __pad_9[3]; + int32_t m_csecsLast5h; + uint32_t m_progress; + uint32_t m_notification; +}; +#pragma pack( pop ) + +typedef struct EncryptedAppTicketResponse_t EncryptedAppTicketResponse_t; +#pragma pack( push, 4 ) +struct EncryptedAppTicketResponse_t +{ + uint32_t m_eResult; +}; +#pragma pack( pop ) + +typedef struct EquippedProfileItemsChanged_t EquippedProfileItemsChanged_t; +#pragma pack( push, 1 ) +struct EquippedProfileItemsChanged_t +{ + CSteamID m_steamID; +}; +#pragma pack( pop ) + +typedef struct EquippedProfileItems_t EquippedProfileItems_t; +#pragma pack( push, 4 ) +struct EquippedProfileItems_t +{ + uint32_t m_eResult; + CSteamID m_steamID; + bool m_bHasAnimatedAvatar; + bool m_bHasAvatarFrame; + bool m_bHasProfileModifier; + bool m_bHasProfileBackground; + bool m_bHasMiniProfileBackground; + uint8_t __pad_17[3]; +}; +#pragma pack( pop ) + +typedef struct FavoritesListAccountsUpdated_t FavoritesListAccountsUpdated_t; +#pragma pack( push, 4 ) +struct FavoritesListAccountsUpdated_t +{ + uint32_t m_eResult; +}; +#pragma pack( pop ) + +typedef struct FavoritesListChanged_t_128x FavoritesListChanged_t_128x; +#pragma pack( push, 4 ) +struct FavoritesListChanged_t_128x +{ + uint32_t m_nIP; + uint32_t m_nQueryPort; + uint32_t m_nConnPort; + uint32_t m_nAppID; + uint32_t m_nFlags; + bool m_bAdd; + uint8_t __pad_21[3]; + uint32_t m_unAccountId; +}; +#pragma pack( pop ) + +typedef struct FavoritesListChanged_t_099u FavoritesListChanged_t_099u; +#pragma pack( push, 4 ) +struct FavoritesListChanged_t_099u +{ + uint32_t m_nIP; + uint32_t m_nQueryPort; + uint32_t m_nConnPort; + uint32_t m_nAppID; + uint32_t m_nFlags; + bool m_bAdd; + uint8_t __pad_21[3]; +}; +#pragma pack( pop ) + +typedef struct FilterTextDictionaryChanged_t FilterTextDictionaryChanged_t; +#pragma pack( push, 4 ) +struct FilterTextDictionaryChanged_t +{ + int32_t m_eLanguage; +}; +#pragma pack( pop ) + +typedef struct FloatingGamepadTextInputDismissed_t FloatingGamepadTextInputDismissed_t; +#pragma pack( push, 1 ) +struct FloatingGamepadTextInputDismissed_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct FriendGameInfo_t FriendGameInfo_t; +#pragma pack( push, 4 ) +struct FriendGameInfo_t +{ + CGameID m_gameID; + uint32_t m_unGameIP; + uint16_t m_usGamePort; + uint16_t m_usQueryPort; + CSteamID m_steamIDLobby; +}; +#pragma pack( pop ) + +typedef struct FriendRichPresenceUpdate_t FriendRichPresenceUpdate_t; +#pragma pack( push, 4 ) +struct FriendRichPresenceUpdate_t +{ + CSteamID m_steamIDFriend; + uint32_t m_nAppID; +}; +#pragma pack( pop ) + +typedef struct FriendSessionStateInfo_t FriendSessionStateInfo_t; +#pragma pack( push, 4 ) +struct FriendSessionStateInfo_t +{ + uint32_t m_uiOnlineSessionInstances; + uint8_t m_uiPublishedToFriendsSessionInstance; + uint8_t __pad_5[3]; +}; +#pragma pack( pop ) + +typedef struct FriendsEnumerateFollowingList_t FriendsEnumerateFollowingList_t; +#pragma pack( push, 4 ) +struct FriendsEnumerateFollowingList_t +{ + uint32_t m_eResult; + CSteamID (m_rgSteamID)[50]; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; +}; +#pragma pack( pop ) + +typedef struct FriendsGetFollowerCount_t FriendsGetFollowerCount_t; +#pragma pack( push, 4 ) +struct FriendsGetFollowerCount_t +{ + uint32_t m_eResult; + CSteamID m_steamID; + int32_t m_nCount; +}; +#pragma pack( pop ) + +typedef struct FriendsIsFollowing_t FriendsIsFollowing_t; +#pragma pack( push, 4 ) +struct FriendsIsFollowing_t +{ + uint32_t m_eResult; + CSteamID m_steamID; + bool m_bIsFollowing; + uint8_t __pad_13[3]; +}; +#pragma pack( pop ) + +typedef struct GCMessageAvailable_t GCMessageAvailable_t; +#pragma pack( push, 4 ) +struct GCMessageAvailable_t +{ + uint32_t m_nMessageSize; +}; +#pragma pack( pop ) + +typedef struct GCMessageFailed_t GCMessageFailed_t; +#pragma pack( push, 1 ) +struct GCMessageFailed_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct GSClientAchievementStatus_t GSClientAchievementStatus_t; +#pragma pack( push, 8 ) +struct GSClientAchievementStatus_t +{ + uint64_t m_SteamID; + char (m_pchAchievement)[128]; + bool m_bUnlocked; + uint8_t __pad_137[7]; +}; +#pragma pack( pop ) + +typedef struct GSClientApprove_t_126 GSClientApprove_t_126; +#pragma pack( push, 1 ) +struct GSClientApprove_t_126 +{ + CSteamID m_SteamID; + CSteamID m_OwnerSteamID; +}; +#pragma pack( pop ) + +typedef struct GSClientApprove_t_099u GSClientApprove_t_099u; +#pragma pack( push, 1 ) +struct GSClientApprove_t_099u +{ + CSteamID m_SteamID; +}; +#pragma pack( pop ) + +typedef struct GSClientDeny_t GSClientDeny_t; +#pragma pack( push, 4 ) +struct GSClientDeny_t +{ + CSteamID m_SteamID; + uint32_t m_eDenyReason; + char (m_rgchOptionalText)[128]; +}; +#pragma pack( pop ) + +typedef struct GSClientGroupStatus_t GSClientGroupStatus_t; +#pragma pack( push, 1 ) +struct GSClientGroupStatus_t +{ + CSteamID m_SteamIDUser; + CSteamID m_SteamIDGroup; + bool m_bMember; + bool m_bOfficer; +}; +#pragma pack( pop ) + +typedef struct GSClientKick_t GSClientKick_t; +#pragma pack( push, 4 ) +struct GSClientKick_t +{ + CSteamID m_SteamID; + uint32_t m_eDenyReason; +}; +#pragma pack( pop ) + +typedef struct GSGameplayStats_t GSGameplayStats_t; +#pragma pack( push, 4 ) +struct GSGameplayStats_t +{ + uint32_t m_eResult; + int32_t m_nRank; + uint32_t m_unTotalConnects; + uint32_t m_unTotalMinutesPlayed; +}; +#pragma pack( pop ) + +typedef struct GSPolicyResponse_t GSPolicyResponse_t; +#pragma pack( push, 1 ) +struct GSPolicyResponse_t +{ + uint8_t m_bSecure; +}; +#pragma pack( pop ) + +typedef struct GSStatsReceived_t GSStatsReceived_t; +#pragma pack( push, 4 ) +struct GSStatsReceived_t +{ + uint32_t m_eResult; + CSteamID m_steamIDUser; +}; +#pragma pack( pop ) + +typedef struct GSStatsStored_t GSStatsStored_t; +#pragma pack( push, 4 ) +struct GSStatsStored_t +{ + uint32_t m_eResult; + CSteamID m_steamIDUser; +}; +#pragma pack( pop ) + +typedef struct GSStatsUnloaded_t GSStatsUnloaded_t; +#pragma pack( push, 1 ) +struct GSStatsUnloaded_t +{ + CSteamID m_steamIDUser; +}; +#pragma pack( pop ) + +typedef struct GameConnectedChatJoin_t GameConnectedChatJoin_t; +#pragma pack( push, 1 ) +struct GameConnectedChatJoin_t +{ + CSteamID m_steamIDClanChat; + CSteamID m_steamIDUser; +}; +#pragma pack( pop ) + +typedef struct GameConnectedChatLeave_t GameConnectedChatLeave_t; +#pragma pack( push, 1 ) +struct GameConnectedChatLeave_t +{ + CSteamID m_steamIDClanChat; + CSteamID m_steamIDUser; + bool m_bKicked; + bool m_bDropped; +}; +#pragma pack( pop ) + +typedef struct GameConnectedClanChatMsg_t GameConnectedClanChatMsg_t; +#pragma pack( push, 4 ) +struct GameConnectedClanChatMsg_t +{ + CSteamID m_steamIDClanChat; + CSteamID m_steamIDUser; + int32_t m_iMessageID; +}; +#pragma pack( pop ) + +typedef struct GameConnectedFriendChatMsg_t GameConnectedFriendChatMsg_t; +#pragma pack( push, 4 ) +struct GameConnectedFriendChatMsg_t +{ + CSteamID m_steamIDUser; + int32_t m_iMessageID; +}; +#pragma pack( pop ) + +typedef struct GameLobbyJoinRequested_t GameLobbyJoinRequested_t; +#pragma pack( push, 1 ) +struct GameLobbyJoinRequested_t +{ + CSteamID m_steamIDLobby; + CSteamID m_steamIDFriend; +}; +#pragma pack( pop ) + +typedef struct GameOverlayActivated_t_158 GameOverlayActivated_t_158; +#pragma pack( push, 4 ) +struct GameOverlayActivated_t_158 +{ + uint8_t m_bActive; + bool m_bUserInitiated; + uint8_t __pad_2[2]; + uint32_t m_nAppID; + uint32_t m_dwOverlayPID; +}; +#pragma pack( pop ) + +typedef struct GameOverlayActivated_t_156 GameOverlayActivated_t_156; +#pragma pack( push, 4 ) +struct GameOverlayActivated_t_156 +{ + uint8_t m_bActive; + bool m_bUserInitiated; + uint8_t __pad_2[2]; + uint32_t m_nAppID; +}; +#pragma pack( pop ) + +typedef struct GameOverlayActivated_t_099u GameOverlayActivated_t_099u; +#pragma pack( push, 1 ) +struct GameOverlayActivated_t_099u +{ + uint8_t m_bActive; +}; +#pragma pack( pop ) + +typedef struct GameRichPresenceJoinRequested_t GameRichPresenceJoinRequested_t; +#pragma pack( push, 1 ) +struct GameRichPresenceJoinRequested_t +{ + CSteamID m_steamIDFriend; + char (m_rgchConnect)[256]; +}; +#pragma pack( pop ) + +typedef struct GameServerChangeRequested_t GameServerChangeRequested_t; +#pragma pack( push, 1 ) +struct GameServerChangeRequested_t +{ + char (m_rgchServer)[64]; + char (m_rgchPassword)[64]; +}; +#pragma pack( pop ) + +typedef struct GameStatsSessionClosed_t GameStatsSessionClosed_t; +#pragma pack( push, 8 ) +struct GameStatsSessionClosed_t +{ + uint64_t m_ulSessionID; + uint32_t m_eResult; + uint8_t __pad_12[4]; +}; +#pragma pack( pop ) + +typedef struct GameStatsSessionIssued_t GameStatsSessionIssued_t; +#pragma pack( push, 8 ) +struct GameStatsSessionIssued_t +{ + uint64_t m_ulSessionID; + uint32_t m_eResult; + bool m_bCollectingAny; + bool m_bCollectingDetails; + uint8_t __pad_14[2]; +}; +#pragma pack( pop ) + +typedef struct GameWebCallback_t GameWebCallback_t; +#pragma pack( push, 1 ) +struct GameWebCallback_t +{ + char (m_szURL)[256]; +}; +#pragma pack( pop ) + +typedef struct GamepadTextInputDismissed_t_156 GamepadTextInputDismissed_t_156; +#pragma pack( push, 4 ) +struct GamepadTextInputDismissed_t_156 +{ + bool m_bSubmitted; + uint8_t __pad_1[3]; + uint32_t m_unSubmittedText; + uint32_t m_unAppID; +}; +#pragma pack( pop ) + +typedef struct GamepadTextInputDismissed_t_121 GamepadTextInputDismissed_t_121; +#pragma pack( push, 4 ) +struct GamepadTextInputDismissed_t_121 +{ + bool m_bSubmitted; + uint8_t __pad_1[3]; + uint32_t m_unSubmittedText; +}; +#pragma pack( pop ) + +typedef struct GetAuthSessionTicketResponse_t GetAuthSessionTicketResponse_t; +#pragma pack( push, 4 ) +struct GetAuthSessionTicketResponse_t +{ + uint32_t m_hAuthTicket; + uint32_t m_eResult; +}; +#pragma pack( pop ) + +typedef struct GetOPFSettingsResult_t GetOPFSettingsResult_t; +#pragma pack( push, 4 ) +struct GetOPFSettingsResult_t +{ + uint32_t m_eResult; + uint32_t m_unVideoAppID; +}; +#pragma pack( pop ) + +typedef struct GetTicketForWebApiResponse_t GetTicketForWebApiResponse_t; +#pragma pack( push, 4 ) +struct GetTicketForWebApiResponse_t +{ + uint32_t m_hAuthTicket; + uint32_t m_eResult; + int32_t m_cubTicket; + uint8_t (m_rgubTicket)[2560]; +}; +#pragma pack( pop ) + +typedef struct GetUserItemVoteResult_t GetUserItemVoteResult_t; +#pragma pack( push, 8 ) +struct GetUserItemVoteResult_t +{ + uint64_t m_nPublishedFileId; + uint32_t m_eResult; + bool m_bVotedUp; + bool m_bVotedDown; + bool m_bVoteSkipped; + uint8_t __pad_15[1]; +}; +#pragma pack( pop ) + +typedef struct GetVideoURLResult_t GetVideoURLResult_t; +#pragma pack( push, 4 ) +struct GetVideoURLResult_t +{ + uint32_t m_eResult; + uint32_t m_unVideoAppID; + char (m_rgchURL)[256]; +}; +#pragma pack( pop ) + +typedef struct GlobalAchievementPercentagesReady_t GlobalAchievementPercentagesReady_t; +#pragma pack( push, 8 ) +struct GlobalAchievementPercentagesReady_t +{ + uint64_t m_nGameID; + uint32_t m_eResult; + uint8_t __pad_12[4]; +}; +#pragma pack( pop ) + +typedef struct GlobalStatsReceived_t GlobalStatsReceived_t; +#pragma pack( push, 8 ) +struct GlobalStatsReceived_t +{ + uint64_t m_nGameID; + uint32_t m_eResult; + uint8_t __pad_12[4]; +}; +#pragma pack( pop ) + +typedef struct HTML_BrowserReady_t HTML_BrowserReady_t; +#pragma pack( push, 4 ) +struct HTML_BrowserReady_t +{ + uint32_t unBrowserHandle; +}; +#pragma pack( pop ) + +typedef struct HTML_BrowserRestarted_t HTML_BrowserRestarted_t; +#pragma pack( push, 4 ) +struct HTML_BrowserRestarted_t +{ + uint32_t unBrowserHandle; + uint32_t unOldBrowserHandle; +}; +#pragma pack( pop ) + +typedef struct HTML_CanGoBackAndForward_t HTML_CanGoBackAndForward_t; +#pragma pack( push, 4 ) +struct HTML_CanGoBackAndForward_t +{ + uint32_t unBrowserHandle; + bool bCanGoBack; + bool bCanGoForward; + uint8_t __pad_6[2]; +}; +#pragma pack( pop ) + +typedef struct HTML_CloseBrowser_t HTML_CloseBrowser_t; +#pragma pack( push, 4 ) +struct HTML_CloseBrowser_t +{ + uint32_t unBrowserHandle; +}; +#pragma pack( pop ) + +typedef struct HTML_HidePopup_t HTML_HidePopup_t; +#pragma pack( push, 4 ) +struct HTML_HidePopup_t +{ + uint32_t unBrowserHandle; +}; +#pragma pack( pop ) + +typedef struct HTML_HideToolTip_t HTML_HideToolTip_t; +#pragma pack( push, 4 ) +struct HTML_HideToolTip_t +{ + uint32_t unBrowserHandle; +}; +#pragma pack( pop ) + +typedef struct HTML_HorizontalScroll_t HTML_HorizontalScroll_t; +#pragma pack( push, 4 ) +struct HTML_HorizontalScroll_t +{ + uint32_t unBrowserHandle; + uint32_t unScrollMax; + uint32_t unScrollCurrent; + float flPageScale; + bool bVisible; + uint8_t __pad_17[3]; + uint32_t unPageSize; +}; +#pragma pack( pop ) + +typedef struct HTML_SearchResults_t HTML_SearchResults_t; +#pragma pack( push, 4 ) +struct HTML_SearchResults_t +{ + uint32_t unBrowserHandle; + uint32_t unResults; + uint32_t unCurrentMatch; +}; +#pragma pack( pop ) + +typedef struct HTML_SetCursor_t HTML_SetCursor_t; +#pragma pack( push, 4 ) +struct HTML_SetCursor_t +{ + uint32_t unBrowserHandle; + uint32_t eMouseCursor; +}; +#pragma pack( pop ) + +typedef struct HTML_ShowPopup_t HTML_ShowPopup_t; +#pragma pack( push, 4 ) +struct HTML_ShowPopup_t +{ + uint32_t unBrowserHandle; +}; +#pragma pack( pop ) + +typedef struct HTML_SizePopup_t HTML_SizePopup_t; +#pragma pack( push, 4 ) +struct HTML_SizePopup_t +{ + uint32_t unBrowserHandle; + uint32_t unX; + uint32_t unY; + uint32_t unWide; + uint32_t unTall; +}; +#pragma pack( pop ) + +typedef struct HTML_VerticalScroll_t HTML_VerticalScroll_t; +#pragma pack( push, 4 ) +struct HTML_VerticalScroll_t +{ + uint32_t unBrowserHandle; + uint32_t unScrollMax; + uint32_t unScrollCurrent; + float flPageScale; + bool bVisible; + uint8_t __pad_17[3]; + uint32_t unPageSize; +}; +#pragma pack( pop ) + +typedef struct IPCFailure_t IPCFailure_t; +#pragma pack( push, 1 ) +struct IPCFailure_t +{ + uint8_t m_eFailureType; +}; +#pragma pack( pop ) + +typedef struct IPCountry_t IPCountry_t; +#pragma pack( push, 1 ) +struct IPCountry_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct InputAnalogActionData_t InputAnalogActionData_t; +#pragma pack( push, 1 ) +struct InputAnalogActionData_t +{ + uint32_t eMode; + float x; + float y; + bool bActive; +}; +#pragma pack( pop ) + +typedef struct InputDigitalActionData_t InputDigitalActionData_t; +#pragma pack( push, 1 ) +struct InputDigitalActionData_t +{ + bool bState; + bool bActive; +}; +#pragma pack( pop ) + +typedef struct InputMotionDataV2_t InputMotionDataV2_t; +#pragma pack( push, 1 ) +struct InputMotionDataV2_t +{ + float driftCorrectedQuatX; + float driftCorrectedQuatY; + float driftCorrectedQuatZ; + float driftCorrectedQuatW; + float sensorFusionQuatX; + float sensorFusionQuatY; + float sensorFusionQuatZ; + float sensorFusionQuatW; + float deferredSensorFusionQuatX; + float deferredSensorFusionQuatY; + float deferredSensorFusionQuatZ; + float deferredSensorFusionQuatW; + float gravityX; + float gravityY; + float gravityZ; + float degreesPerSecondX; + float degreesPerSecondY; + float degreesPerSecondZ; +}; +#pragma pack( pop ) + +typedef struct InputMotionData_t InputMotionData_t; +#pragma pack( push, 1 ) +struct InputMotionData_t +{ + float rotQuatX; + float rotQuatY; + float rotQuatZ; + float rotQuatW; + float posAccelX; + float posAccelY; + float posAccelZ; + float rotVelX; + float rotVelY; + float rotVelZ; +}; +#pragma pack( pop ) + +typedef struct JoinClanChatRoomCompletionResult_t JoinClanChatRoomCompletionResult_t; +#pragma pack( push, 4 ) +struct JoinClanChatRoomCompletionResult_t +{ + CSteamID m_steamIDClanChat; + uint32_t m_eChatRoomEnterResponse; +}; +#pragma pack( pop ) + +typedef struct LeaderboardFindResult_t LeaderboardFindResult_t; +#pragma pack( push, 8 ) +struct LeaderboardFindResult_t +{ + uint64_t m_hSteamLeaderboard; + uint8_t m_bLeaderboardFound; + uint8_t __pad_9[7]; +}; +#pragma pack( pop ) + +typedef struct LeaderboardScoresDownloaded_t LeaderboardScoresDownloaded_t; +#pragma pack( push, 8 ) +struct LeaderboardScoresDownloaded_t +{ + uint64_t m_hSteamLeaderboard; + uint64_t m_hSteamLeaderboardEntries; + int32_t m_cEntryCount; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +typedef struct LicensesUpdated_t LicensesUpdated_t; +#pragma pack( push, 1 ) +struct LicensesUpdated_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct LobbyChatMsg_t LobbyChatMsg_t; +#pragma pack( push, 8 ) +struct LobbyChatMsg_t +{ + uint64_t m_ulSteamIDLobby; + uint64_t m_ulSteamIDUser; + uint8_t m_eChatEntryType; + uint8_t __pad_17[3]; + uint32_t m_iChatID; +}; +#pragma pack( pop ) + +typedef struct LobbyChatUpdate_t LobbyChatUpdate_t; +#pragma pack( push, 8 ) +struct LobbyChatUpdate_t +{ + uint64_t m_ulSteamIDLobby; + uint64_t m_ulSteamIDUserChanged; + uint64_t m_ulSteamIDMakingChange; + uint32_t m_rgfChatMemberStateChange; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +typedef struct LobbyClosing_t LobbyClosing_t; +#pragma pack( push, 8 ) +struct LobbyClosing_t +{ + uint64_t m_ulSteamIDLobby; +}; +#pragma pack( pop ) + +typedef struct LobbyDataUpdate_t_111x LobbyDataUpdate_t_111x; +#pragma pack( push, 8 ) +struct LobbyDataUpdate_t_111x +{ + uint64_t m_ulSteamIDLobby; + uint64_t m_ulSteamIDMember; + uint8_t m_bSuccess; + uint8_t __pad_17[7]; +}; +#pragma pack( pop ) + +typedef struct LobbyDataUpdate_t_099u LobbyDataUpdate_t_099u; +#pragma pack( push, 8 ) +struct LobbyDataUpdate_t_099u +{ + uint64_t m_ulSteamIDLobby; + uint64_t m_ulSteamIDMember; +}; +#pragma pack( pop ) + +typedef struct LobbyEnter_t LobbyEnter_t; +#pragma pack( push, 8 ) +struct LobbyEnter_t +{ + uint64_t m_ulSteamIDLobby; + uint32_t m_rgfChatPermissions; + bool m_bLocked; + uint8_t __pad_13[3]; + uint32_t m_EChatRoomEnterResponse; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +typedef struct LobbyGameCreated_t LobbyGameCreated_t; +#pragma pack( push, 8 ) +struct LobbyGameCreated_t +{ + uint64_t m_ulSteamIDLobby; + uint64_t m_ulSteamIDGameServer; + uint32_t m_unIP; + uint16_t m_usPort; + uint8_t __pad_22[2]; +}; +#pragma pack( pop ) + +typedef struct LobbyInvite_t_112x LobbyInvite_t_112x; +#pragma pack( push, 8 ) +struct LobbyInvite_t_112x +{ + uint64_t m_ulSteamIDUser; + uint64_t m_ulSteamIDLobby; + uint64_t m_ulGameID; +}; +#pragma pack( pop ) + +typedef struct LobbyInvite_t_099u LobbyInvite_t_099u; +#pragma pack( push, 8 ) +struct LobbyInvite_t_099u +{ + uint64_t m_ulSteamIDUser; + uint64_t m_ulSteamIDLobby; +}; +#pragma pack( pop ) + +typedef struct LobbyKicked_t_106 LobbyKicked_t_106; +#pragma pack( push, 8 ) +struct LobbyKicked_t_106 +{ + uint64_t m_ulSteamIDLobby; + uint64_t m_ulSteamIDAdmin; + uint8_t m_bKickedDueToDisconnect; + uint8_t __pad_17[7]; +}; +#pragma pack( pop ) + +typedef struct LobbyKicked_t_099u LobbyKicked_t_099u; +#pragma pack( push, 8 ) +struct LobbyKicked_t_099u +{ + uint64_t m_ulSteamIDLobby; + uint64_t m_ulSteamIDAdmin; +}; +#pragma pack( pop ) + +typedef struct LobbyMatchList_t LobbyMatchList_t; +#pragma pack( push, 4 ) +struct LobbyMatchList_t +{ + uint32_t m_nLobbiesMatching; +}; +#pragma pack( pop ) + +typedef struct LowBatteryPower_t LowBatteryPower_t; +#pragma pack( push, 1 ) +struct LowBatteryPower_t +{ + uint8_t m_nMinutesBatteryLeft; +}; +#pragma pack( pop ) + +typedef struct MarketEligibilityResponse_t MarketEligibilityResponse_t; +#pragma pack( push, 4 ) +struct MarketEligibilityResponse_t +{ + bool m_bAllowed; + uint8_t __pad_1[3]; + uint32_t m_eNotAllowedReason; + uint32_t m_rtAllowedAtTime; + int32_t m_cdaySteamGuardRequiredDays; + int32_t m_cdayNewDeviceCooldown; +}; +#pragma pack( pop ) + +typedef struct MatchMakingKeyValuePair_t MatchMakingKeyValuePair_t; +#pragma pack( push, 1 ) +struct MatchMakingKeyValuePair_t +{ + char (m_szKey)[256]; + char (m_szValue)[256]; +}; +#pragma pack( pop ) + +typedef struct MusicPlayerRemoteToFront_t MusicPlayerRemoteToFront_t; +#pragma pack( push, 1 ) +struct MusicPlayerRemoteToFront_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct MusicPlayerRemoteWillActivate_t MusicPlayerRemoteWillActivate_t; +#pragma pack( push, 1 ) +struct MusicPlayerRemoteWillActivate_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct MusicPlayerRemoteWillDeactivate_t MusicPlayerRemoteWillDeactivate_t; +#pragma pack( push, 1 ) +struct MusicPlayerRemoteWillDeactivate_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct MusicPlayerSelectsPlaylistEntry_t MusicPlayerSelectsPlaylistEntry_t; +#pragma pack( push, 4 ) +struct MusicPlayerSelectsPlaylistEntry_t +{ + int32_t nID; +}; +#pragma pack( pop ) + +typedef struct MusicPlayerSelectsQueueEntry_t MusicPlayerSelectsQueueEntry_t; +#pragma pack( push, 4 ) +struct MusicPlayerSelectsQueueEntry_t +{ + int32_t nID; +}; +#pragma pack( pop ) + +typedef struct MusicPlayerWantsLooped_t MusicPlayerWantsLooped_t; +#pragma pack( push, 1 ) +struct MusicPlayerWantsLooped_t +{ + bool m_bLooped; +}; +#pragma pack( pop ) + +typedef struct MusicPlayerWantsPause_t MusicPlayerWantsPause_t; +#pragma pack( push, 1 ) +struct MusicPlayerWantsPause_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct MusicPlayerWantsPlayNext_t MusicPlayerWantsPlayNext_t; +#pragma pack( push, 1 ) +struct MusicPlayerWantsPlayNext_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct MusicPlayerWantsPlayPrevious_t MusicPlayerWantsPlayPrevious_t; +#pragma pack( push, 1 ) +struct MusicPlayerWantsPlayPrevious_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct MusicPlayerWantsPlay_t MusicPlayerWantsPlay_t; +#pragma pack( push, 1 ) +struct MusicPlayerWantsPlay_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct MusicPlayerWantsPlayingRepeatStatus_t MusicPlayerWantsPlayingRepeatStatus_t; +#pragma pack( push, 4 ) +struct MusicPlayerWantsPlayingRepeatStatus_t +{ + int32_t m_nPlayingRepeatStatus; +}; +#pragma pack( pop ) + +typedef struct MusicPlayerWantsShuffled_t MusicPlayerWantsShuffled_t; +#pragma pack( push, 1 ) +struct MusicPlayerWantsShuffled_t +{ + bool m_bShuffled; +}; +#pragma pack( pop ) + +typedef struct MusicPlayerWantsVolume_t MusicPlayerWantsVolume_t; +#pragma pack( push, 4 ) +struct MusicPlayerWantsVolume_t +{ + float m_flNewVolume; +}; +#pragma pack( pop ) + +typedef struct MusicPlayerWillQuit_t MusicPlayerWillQuit_t; +#pragma pack( push, 1 ) +struct MusicPlayerWillQuit_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct NameHistoryResponse_t NameHistoryResponse_t; +#pragma pack( push, 4 ) +struct NameHistoryResponse_t +{ + int32_t m_cSuccessfulLookups; + int32_t m_cFailedLookups; +}; +#pragma pack( pop ) + +typedef struct NewLaunchQueryParameters_t NewLaunchQueryParameters_t; +#pragma pack( push, 1 ) +struct NewLaunchQueryParameters_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct NewUrlLaunchParameters_t NewUrlLaunchParameters_t; +#pragma pack( push, 1 ) +struct NewUrlLaunchParameters_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct NumberOfCurrentPlayers_t NumberOfCurrentPlayers_t; +#pragma pack( push, 4 ) +struct NumberOfCurrentPlayers_t +{ + uint8_t m_bSuccess; + uint8_t __pad_1[3]; + int32_t m_cPlayers; +}; +#pragma pack( pop ) + +typedef struct OverlayBrowserProtocolNavigation_t OverlayBrowserProtocolNavigation_t; +#pragma pack( push, 1 ) +struct OverlayBrowserProtocolNavigation_t +{ + char (rgchURI)[1024]; +}; +#pragma pack( pop ) + +typedef struct P2PSessionConnectFail_t P2PSessionConnectFail_t; +#pragma pack( push, 1 ) +struct P2PSessionConnectFail_t +{ + CSteamID m_steamIDRemote; + uint8_t m_eP2PSessionError; +}; +#pragma pack( pop ) + +typedef struct P2PSessionRequest_t P2PSessionRequest_t; +#pragma pack( push, 1 ) +struct P2PSessionRequest_t +{ + CSteamID m_steamIDRemote; +}; +#pragma pack( pop ) + +typedef struct P2PSessionState_t P2PSessionState_t; +#pragma pack( push, 4 ) +struct P2PSessionState_t +{ + uint8_t m_bConnectionActive; + uint8_t m_bConnecting; + uint8_t m_eP2PSessionError; + uint8_t m_bUsingRelay; + int32_t m_nBytesQueuedForSend; + int32_t m_nPacketsQueuedForSend; + uint32_t m_nRemoteIP; + uint16_t m_nRemotePort; + uint8_t __pad_18[2]; +}; +#pragma pack( pop ) + +typedef struct PSNGameBootInviteResult_t PSNGameBootInviteResult_t; +#pragma pack( push, 1 ) +struct PSNGameBootInviteResult_t +{ + bool m_bGameBootInviteExists; + CSteamID m_steamIDLobby; +}; +#pragma pack( pop ) + +typedef struct PersonaStateChange_t PersonaStateChange_t; +#pragma pack( push, 8 ) +struct PersonaStateChange_t +{ + uint64_t m_ulSteamID; + int32_t m_nChangeFlags; + uint8_t __pad_12[4]; +}; +#pragma pack( pop ) + +typedef struct PlaybackStatusHasChanged_t PlaybackStatusHasChanged_t; +#pragma pack( push, 1 ) +struct PlaybackStatusHasChanged_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct RegisterActivationCodeResponse_t RegisterActivationCodeResponse_t; +#pragma pack( push, 4 ) +struct RegisterActivationCodeResponse_t +{ + uint32_t m_eResult; + uint32_t m_unPackageRegistered; +}; +#pragma pack( pop ) + +typedef struct RemoteStorageAppSyncStatusCheck_t RemoteStorageAppSyncStatusCheck_t; +#pragma pack( push, 4 ) +struct RemoteStorageAppSyncStatusCheck_t +{ + uint32_t m_nAppID; + uint32_t m_eResult; +}; +#pragma pack( pop ) + +typedef struct RemoteStorageAppSyncedClient_t RemoteStorageAppSyncedClient_t; +#pragma pack( push, 4 ) +struct RemoteStorageAppSyncedClient_t +{ + uint32_t m_nAppID; + uint32_t m_eResult; + int32_t m_unNumDownloads; +}; +#pragma pack( pop ) + +typedef struct RemoteStorageAppSyncedServer_t RemoteStorageAppSyncedServer_t; +#pragma pack( push, 4 ) +struct RemoteStorageAppSyncedServer_t +{ + uint32_t m_nAppID; + uint32_t m_eResult; + int32_t m_unNumUploads; +}; +#pragma pack( pop ) + +typedef struct RemoteStorageConflictResolution_t RemoteStorageConflictResolution_t; +#pragma pack( push, 4 ) +struct RemoteStorageConflictResolution_t +{ + uint32_t m_nAppID; + uint32_t m_eResult; +}; +#pragma pack( pop ) + +typedef struct RemoteStorageEnumeratePublishedFilesByUserActionResult_t RemoteStorageEnumeratePublishedFilesByUserActionResult_t; +#pragma pack( push, 8 ) +struct RemoteStorageEnumeratePublishedFilesByUserActionResult_t +{ + uint32_t m_eResult; + uint32_t m_eAction; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + uint64_t (m_rgPublishedFileId)[50]; + uint32_t (m_rgRTimeUpdated)[50]; +}; +#pragma pack( pop ) + +typedef struct RemoteStorageFileReadAsyncComplete_t RemoteStorageFileReadAsyncComplete_t; +#pragma pack( push, 8 ) +struct RemoteStorageFileReadAsyncComplete_t +{ + uint64_t m_hFileReadAsync; + uint32_t m_eResult; + uint32_t m_nOffset; + uint32_t m_cubRead; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +typedef struct RemoteStorageFileWriteAsyncComplete_t RemoteStorageFileWriteAsyncComplete_t; +#pragma pack( push, 4 ) +struct RemoteStorageFileWriteAsyncComplete_t +{ + uint32_t m_eResult; +}; +#pragma pack( pop ) + +typedef struct RemoteStorageLocalFileChange_t RemoteStorageLocalFileChange_t; +#pragma pack( push, 1 ) +struct RemoteStorageLocalFileChange_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct RemoteStoragePublishFileProgress_t RemoteStoragePublishFileProgress_t; +#pragma pack( push, 8 ) +struct RemoteStoragePublishFileProgress_t +{ + double m_dPercentFile; + bool m_bPreview; + uint8_t __pad_9[7]; +}; +#pragma pack( pop ) + +typedef struct RemoteStoragePublishedFileDeleted_t RemoteStoragePublishedFileDeleted_t; +#pragma pack( push, 8 ) +struct RemoteStoragePublishedFileDeleted_t +{ + uint64_t m_nPublishedFileId; + uint32_t m_nAppID; + uint8_t __pad_12[4]; +}; +#pragma pack( pop ) + +typedef struct RemoteStoragePublishedFileSubscribed_t RemoteStoragePublishedFileSubscribed_t; +#pragma pack( push, 8 ) +struct RemoteStoragePublishedFileSubscribed_t +{ + uint64_t m_nPublishedFileId; + uint32_t m_nAppID; + uint8_t __pad_12[4]; +}; +#pragma pack( pop ) + +typedef struct RemoteStoragePublishedFileUnsubscribed_t RemoteStoragePublishedFileUnsubscribed_t; +#pragma pack( push, 8 ) +struct RemoteStoragePublishedFileUnsubscribed_t +{ + uint64_t m_nPublishedFileId; + uint32_t m_nAppID; + uint8_t __pad_12[4]; +}; +#pragma pack( pop ) + +typedef struct RequestFriendsLobbiesResponse_t RequestFriendsLobbiesResponse_t; +#pragma pack( push, 8 ) +struct RequestFriendsLobbiesResponse_t +{ + uint64_t m_ulSteamIDFriend; + uint64_t m_ulSteamIDLobby; + int32_t m_cResultIndex; + int32_t m_cResultsTotal; +}; +#pragma pack( pop ) + +typedef struct ReservationNotificationCallback_t ReservationNotificationCallback_t; +#pragma pack( push, 8 ) +struct ReservationNotificationCallback_t +{ + uint64_t m_ulBeaconID; + CSteamID m_steamIDJoiner; +}; +#pragma pack( pop ) + +typedef struct ScreenshotReady_t ScreenshotReady_t; +#pragma pack( push, 4 ) +struct ScreenshotReady_t +{ + uint32_t m_hLocal; + uint32_t m_eResult; +}; +#pragma pack( pop ) + +typedef struct ScreenshotRequested_t ScreenshotRequested_t; +#pragma pack( push, 1 ) +struct ScreenshotRequested_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct SearchForGameProgressCallback_t SearchForGameProgressCallback_t; +#pragma pack( push, 8 ) +struct SearchForGameProgressCallback_t +{ + uint64_t m_ullSearchID; + uint32_t m_eResult; + CSteamID m_lobbyID; + CSteamID m_steamIDEndedSearch; + int32_t m_nSecondsRemainingEstimate; + int32_t m_cPlayersSearching; + uint8_t __pad_36[4]; +}; +#pragma pack( pop ) + +typedef struct SearchForGameResultCallback_t SearchForGameResultCallback_t; +#pragma pack( push, 8 ) +struct SearchForGameResultCallback_t +{ + uint64_t m_ullSearchID; + uint32_t m_eResult; + int32_t m_nCountPlayersInGame; + int32_t m_nCountAcceptedGame; + CSteamID m_steamIDHost; + bool m_bFinalCallback; + uint8_t __pad_29[3]; +}; +#pragma pack( pop ) + +typedef struct SetPersonaNameResponse_t SetPersonaNameResponse_t; +#pragma pack( push, 4 ) +struct SetPersonaNameResponse_t +{ + bool m_bSuccess; + bool m_bLocalSuccess; + uint8_t __pad_2[2]; + uint32_t m_result; +}; +#pragma pack( pop ) + +typedef struct SetUserItemVoteResult_t SetUserItemVoteResult_t; +#pragma pack( push, 8 ) +struct SetUserItemVoteResult_t +{ + uint64_t m_nPublishedFileId; + uint32_t m_eResult; + bool m_bVoteUp; + uint8_t __pad_13[3]; +}; +#pragma pack( pop ) + +typedef struct SocketStatusCallback_t SocketStatusCallback_t; +#pragma pack( push, 4 ) +struct SocketStatusCallback_t +{ + uint32_t m_hSocket; + uint32_t m_hListenSocket; + CSteamID m_steamIDRemote; + int32_t m_eSNetSocketState; +}; +#pragma pack( pop ) + +typedef struct StartPlaytimeTrackingResult_t StartPlaytimeTrackingResult_t; +#pragma pack( push, 4 ) +struct StartPlaytimeTrackingResult_t +{ + uint32_t m_eResult; +}; +#pragma pack( pop ) + +typedef struct SteamAPICallCompleted_t_137 SteamAPICallCompleted_t_137; +#pragma pack( push, 8 ) +struct SteamAPICallCompleted_t_137 +{ + uint64_t m_hAsyncCall; + int32_t m_iCallback; + uint32_t m_cubParam; +}; +#pragma pack( pop ) + +typedef struct SteamAPICallCompleted_t_102x SteamAPICallCompleted_t_102x; +#pragma pack( push, 8 ) +struct SteamAPICallCompleted_t_102x +{ + uint64_t m_hAsyncCall; +}; +#pragma pack( pop ) + +typedef struct SteamAppInstalled_t_152 SteamAppInstalled_t_152; +#pragma pack( push, 4 ) +struct SteamAppInstalled_t_152 +{ + uint32_t m_nAppID; + int32_t m_iInstallFolderIndex; +}; +#pragma pack( pop ) + +typedef struct SteamAppInstalled_t_128x SteamAppInstalled_t_128x; +#pragma pack( push, 4 ) +struct SteamAppInstalled_t_128x +{ + uint32_t m_nAppID; +}; +#pragma pack( pop ) + +typedef struct SteamAppUninstalled_t_152 SteamAppUninstalled_t_152; +#pragma pack( push, 4 ) +struct SteamAppUninstalled_t_152 +{ + uint32_t m_nAppID; + int32_t m_iInstallFolderIndex; +}; +#pragma pack( pop ) + +typedef struct SteamAppUninstalled_t_128x SteamAppUninstalled_t_128x; +#pragma pack( push, 4 ) +struct SteamAppUninstalled_t_128x +{ + uint32_t m_nAppID; +}; +#pragma pack( pop ) + +typedef struct SteamCallback_t SteamCallback_t; +#pragma pack( push, 1 ) +struct SteamCallback_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct SteamControllerState001_t SteamControllerState001_t; +#pragma pack( push, 1 ) +struct SteamControllerState001_t +{ + uint32_t unPacketNum; + uint64_t ulButtons; + int16_t sLeftPadX; + int16_t sLeftPadY; + int16_t sRightPadX; + int16_t sRightPadY; +}; +#pragma pack( pop ) + +typedef struct SteamControllerState_t SteamControllerState_t; +#pragma pack( push, 1 ) +struct SteamControllerState_t +{ + uint32_t unPacketNum; + uint64_t ulButtons; + int16_t sLeftPadX; + int16_t sLeftPadY; + int16_t sRightPadX; + int16_t sRightPadY; +}; +#pragma pack( pop ) + +typedef struct SteamInputActionEvent_t SteamInputActionEvent_t; +#pragma pack( push, 1 ) +struct SteamInputActionEvent_t +{ + uint64_t controllerHandle; + uint32_t eEventType; + struct { uint8_t _[21]; } x; +}; +#pragma pack( pop ) + +typedef struct SteamInputDeviceConnected_t SteamInputDeviceConnected_t; +#pragma pack( push, 8 ) +struct SteamInputDeviceConnected_t +{ + uint64_t m_ulConnectedDeviceHandle; +}; +#pragma pack( pop ) + +typedef struct SteamInputDeviceDisconnected_t SteamInputDeviceDisconnected_t; +#pragma pack( push, 8 ) +struct SteamInputDeviceDisconnected_t +{ + uint64_t m_ulDisconnectedDeviceHandle; +}; +#pragma pack( pop ) + +typedef struct SteamInventoryDefinitionUpdate_t SteamInventoryDefinitionUpdate_t; +#pragma pack( push, 1 ) +struct SteamInventoryDefinitionUpdate_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct SteamInventoryEligiblePromoItemDefIDs_t SteamInventoryEligiblePromoItemDefIDs_t; +#pragma pack( push, 4 ) +struct SteamInventoryEligiblePromoItemDefIDs_t +{ + uint32_t m_result; + CSteamID m_steamID; + int32_t m_numEligiblePromoItemDefs; + bool m_bCachedData; + uint8_t __pad_17[3]; +}; +#pragma pack( pop ) + +typedef struct SteamInventoryFullUpdate_t SteamInventoryFullUpdate_t; +#pragma pack( push, 4 ) +struct SteamInventoryFullUpdate_t +{ + int32_t m_handle; +}; +#pragma pack( pop ) + +typedef struct SteamInventoryRequestPricesResult_t SteamInventoryRequestPricesResult_t; +#pragma pack( push, 4 ) +struct SteamInventoryRequestPricesResult_t +{ + uint32_t m_result; + char (m_rgchCurrency)[4]; +}; +#pragma pack( pop ) + +typedef struct SteamInventoryResultReady_t SteamInventoryResultReady_t; +#pragma pack( push, 4 ) +struct SteamInventoryResultReady_t +{ + int32_t m_handle; + uint32_t m_result; +}; +#pragma pack( pop ) + +typedef struct SteamItemDetails_t SteamItemDetails_t; +#pragma pack( push, 8 ) +struct SteamItemDetails_t +{ + uint64_t m_itemId; + int32_t m_iDefinition; + uint16_t m_unQuantity; + uint16_t m_unFlags; +}; +#pragma pack( pop ) + +typedef struct SteamNetAuthenticationStatus_t SteamNetAuthenticationStatus_t; +#pragma pack( push, 4 ) +struct SteamNetAuthenticationStatus_t +{ + uint32_t m_eAvail; + char (m_debugMsg)[256]; +}; +#pragma pack( pop ) + +typedef struct SteamNetConnectionRealTimeLaneStatus_t SteamNetConnectionRealTimeLaneStatus_t; +#pragma pack( push, 8 ) +struct SteamNetConnectionRealTimeLaneStatus_t +{ + int32_t m_cbPendingUnreliable; + int32_t m_cbPendingReliable; + int32_t m_cbSentUnackedReliable; + int32_t _reservePad1; + int64_t m_usecQueueTime; + uint32_t (reserved)[10]; +}; +#pragma pack( pop ) + +typedef struct SteamNetConnectionRealTimeStatus_t SteamNetConnectionRealTimeStatus_t; +#pragma pack( push, 8 ) +struct SteamNetConnectionRealTimeStatus_t +{ + uint32_t m_eState; + int32_t m_nPing; + float m_flConnectionQualityLocal; + float m_flConnectionQualityRemote; + float m_flOutPacketsPerSec; + float m_flOutBytesPerSec; + float m_flInPacketsPerSec; + float m_flInBytesPerSec; + int32_t m_nSendRateBytesPerSecond; + int32_t m_cbPendingUnreliable; + int32_t m_cbPendingReliable; + int32_t m_cbSentUnackedReliable; + int64_t m_usecQueueTime; + uint32_t (reserved)[16]; +}; +#pragma pack( pop ) + +typedef struct SteamNetworkPingLocation_t SteamNetworkPingLocation_t; +#pragma pack( push, 1 ) +struct SteamNetworkPingLocation_t +{ + uint8_t (m_data)[512]; +}; +#pragma pack( pop ) + +typedef struct SteamNetworkingConfigValue_t SteamNetworkingConfigValue_t; +#pragma pack( push, 8 ) +struct SteamNetworkingConfigValue_t +{ + uint32_t m_eValue; + uint32_t m_eDataType; + struct { uint8_t _[8]; } m_val; +}; +#pragma pack( pop ) + +typedef struct SteamNetworkingFakeIPResult_t SteamNetworkingFakeIPResult_t; +#pragma pack( push, 4 ) +struct SteamNetworkingFakeIPResult_t +{ + uint32_t m_eResult; + SteamNetworkingIdentity_144 m_identity; + uint32_t m_unIP; + uint16_t (m_unPorts)[8]; +}; +#pragma pack( pop ) + +typedef struct SteamNetworkingMessagesSessionFailed_t_153a SteamNetworkingMessagesSessionFailed_t_153a; +#pragma pack( push, 1 ) +struct SteamNetworkingMessagesSessionFailed_t_153a +{ + SteamNetConnectionInfo_t_153a m_info; +}; +#pragma pack( pop ) + +typedef struct SteamNetworkingMessagesSessionFailed_t_150 SteamNetworkingMessagesSessionFailed_t_150; +#pragma pack( push, 1 ) +struct SteamNetworkingMessagesSessionFailed_t_150 +{ + SteamNetConnectionInfo_t_144 m_info; +}; +#pragma pack( pop ) + +typedef struct SteamNetworkingMessagesSessionFailed_t_151 SteamNetworkingMessagesSessionFailed_t_151; +#pragma pack( push, 1 ) +struct SteamNetworkingMessagesSessionFailed_t_151 +{ + SteamNetConnectionInfo_t_151 m_info; +}; +#pragma pack( pop ) + +typedef struct SteamNetworkingMessagesSessionRequest_t_150 SteamNetworkingMessagesSessionRequest_t_150; +#pragma pack( push, 1 ) +struct SteamNetworkingMessagesSessionRequest_t_150 +{ + SteamNetworkingIdentity_144 m_identityRemote; +}; +#pragma pack( pop ) + +typedef struct SteamNetworkingMessagesSessionRequest_t_151 SteamNetworkingMessagesSessionRequest_t_151; +#pragma pack( push, 1 ) +struct SteamNetworkingMessagesSessionRequest_t_151 +{ + SteamNetworkingIdentity_151 m_identityRemote; +}; +#pragma pack( pop ) + +typedef struct SteamNetworkingPOPIDRender SteamNetworkingPOPIDRender; +#pragma pack( push, 1 ) +struct SteamNetworkingPOPIDRender +{ + char (buf)[8]; +}; +#pragma pack( pop ) + +typedef struct SteamNetworkingQuickConnectionStatus SteamNetworkingQuickConnectionStatus; +#pragma pack( push, 8 ) +struct SteamNetworkingQuickConnectionStatus +{ + uint32_t m_eState; + int32_t m_nPing; + float m_flConnectionQualityLocal; + float m_flConnectionQualityRemote; + float m_flOutPacketsPerSec; + float m_flOutBytesPerSec; + float m_flInPacketsPerSec; + float m_flInBytesPerSec; + int32_t m_nSendRateBytesPerSecond; + int32_t m_cbPendingUnreliable; + int32_t m_cbPendingReliable; + int32_t m_cbSentUnackedReliable; + int64_t m_usecQueueTime; + uint32_t (reserved)[16]; +}; +#pragma pack( pop ) + +typedef struct SteamParentalSettingsChanged_t SteamParentalSettingsChanged_t; +#pragma pack( push, 1 ) +struct SteamParentalSettingsChanged_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct SteamRelayNetworkStatus_t SteamRelayNetworkStatus_t; +#pragma pack( push, 4 ) +struct SteamRelayNetworkStatus_t +{ + uint32_t m_eAvail; + int32_t m_bPingMeasurementInProgress; + uint32_t m_eAvailNetworkConfig; + uint32_t m_eAvailAnyRelay; + char (m_debugMsg)[256]; +}; +#pragma pack( pop ) + +typedef struct SteamRemotePlaySessionConnected_t SteamRemotePlaySessionConnected_t; +#pragma pack( push, 4 ) +struct SteamRemotePlaySessionConnected_t +{ + uint32_t m_unSessionID; +}; +#pragma pack( pop ) + +typedef struct SteamRemotePlaySessionDisconnected_t SteamRemotePlaySessionDisconnected_t; +#pragma pack( push, 4 ) +struct SteamRemotePlaySessionDisconnected_t +{ + uint32_t m_unSessionID; +}; +#pragma pack( pop ) + +typedef struct SteamRemotePlayTogetherGuestInvite_t SteamRemotePlayTogetherGuestInvite_t; +#pragma pack( push, 1 ) +struct SteamRemotePlayTogetherGuestInvite_t +{ + char (m_szConnectURL)[1024]; +}; +#pragma pack( pop ) + +typedef struct SteamServerConnectFailure_t_135 SteamServerConnectFailure_t_135; +#pragma pack( push, 4 ) +struct SteamServerConnectFailure_t_135 +{ + uint32_t m_eResult; + bool m_bStillRetrying; + uint8_t __pad_5[3]; +}; +#pragma pack( pop ) + +typedef struct SteamServerConnectFailure_t_099u SteamServerConnectFailure_t_099u; +#pragma pack( push, 4 ) +struct SteamServerConnectFailure_t_099u +{ + uint32_t m_eResult; +}; +#pragma pack( pop ) + +typedef struct SteamServersConnected_t SteamServersConnected_t; +#pragma pack( push, 1 ) +struct SteamServersConnected_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct SteamServersDisconnected_t SteamServersDisconnected_t; +#pragma pack( push, 4 ) +struct SteamServersDisconnected_t +{ + uint32_t m_eResult; +}; +#pragma pack( pop ) + +typedef struct SteamShutdown_t SteamShutdown_t; +#pragma pack( push, 1 ) +struct SteamShutdown_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct SteamUGCQueryCompleted_t_143 SteamUGCQueryCompleted_t_143; +#pragma pack( push, 8 ) +struct SteamUGCQueryCompleted_t_143 +{ + uint64_t m_handle; + uint32_t m_eResult; + uint32_t m_unNumResultsReturned; + uint32_t m_unTotalMatchingResults; + bool m_bCachedData; + char (m_rgchNextCursor)[256]; + uint8_t __pad_277[3]; +}; +#pragma pack( pop ) + +typedef struct SteamUGCQueryCompleted_t_128x SteamUGCQueryCompleted_t_128x; +#pragma pack( push, 8 ) +struct SteamUGCQueryCompleted_t_128x +{ + uint64_t m_handle; + uint32_t m_eResult; + uint32_t m_unNumResultsReturned; + uint32_t m_unTotalMatchingResults; + bool m_bCachedData; + uint8_t __pad_21[3]; +}; +#pragma pack( pop ) + +typedef struct SteamUGCQueryCompleted_t_126 SteamUGCQueryCompleted_t_126; +#pragma pack( push, 8 ) +struct SteamUGCQueryCompleted_t_126 +{ + uint64_t m_handle; + uint32_t m_eResult; + uint32_t m_unNumResultsReturned; + uint32_t m_unTotalMatchingResults; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +typedef struct SteamUnifiedMessagesSendMethodResult_t SteamUnifiedMessagesSendMethodResult_t; +#pragma pack( push, 8 ) +struct SteamUnifiedMessagesSendMethodResult_t +{ + uint64_t m_hHandle; + uint64_t m_unContext; + uint32_t m_eResult; + uint32_t m_unResponseSize; +}; +#pragma pack( pop ) + +typedef struct StopPlaytimeTrackingResult_t StopPlaytimeTrackingResult_t; +#pragma pack( push, 4 ) +struct StopPlaytimeTrackingResult_t +{ + uint32_t m_eResult; +}; +#pragma pack( pop ) + +typedef struct StoreAuthURLResponse_t StoreAuthURLResponse_t; +#pragma pack( push, 1 ) +struct StoreAuthURLResponse_t +{ + char (m_szURL)[512]; +}; +#pragma pack( pop ) + +typedef struct SubmitItemUpdateResult_t_141 SubmitItemUpdateResult_t_141; +#pragma pack( push, 8 ) +struct SubmitItemUpdateResult_t_141 +{ + uint32_t m_eResult; + bool m_bUserNeedsToAcceptWorkshopLegalAgreement; + uint8_t __pad_5[3]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +typedef struct SubmitItemUpdateResult_t_130 SubmitItemUpdateResult_t_130; +#pragma pack( push, 4 ) +struct SubmitItemUpdateResult_t_130 +{ + uint32_t m_eResult; + bool m_bUserNeedsToAcceptWorkshopLegalAgreement; + uint8_t __pad_5[3]; +}; +#pragma pack( pop ) + +typedef struct TimedTrialStatus_t TimedTrialStatus_t; +#pragma pack( push, 4 ) +struct TimedTrialStatus_t +{ + uint32_t m_unAppID; + bool m_bIsOffline; + uint8_t __pad_5[3]; + uint32_t m_unSecondsAllowed; + uint32_t m_unSecondsPlayed; +}; +#pragma pack( pop ) + +typedef struct UnreadChatMessagesChanged_t UnreadChatMessagesChanged_t; +#pragma pack( push, 1 ) +struct UnreadChatMessagesChanged_t +{ + uint8_t __pad_0[1]; +}; +#pragma pack( pop ) + +typedef struct UserAchievementIconFetched_t UserAchievementIconFetched_t; +#pragma pack( push, 4 ) +struct UserAchievementIconFetched_t +{ + CGameID m_nGameID; + char (m_rgchAchievementName)[128]; + bool m_bAchieved; + uint8_t __pad_137[3]; + int32_t m_nIconHandle; +}; +#pragma pack( pop ) + +typedef struct UserAchievementStored_t UserAchievementStored_t; +#pragma pack( push, 8 ) +struct UserAchievementStored_t +{ + uint64_t m_nGameID; + bool m_bGroupAchievement; + char (m_rgchAchievementName)[128]; + uint8_t __pad_137[3]; + uint32_t m_nCurProgress; + uint32_t m_nMaxProgress; + uint8_t __pad_148[4]; +}; +#pragma pack( pop ) + +typedef struct UserFavoriteItemsListChanged_t UserFavoriteItemsListChanged_t; +#pragma pack( push, 8 ) +struct UserFavoriteItemsListChanged_t +{ + uint64_t m_nPublishedFileId; + uint32_t m_eResult; + bool m_bWasAddRequest; + uint8_t __pad_13[3]; +}; +#pragma pack( pop ) + +typedef struct UserStatsReceived_t_102x UserStatsReceived_t_102x; +#pragma pack( push, 8 ) +struct UserStatsReceived_t_102x +{ + uint64_t m_nGameID; + uint32_t m_eResult; + CSteamID m_steamIDUser; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +typedef struct UserStatsReceived_t_099u UserStatsReceived_t_099u; +#pragma pack( push, 8 ) +struct UserStatsReceived_t_099u +{ + uint64_t m_nGameID; + uint32_t m_eResult; + uint8_t __pad_12[4]; +}; +#pragma pack( pop ) + +typedef struct UserStatsStored_t UserStatsStored_t; +#pragma pack( push, 8 ) +struct UserStatsStored_t +{ + uint64_t m_nGameID; + uint32_t m_eResult; + uint8_t __pad_12[4]; +}; +#pragma pack( pop ) + +typedef struct UserStatsUnloaded_t UserStatsUnloaded_t; +#pragma pack( push, 1 ) +struct UserStatsUnloaded_t +{ + CSteamID m_steamIDUser; +}; +#pragma pack( pop ) + +typedef struct UserSubscribedItemsListChanged_t UserSubscribedItemsListChanged_t; +#pragma pack( push, 4 ) +struct UserSubscribedItemsListChanged_t +{ + uint32_t m_nAppID; +}; +#pragma pack( pop ) + +typedef struct ValidateAuthTicketResponse_t_126 ValidateAuthTicketResponse_t_126; +#pragma pack( push, 4 ) +struct ValidateAuthTicketResponse_t_126 +{ + CSteamID m_SteamID; + uint32_t m_eAuthSessionResponse; + CSteamID m_OwnerSteamID; +}; +#pragma pack( pop ) + +typedef struct ValidateAuthTicketResponse_t_104 ValidateAuthTicketResponse_t_104; +#pragma pack( push, 4 ) +struct ValidateAuthTicketResponse_t_104 +{ + CSteamID m_SteamID; + uint32_t m_eAuthSessionResponse; +}; +#pragma pack( pop ) + +typedef struct VolumeHasChanged_t VolumeHasChanged_t; +#pragma pack( push, 4 ) +struct VolumeHasChanged_t +{ + float m_flNewVolume; +}; +#pragma pack( pop ) + +typedef struct WorkshopEULAStatus_t WorkshopEULAStatus_t; +#pragma pack( push, 4 ) +struct WorkshopEULAStatus_t +{ + uint32_t m_eResult; + uint32_t m_nAppID; + uint32_t m_unVersion; + uint32_t m_rtAction; + bool m_bAccepted; + bool m_bNeedsAction; + uint8_t __pad_18[2]; +}; +#pragma pack( pop ) + +typedef struct gameserveritem_t_105 gameserveritem_t_105; +#pragma pack( push, 4 ) +struct gameserveritem_t_105 +{ + servernetadr_t m_NetAdr; + int32_t m_nPing; + bool m_bHadSuccessfulResponse; + bool m_bDoNotRefresh; + char (m_szGameDir)[32]; + char (m_szMap)[32]; + char (m_szGameDescription)[64]; + uint8_t __pad_142[2]; + uint32_t m_nAppID; + int32_t m_nPlayers; + int32_t m_nMaxPlayers; + int32_t m_nBotPlayers; + bool m_bPassword; + bool m_bSecure; + uint8_t __pad_162[2]; + uint32_t m_ulTimeLastPlayed; + int32_t m_nServerVersion; + char (m_szServerName)[64]; + char (m_szGameTags)[128]; + CSteamID m_steamID; +}; +#pragma pack( pop ) + +typedef struct gameserveritem_t_099u gameserveritem_t_099u; +#pragma pack( push, 4 ) +struct gameserveritem_t_099u +{ + servernetadr_t m_NetAdr; + int32_t m_nPing; + bool m_bHadSuccessfulResponse; + bool m_bDoNotRefresh; + char (m_szGameDir)[32]; + char (m_szMap)[32]; + char (m_szGameDescription)[64]; + uint8_t __pad_142[2]; + int32_t m_nAppID; + int32_t m_nPlayers; + int32_t m_nMaxPlayers; + int32_t m_nBotPlayers; + bool m_bPassword; + bool m_bSecure; + uint8_t __pad_162[2]; + uint32_t m_ulTimeLastPlayed; + int32_t m_nServerVersion; + char (m_szServerName)[64]; + char (m_szGameTags)[128]; +}; +#pragma pack( pop ) + +typedef struct u64_SteamUGCDetails_t_128x u64_SteamUGCDetails_t_128x; +typedef struct w64_SteamUGCDetails_t_128x w64_SteamUGCDetails_t_128x; +typedef struct u32_SteamUGCDetails_t_128x u32_SteamUGCDetails_t_128x; +typedef struct w32_SteamUGCDetails_t_128x w32_SteamUGCDetails_t_128x; +typedef struct u64_SteamUGCDetails_t_126 u64_SteamUGCDetails_t_126; +typedef struct w64_SteamUGCDetails_t_126 w64_SteamUGCDetails_t_126; +typedef struct u32_SteamUGCDetails_t_126 u32_SteamUGCDetails_t_126; +typedef struct w32_SteamUGCDetails_t_126 w32_SteamUGCDetails_t_126; +typedef struct u64_AddAppDependencyResult_t u64_AddAppDependencyResult_t; +typedef struct w64_AddAppDependencyResult_t w64_AddAppDependencyResult_t; +typedef struct u32_AddAppDependencyResult_t u32_AddAppDependencyResult_t; +typedef struct w32_AddAppDependencyResult_t w32_AddAppDependencyResult_t; +typedef struct u64_AddUGCDependencyResult_t u64_AddUGCDependencyResult_t; +typedef struct w64_AddUGCDependencyResult_t w64_AddUGCDependencyResult_t; +typedef struct u32_AddUGCDependencyResult_t u32_AddUGCDependencyResult_t; +typedef struct w32_AddUGCDependencyResult_t w32_AddUGCDependencyResult_t; +typedef struct w64_CSteamAPIContext_143 u64_CSteamAPIContext_143; +typedef struct w64_CSteamAPIContext_143 w64_CSteamAPIContext_143; +typedef struct w32_CSteamAPIContext_143 u32_CSteamAPIContext_143; +typedef struct w32_CSteamAPIContext_143 w32_CSteamAPIContext_143; +typedef struct w64_CSteamAPIContext_145 u64_CSteamAPIContext_145; +typedef struct w64_CSteamAPIContext_145 w64_CSteamAPIContext_145; +typedef struct w32_CSteamAPIContext_145 u32_CSteamAPIContext_145; +typedef struct w32_CSteamAPIContext_145 w32_CSteamAPIContext_145; +typedef struct w64_CSteamAPIContext_137 u64_CSteamAPIContext_137; +typedef struct w64_CSteamAPIContext_137 w64_CSteamAPIContext_137; +typedef struct w32_CSteamAPIContext_137 u32_CSteamAPIContext_137; +typedef struct w32_CSteamAPIContext_137 w32_CSteamAPIContext_137; +typedef struct w64_CSteamAPIContext_141 u64_CSteamAPIContext_141; +typedef struct w64_CSteamAPIContext_141 w64_CSteamAPIContext_141; +typedef struct w32_CSteamAPIContext_141 u32_CSteamAPIContext_141; +typedef struct w32_CSteamAPIContext_141 w32_CSteamAPIContext_141; +typedef struct u_CSteamCallback u_CSteamCallback; +typedef struct u_CSteamCallback u64_CSteamCallback; +typedef struct u_CSteamCallback u32_CSteamCallback; +typedef struct w_CSteamCallback w_CSteamCallback; +typedef struct w_CSteamCallback w64_CSteamCallback; +typedef struct w_CSteamCallback w32_CSteamCallback; +typedef struct w64_CSteamGameServerAPIContext_152 u64_CSteamGameServerAPIContext_152; +typedef struct w64_CSteamGameServerAPIContext_152 w64_CSteamGameServerAPIContext_152; +typedef struct w32_CSteamGameServerAPIContext_152 u32_CSteamGameServerAPIContext_152; +typedef struct w32_CSteamGameServerAPIContext_152 w32_CSteamGameServerAPIContext_152; +typedef struct w64_CSteamGameServerAPIContext_143 u64_CSteamGameServerAPIContext_143; +typedef struct w64_CSteamGameServerAPIContext_143 w64_CSteamGameServerAPIContext_143; +typedef struct w32_CSteamGameServerAPIContext_143 u32_CSteamGameServerAPIContext_143; +typedef struct w32_CSteamGameServerAPIContext_143 w32_CSteamGameServerAPIContext_143; +typedef struct w64_CallbackMsg_t u64_CallbackMsg_t; +typedef struct w64_CallbackMsg_t w64_CallbackMsg_t; +typedef struct w32_CallbackMsg_t u32_CallbackMsg_t; +typedef struct w32_CallbackMsg_t w32_CallbackMsg_t; +typedef struct u64_CreateBeaconCallback_t u64_CreateBeaconCallback_t; +typedef struct w64_CreateBeaconCallback_t w64_CreateBeaconCallback_t; +typedef struct u32_CreateBeaconCallback_t u32_CreateBeaconCallback_t; +typedef struct w32_CreateBeaconCallback_t w32_CreateBeaconCallback_t; +typedef struct u64_CreateItemResult_t u64_CreateItemResult_t; +typedef struct w64_CreateItemResult_t w64_CreateItemResult_t; +typedef struct u32_CreateItemResult_t u32_CreateItemResult_t; +typedef struct w32_CreateItemResult_t w32_CreateItemResult_t; +typedef struct u64_DeleteItemResult_t u64_DeleteItemResult_t; +typedef struct w64_DeleteItemResult_t w64_DeleteItemResult_t; +typedef struct u32_DeleteItemResult_t u32_DeleteItemResult_t; +typedef struct w32_DeleteItemResult_t w32_DeleteItemResult_t; +typedef struct u64_DownloadItemResult_t u64_DownloadItemResult_t; +typedef struct w64_DownloadItemResult_t w64_DownloadItemResult_t; +typedef struct u32_DownloadItemResult_t u32_DownloadItemResult_t; +typedef struct w32_DownloadItemResult_t w32_DownloadItemResult_t; +typedef struct u64_EndGameResultCallback_t u64_EndGameResultCallback_t; +typedef struct w64_EndGameResultCallback_t w64_EndGameResultCallback_t; +typedef struct u32_EndGameResultCallback_t u32_EndGameResultCallback_t; +typedef struct w32_EndGameResultCallback_t w32_EndGameResultCallback_t; +typedef struct u64_FileDetailsResult_t u64_FileDetailsResult_t; +typedef struct w64_FileDetailsResult_t w64_FileDetailsResult_t; +typedef struct u32_FileDetailsResult_t u32_FileDetailsResult_t; +typedef struct w32_FileDetailsResult_t w32_FileDetailsResult_t; +typedef struct u64_GSReputation_t_123 u64_GSReputation_t_123; +typedef struct w64_GSReputation_t_123 w64_GSReputation_t_123; +typedef struct u32_GSReputation_t_123 u32_GSReputation_t_123; +typedef struct w32_GSReputation_t_123 w32_GSReputation_t_123; +typedef struct w64_GSReputation_t_108 u64_GSReputation_t_108; +typedef struct w64_GSReputation_t_108 w64_GSReputation_t_108; +typedef struct u32_GSReputation_t_108 u32_GSReputation_t_108; +typedef struct w32_GSReputation_t_108 w32_GSReputation_t_108; +typedef struct u64_GetAppDependenciesResult_t u64_GetAppDependenciesResult_t; +typedef struct w64_GetAppDependenciesResult_t w64_GetAppDependenciesResult_t; +typedef struct u32_GetAppDependenciesResult_t u32_GetAppDependenciesResult_t; +typedef struct w32_GetAppDependenciesResult_t w32_GetAppDependenciesResult_t; +typedef struct u64_HTML_ChangedTitle_t u64_HTML_ChangedTitle_t; +typedef struct w64_HTML_ChangedTitle_t w64_HTML_ChangedTitle_t; +typedef struct w32_HTML_ChangedTitle_t u32_HTML_ChangedTitle_t; +typedef struct w32_HTML_ChangedTitle_t w32_HTML_ChangedTitle_t; +typedef struct u64_HTML_ComboNeedsPaint_t u64_HTML_ComboNeedsPaint_t; +typedef struct w64_HTML_ComboNeedsPaint_t w64_HTML_ComboNeedsPaint_t; +typedef struct w32_HTML_ComboNeedsPaint_t u32_HTML_ComboNeedsPaint_t; +typedef struct w32_HTML_ComboNeedsPaint_t w32_HTML_ComboNeedsPaint_t; +typedef struct u64_HTML_FileOpenDialog_t u64_HTML_FileOpenDialog_t; +typedef struct w64_HTML_FileOpenDialog_t w64_HTML_FileOpenDialog_t; +typedef struct u32_HTML_FileOpenDialog_t u32_HTML_FileOpenDialog_t; +typedef struct w32_HTML_FileOpenDialog_t w32_HTML_FileOpenDialog_t; +typedef struct u64_HTML_FinishedRequest_t u64_HTML_FinishedRequest_t; +typedef struct w64_HTML_FinishedRequest_t w64_HTML_FinishedRequest_t; +typedef struct u32_HTML_FinishedRequest_t u32_HTML_FinishedRequest_t; +typedef struct w32_HTML_FinishedRequest_t w32_HTML_FinishedRequest_t; +typedef struct u64_HTML_JSAlert_t u64_HTML_JSAlert_t; +typedef struct w64_HTML_JSAlert_t w64_HTML_JSAlert_t; +typedef struct w32_HTML_JSAlert_t u32_HTML_JSAlert_t; +typedef struct w32_HTML_JSAlert_t w32_HTML_JSAlert_t; +typedef struct u64_HTML_JSConfirm_t u64_HTML_JSConfirm_t; +typedef struct w64_HTML_JSConfirm_t w64_HTML_JSConfirm_t; +typedef struct w32_HTML_JSConfirm_t u32_HTML_JSConfirm_t; +typedef struct w32_HTML_JSConfirm_t w32_HTML_JSConfirm_t; +typedef struct u64_HTML_LinkAtPosition_t u64_HTML_LinkAtPosition_t; +typedef struct w64_HTML_LinkAtPosition_t w64_HTML_LinkAtPosition_t; +typedef struct u32_HTML_LinkAtPosition_t u32_HTML_LinkAtPosition_t; +typedef struct w32_HTML_LinkAtPosition_t w32_HTML_LinkAtPosition_t; +typedef struct u64_HTML_NeedsPaint_t u64_HTML_NeedsPaint_t; +typedef struct w64_HTML_NeedsPaint_t w64_HTML_NeedsPaint_t; +typedef struct w32_HTML_NeedsPaint_t u32_HTML_NeedsPaint_t; +typedef struct w32_HTML_NeedsPaint_t w32_HTML_NeedsPaint_t; +typedef struct u64_HTML_NewWindow_t_132x u64_HTML_NewWindow_t_132x; +typedef struct w64_HTML_NewWindow_t_132x w64_HTML_NewWindow_t_132x; +typedef struct u32_HTML_NewWindow_t_132x u32_HTML_NewWindow_t_132x; +typedef struct w32_HTML_NewWindow_t_132x w32_HTML_NewWindow_t_132x; +typedef struct u64_HTML_NewWindow_t_130x u64_HTML_NewWindow_t_130x; +typedef struct w64_HTML_NewWindow_t_130x w64_HTML_NewWindow_t_130x; +typedef struct u32_HTML_NewWindow_t_130x u32_HTML_NewWindow_t_130x; +typedef struct w32_HTML_NewWindow_t_130x w32_HTML_NewWindow_t_130x; +typedef struct u64_HTML_OpenLinkInNewTab_t u64_HTML_OpenLinkInNewTab_t; +typedef struct w64_HTML_OpenLinkInNewTab_t w64_HTML_OpenLinkInNewTab_t; +typedef struct u32_HTML_OpenLinkInNewTab_t u32_HTML_OpenLinkInNewTab_t; +typedef struct w32_HTML_OpenLinkInNewTab_t w32_HTML_OpenLinkInNewTab_t; +typedef struct u64_HTML_ShowToolTip_t u64_HTML_ShowToolTip_t; +typedef struct w64_HTML_ShowToolTip_t w64_HTML_ShowToolTip_t; +typedef struct w32_HTML_ShowToolTip_t u32_HTML_ShowToolTip_t; +typedef struct w32_HTML_ShowToolTip_t w32_HTML_ShowToolTip_t; +typedef struct u64_HTML_StartRequest_t u64_HTML_StartRequest_t; +typedef struct w64_HTML_StartRequest_t w64_HTML_StartRequest_t; +typedef struct u32_HTML_StartRequest_t u32_HTML_StartRequest_t; +typedef struct w32_HTML_StartRequest_t w32_HTML_StartRequest_t; +typedef struct u64_HTML_StatusText_t u64_HTML_StatusText_t; +typedef struct w64_HTML_StatusText_t w64_HTML_StatusText_t; +typedef struct w32_HTML_StatusText_t u32_HTML_StatusText_t; +typedef struct w32_HTML_StatusText_t w32_HTML_StatusText_t; +typedef struct u64_HTML_URLChanged_t u64_HTML_URLChanged_t; +typedef struct w64_HTML_URLChanged_t w64_HTML_URLChanged_t; +typedef struct u32_HTML_URLChanged_t u32_HTML_URLChanged_t; +typedef struct w32_HTML_URLChanged_t w32_HTML_URLChanged_t; +typedef struct u64_HTML_UpdateToolTip_t u64_HTML_UpdateToolTip_t; +typedef struct w64_HTML_UpdateToolTip_t w64_HTML_UpdateToolTip_t; +typedef struct w32_HTML_UpdateToolTip_t u32_HTML_UpdateToolTip_t; +typedef struct w32_HTML_UpdateToolTip_t w32_HTML_UpdateToolTip_t; +typedef struct u64_HTTPRequestCompleted_t_132x u64_HTTPRequestCompleted_t_132x; +typedef struct w64_HTTPRequestCompleted_t_132x w64_HTTPRequestCompleted_t_132x; +typedef struct u32_HTTPRequestCompleted_t_132x u32_HTTPRequestCompleted_t_132x; +typedef struct w32_HTTPRequestCompleted_t_132x w32_HTTPRequestCompleted_t_132x; +typedef struct u64_HTTPRequestCompleted_t_123 u64_HTTPRequestCompleted_t_123; +typedef struct w64_HTTPRequestCompleted_t_123 w64_HTTPRequestCompleted_t_123; +typedef struct u32_HTTPRequestCompleted_t_123 u32_HTTPRequestCompleted_t_123; +typedef struct w32_HTTPRequestCompleted_t_123 w32_HTTPRequestCompleted_t_123; +typedef struct w64_HTTPRequestCompleted_t_115 u64_HTTPRequestCompleted_t_115; +typedef struct w64_HTTPRequestCompleted_t_115 w64_HTTPRequestCompleted_t_115; +typedef struct u32_HTTPRequestCompleted_t_115 u32_HTTPRequestCompleted_t_115; +typedef struct w32_HTTPRequestCompleted_t_115 w32_HTTPRequestCompleted_t_115; +typedef struct u64_HTTPRequestDataReceived_t_123 u64_HTTPRequestDataReceived_t_123; +typedef struct w64_HTTPRequestDataReceived_t_123 w64_HTTPRequestDataReceived_t_123; +typedef struct u32_HTTPRequestDataReceived_t_123 u32_HTTPRequestDataReceived_t_123; +typedef struct w32_HTTPRequestDataReceived_t_123 w32_HTTPRequestDataReceived_t_123; +typedef struct w64_HTTPRequestDataReceived_t_121x u64_HTTPRequestDataReceived_t_121x; +typedef struct w64_HTTPRequestDataReceived_t_121x w64_HTTPRequestDataReceived_t_121x; +typedef struct u32_HTTPRequestDataReceived_t_121x u32_HTTPRequestDataReceived_t_121x; +typedef struct w32_HTTPRequestDataReceived_t_121x w32_HTTPRequestDataReceived_t_121x; +typedef struct u64_HTTPRequestHeadersReceived_t_123 u64_HTTPRequestHeadersReceived_t_123; +typedef struct w64_HTTPRequestHeadersReceived_t_123 w64_HTTPRequestHeadersReceived_t_123; +typedef struct u32_HTTPRequestHeadersReceived_t_123 u32_HTTPRequestHeadersReceived_t_123; +typedef struct w32_HTTPRequestHeadersReceived_t_123 w32_HTTPRequestHeadersReceived_t_123; +typedef struct w64_HTTPRequestHeadersReceived_t_121x u64_HTTPRequestHeadersReceived_t_121x; +typedef struct w64_HTTPRequestHeadersReceived_t_121x w64_HTTPRequestHeadersReceived_t_121x; +typedef struct u32_HTTPRequestHeadersReceived_t_121x u32_HTTPRequestHeadersReceived_t_121x; +typedef struct w32_HTTPRequestHeadersReceived_t_121x w32_HTTPRequestHeadersReceived_t_121x; +typedef struct u_ISteamMatchmakingPingResponse u_ISteamMatchmakingPingResponse; +typedef struct u_ISteamMatchmakingPingResponse u64_ISteamMatchmakingPingResponse; +typedef struct u_ISteamMatchmakingPingResponse u32_ISteamMatchmakingPingResponse; +typedef struct w_ISteamMatchmakingPingResponse w_ISteamMatchmakingPingResponse; +typedef struct w_ISteamMatchmakingPingResponse w64_ISteamMatchmakingPingResponse; +typedef struct w_ISteamMatchmakingPingResponse w32_ISteamMatchmakingPingResponse; +typedef struct u_ISteamMatchmakingPlayersResponse u_ISteamMatchmakingPlayersResponse; +typedef struct u_ISteamMatchmakingPlayersResponse u64_ISteamMatchmakingPlayersResponse; +typedef struct u_ISteamMatchmakingPlayersResponse u32_ISteamMatchmakingPlayersResponse; +typedef struct w_ISteamMatchmakingPlayersResponse w_ISteamMatchmakingPlayersResponse; +typedef struct w_ISteamMatchmakingPlayersResponse w64_ISteamMatchmakingPlayersResponse; +typedef struct w_ISteamMatchmakingPlayersResponse w32_ISteamMatchmakingPlayersResponse; +typedef struct u_ISteamMatchmakingRulesResponse u_ISteamMatchmakingRulesResponse; +typedef struct u_ISteamMatchmakingRulesResponse u64_ISteamMatchmakingRulesResponse; +typedef struct u_ISteamMatchmakingRulesResponse u32_ISteamMatchmakingRulesResponse; +typedef struct w_ISteamMatchmakingRulesResponse w_ISteamMatchmakingRulesResponse; +typedef struct w_ISteamMatchmakingRulesResponse w64_ISteamMatchmakingRulesResponse; +typedef struct w_ISteamMatchmakingRulesResponse w32_ISteamMatchmakingRulesResponse; +typedef struct u_ISteamMatchmakingServerListResponse u_ISteamMatchmakingServerListResponse; +typedef struct u_ISteamMatchmakingServerListResponse u64_ISteamMatchmakingServerListResponse; +typedef struct u_ISteamMatchmakingServerListResponse u32_ISteamMatchmakingServerListResponse; +typedef struct w_ISteamMatchmakingServerListResponse w_ISteamMatchmakingServerListResponse; +typedef struct w_ISteamMatchmakingServerListResponse w64_ISteamMatchmakingServerListResponse; +typedef struct w_ISteamMatchmakingServerListResponse w32_ISteamMatchmakingServerListResponse; +typedef struct u_ISteamNetworkingConnectionCustomSignaling u_ISteamNetworkingConnectionCustomSignaling; +typedef struct u_ISteamNetworkingConnectionCustomSignaling u64_ISteamNetworkingConnectionCustomSignaling; +typedef struct u_ISteamNetworkingConnectionCustomSignaling u32_ISteamNetworkingConnectionCustomSignaling; +typedef struct w_ISteamNetworkingConnectionCustomSignaling w_ISteamNetworkingConnectionCustomSignaling; +typedef struct w_ISteamNetworkingConnectionCustomSignaling w64_ISteamNetworkingConnectionCustomSignaling; +typedef struct w_ISteamNetworkingConnectionCustomSignaling w32_ISteamNetworkingConnectionCustomSignaling; +typedef struct u_ISteamNetworkingCustomSignalingRecvContext u_ISteamNetworkingCustomSignalingRecvContext; +typedef struct u_ISteamNetworkingCustomSignalingRecvContext u64_ISteamNetworkingCustomSignalingRecvContext; +typedef struct u_ISteamNetworkingCustomSignalingRecvContext u32_ISteamNetworkingCustomSignalingRecvContext; +typedef struct w_ISteamNetworkingCustomSignalingRecvContext w_ISteamNetworkingCustomSignalingRecvContext; +typedef struct w_ISteamNetworkingCustomSignalingRecvContext w64_ISteamNetworkingCustomSignalingRecvContext; +typedef struct w_ISteamNetworkingCustomSignalingRecvContext w32_ISteamNetworkingCustomSignalingRecvContext; +typedef struct u64_ItemInstalled_t u64_ItemInstalled_t; +typedef struct w64_ItemInstalled_t w64_ItemInstalled_t; +typedef struct u32_ItemInstalled_t u32_ItemInstalled_t; +typedef struct w32_ItemInstalled_t w32_ItemInstalled_t; +typedef struct u64_JoinPartyCallback_t u64_JoinPartyCallback_t; +typedef struct w64_JoinPartyCallback_t w64_JoinPartyCallback_t; +typedef struct u32_JoinPartyCallback_t u32_JoinPartyCallback_t; +typedef struct w32_JoinPartyCallback_t w32_JoinPartyCallback_t; +typedef struct u64_LeaderboardEntry_t_123 u64_LeaderboardEntry_t_123; +typedef struct w64_LeaderboardEntry_t_123 w64_LeaderboardEntry_t_123; +typedef struct u32_LeaderboardEntry_t_123 u32_LeaderboardEntry_t_123; +typedef struct w32_LeaderboardEntry_t_123 w32_LeaderboardEntry_t_123; +typedef struct w64_LeaderboardEntry_t_111x u64_LeaderboardEntry_t_111x; +typedef struct w64_LeaderboardEntry_t_111x w64_LeaderboardEntry_t_111x; +typedef struct u32_LeaderboardEntry_t_111x u32_LeaderboardEntry_t_111x; +typedef struct w32_LeaderboardEntry_t_111x w32_LeaderboardEntry_t_111x; +typedef struct w64_LeaderboardEntry_t_104 u64_LeaderboardEntry_t_104; +typedef struct w64_LeaderboardEntry_t_104 w64_LeaderboardEntry_t_104; +typedef struct w32_LeaderboardEntry_t_104 u32_LeaderboardEntry_t_104; +typedef struct w32_LeaderboardEntry_t_104 w32_LeaderboardEntry_t_104; +typedef struct u64_LeaderboardScoreUploaded_t_123 u64_LeaderboardScoreUploaded_t_123; +typedef struct w64_LeaderboardScoreUploaded_t_123 w64_LeaderboardScoreUploaded_t_123; +typedef struct u32_LeaderboardScoreUploaded_t_123 u32_LeaderboardScoreUploaded_t_123; +typedef struct w32_LeaderboardScoreUploaded_t_123 w32_LeaderboardScoreUploaded_t_123; +typedef struct w64_LeaderboardScoreUploaded_t_104 u64_LeaderboardScoreUploaded_t_104; +typedef struct w64_LeaderboardScoreUploaded_t_104 w64_LeaderboardScoreUploaded_t_104; +typedef struct u32_LeaderboardScoreUploaded_t_104 u32_LeaderboardScoreUploaded_t_104; +typedef struct w32_LeaderboardScoreUploaded_t_104 w32_LeaderboardScoreUploaded_t_104; +typedef struct u64_LeaderboardUGCSet_t_123 u64_LeaderboardUGCSet_t_123; +typedef struct w64_LeaderboardUGCSet_t_123 w64_LeaderboardUGCSet_t_123; +typedef struct u32_LeaderboardUGCSet_t_123 u32_LeaderboardUGCSet_t_123; +typedef struct w32_LeaderboardUGCSet_t_123 w32_LeaderboardUGCSet_t_123; +typedef struct w64_LeaderboardUGCSet_t_111x u64_LeaderboardUGCSet_t_111x; +typedef struct w64_LeaderboardUGCSet_t_111x w64_LeaderboardUGCSet_t_111x; +typedef struct u32_LeaderboardUGCSet_t_111x u32_LeaderboardUGCSet_t_111x; +typedef struct w32_LeaderboardUGCSet_t_111x w32_LeaderboardUGCSet_t_111x; +typedef struct u64_LobbyCreated_t_123 u64_LobbyCreated_t_123; +typedef struct w64_LobbyCreated_t_123 w64_LobbyCreated_t_123; +typedef struct u32_LobbyCreated_t_123 u32_LobbyCreated_t_123; +typedef struct w32_LobbyCreated_t_123 w32_LobbyCreated_t_123; +typedef struct w64_LobbyCreated_t_099u u64_LobbyCreated_t_099u; +typedef struct w64_LobbyCreated_t_099u w64_LobbyCreated_t_099u; +typedef struct u32_LobbyCreated_t_099u u32_LobbyCreated_t_099u; +typedef struct w32_LobbyCreated_t_099u w32_LobbyCreated_t_099u; +typedef struct u64_MicroTxnAuthorizationResponse_t_123 u64_MicroTxnAuthorizationResponse_t_123; +typedef struct w64_MicroTxnAuthorizationResponse_t_123 w64_MicroTxnAuthorizationResponse_t_123; +typedef struct u32_MicroTxnAuthorizationResponse_t_123 u32_MicroTxnAuthorizationResponse_t_123; +typedef struct w32_MicroTxnAuthorizationResponse_t_123 w32_MicroTxnAuthorizationResponse_t_123; +typedef struct w64_MicroTxnAuthorizationResponse_t_109 u64_MicroTxnAuthorizationResponse_t_109; +typedef struct w64_MicroTxnAuthorizationResponse_t_109 w64_MicroTxnAuthorizationResponse_t_109; +typedef struct u32_MicroTxnAuthorizationResponse_t_109 u32_MicroTxnAuthorizationResponse_t_109; +typedef struct w32_MicroTxnAuthorizationResponse_t_109 w32_MicroTxnAuthorizationResponse_t_109; +typedef struct u64_PS3TrophiesInstalled_t_123 u64_PS3TrophiesInstalled_t_123; +typedef struct w64_PS3TrophiesInstalled_t_123 w64_PS3TrophiesInstalled_t_123; +typedef struct u32_PS3TrophiesInstalled_t_123 u32_PS3TrophiesInstalled_t_123; +typedef struct w32_PS3TrophiesInstalled_t_123 w32_PS3TrophiesInstalled_t_123; +typedef struct w64_PS3TrophiesInstalled_t_112x u64_PS3TrophiesInstalled_t_112x; +typedef struct w64_PS3TrophiesInstalled_t_112x w64_PS3TrophiesInstalled_t_112x; +typedef struct u32_PS3TrophiesInstalled_t_112x u32_PS3TrophiesInstalled_t_112x; +typedef struct w32_PS3TrophiesInstalled_t_112x w32_PS3TrophiesInstalled_t_112x; +typedef struct u64_RemoteStorageAppSyncProgress_t_123 u64_RemoteStorageAppSyncProgress_t_123; +typedef struct w64_RemoteStorageAppSyncProgress_t_123 w64_RemoteStorageAppSyncProgress_t_123; +typedef struct u32_RemoteStorageAppSyncProgress_t_123 u32_RemoteStorageAppSyncProgress_t_123; +typedef struct w32_RemoteStorageAppSyncProgress_t_123 w32_RemoteStorageAppSyncProgress_t_123; +typedef struct w64_RemoteStorageAppSyncProgress_t_111x u64_RemoteStorageAppSyncProgress_t_111x; +typedef struct w64_RemoteStorageAppSyncProgress_t_111x w64_RemoteStorageAppSyncProgress_t_111x; +typedef struct u32_RemoteStorageAppSyncProgress_t_111x u32_RemoteStorageAppSyncProgress_t_111x; +typedef struct w32_RemoteStorageAppSyncProgress_t_111x w32_RemoteStorageAppSyncProgress_t_111x; +typedef struct u64_RemoteStorageDeletePublishedFileResult_t_123 u64_RemoteStorageDeletePublishedFileResult_t_123; +typedef struct w64_RemoteStorageDeletePublishedFileResult_t_123 w64_RemoteStorageDeletePublishedFileResult_t_123; +typedef struct u32_RemoteStorageDeletePublishedFileResult_t_123 u32_RemoteStorageDeletePublishedFileResult_t_123; +typedef struct w32_RemoteStorageDeletePublishedFileResult_t_123 w32_RemoteStorageDeletePublishedFileResult_t_123; +typedef struct w64_RemoteStorageDeletePublishedFileResult_t_116x u64_RemoteStorageDeletePublishedFileResult_t_116x; +typedef struct w64_RemoteStorageDeletePublishedFileResult_t_116x w64_RemoteStorageDeletePublishedFileResult_t_116x; +typedef struct u32_RemoteStorageDeletePublishedFileResult_t_116x u32_RemoteStorageDeletePublishedFileResult_t_116x; +typedef struct w32_RemoteStorageDeletePublishedFileResult_t_116x w32_RemoteStorageDeletePublishedFileResult_t_116x; +typedef struct u64_RemoteStorageDownloadUGCResult_t_123 u64_RemoteStorageDownloadUGCResult_t_123; +typedef struct w64_RemoteStorageDownloadUGCResult_t_123 w64_RemoteStorageDownloadUGCResult_t_123; +typedef struct u32_RemoteStorageDownloadUGCResult_t_123 u32_RemoteStorageDownloadUGCResult_t_123; +typedef struct w32_RemoteStorageDownloadUGCResult_t_123 w32_RemoteStorageDownloadUGCResult_t_123; +typedef struct w64_RemoteStorageDownloadUGCResult_t_116x u64_RemoteStorageDownloadUGCResult_t_116x; +typedef struct w64_RemoteStorageDownloadUGCResult_t_116x w64_RemoteStorageDownloadUGCResult_t_116x; +typedef struct u32_RemoteStorageDownloadUGCResult_t_116x u32_RemoteStorageDownloadUGCResult_t_116x; +typedef struct w32_RemoteStorageDownloadUGCResult_t_116x w32_RemoteStorageDownloadUGCResult_t_116x; +typedef struct w64_RemoteStorageDownloadUGCResult_t_111x u64_RemoteStorageDownloadUGCResult_t_111x; +typedef struct w64_RemoteStorageDownloadUGCResult_t_111x w64_RemoteStorageDownloadUGCResult_t_111x; +typedef struct u32_RemoteStorageDownloadUGCResult_t_111x u32_RemoteStorageDownloadUGCResult_t_111x; +typedef struct w32_RemoteStorageDownloadUGCResult_t_111x w32_RemoteStorageDownloadUGCResult_t_111x; +typedef struct u64_RemoteStorageEnumerateUserPublishedFilesResult_t_123 u64_RemoteStorageEnumerateUserPublishedFilesResult_t_123; +typedef struct w64_RemoteStorageEnumerateUserPublishedFilesResult_t_123 w64_RemoteStorageEnumerateUserPublishedFilesResult_t_123; +typedef struct u32_RemoteStorageEnumerateUserPublishedFilesResult_t_123 u32_RemoteStorageEnumerateUserPublishedFilesResult_t_123; +typedef struct w32_RemoteStorageEnumerateUserPublishedFilesResult_t_123 w32_RemoteStorageEnumerateUserPublishedFilesResult_t_123; +typedef struct w64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x u64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x; +typedef struct w64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x w64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x; +typedef struct u32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x u32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x; +typedef struct w32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x w32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x; +typedef struct u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123 u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123; +typedef struct w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123 w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123; +typedef struct u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123 u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123; +typedef struct w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123 w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123; +typedef struct w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119 u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119; +typedef struct w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119 w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119; +typedef struct u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119 u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119; +typedef struct w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119 w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119; +typedef struct u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123 u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123; +typedef struct w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123 w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123; +typedef struct u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123 u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123; +typedef struct w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123 w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123; +typedef struct w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x; +typedef struct w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x; +typedef struct u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x; +typedef struct w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x; +typedef struct u64_RemoteStorageEnumerateWorkshopFilesResult_t_125 u64_RemoteStorageEnumerateWorkshopFilesResult_t_125; +typedef struct w64_RemoteStorageEnumerateWorkshopFilesResult_t_125 w64_RemoteStorageEnumerateWorkshopFilesResult_t_125; +typedef struct u32_RemoteStorageEnumerateWorkshopFilesResult_t_125 u32_RemoteStorageEnumerateWorkshopFilesResult_t_125; +typedef struct w32_RemoteStorageEnumerateWorkshopFilesResult_t_125 w32_RemoteStorageEnumerateWorkshopFilesResult_t_125; +typedef struct u64_RemoteStorageEnumerateWorkshopFilesResult_t_123 u64_RemoteStorageEnumerateWorkshopFilesResult_t_123; +typedef struct w64_RemoteStorageEnumerateWorkshopFilesResult_t_123 w64_RemoteStorageEnumerateWorkshopFilesResult_t_123; +typedef struct u32_RemoteStorageEnumerateWorkshopFilesResult_t_123 u32_RemoteStorageEnumerateWorkshopFilesResult_t_123; +typedef struct w32_RemoteStorageEnumerateWorkshopFilesResult_t_123 w32_RemoteStorageEnumerateWorkshopFilesResult_t_123; +typedef struct w64_RemoteStorageEnumerateWorkshopFilesResult_t_119 u64_RemoteStorageEnumerateWorkshopFilesResult_t_119; +typedef struct w64_RemoteStorageEnumerateWorkshopFilesResult_t_119 w64_RemoteStorageEnumerateWorkshopFilesResult_t_119; +typedef struct u32_RemoteStorageEnumerateWorkshopFilesResult_t_119 u32_RemoteStorageEnumerateWorkshopFilesResult_t_119; +typedef struct w32_RemoteStorageEnumerateWorkshopFilesResult_t_119 w32_RemoteStorageEnumerateWorkshopFilesResult_t_119; +typedef struct u64_RemoteStorageFileShareResult_t_128x u64_RemoteStorageFileShareResult_t_128x; +typedef struct w64_RemoteStorageFileShareResult_t_128x w64_RemoteStorageFileShareResult_t_128x; +typedef struct u32_RemoteStorageFileShareResult_t_128x u32_RemoteStorageFileShareResult_t_128x; +typedef struct w32_RemoteStorageFileShareResult_t_128x w32_RemoteStorageFileShareResult_t_128x; +typedef struct u64_RemoteStorageFileShareResult_t_123 u64_RemoteStorageFileShareResult_t_123; +typedef struct w64_RemoteStorageFileShareResult_t_123 w64_RemoteStorageFileShareResult_t_123; +typedef struct u32_RemoteStorageFileShareResult_t_123 u32_RemoteStorageFileShareResult_t_123; +typedef struct w32_RemoteStorageFileShareResult_t_123 w32_RemoteStorageFileShareResult_t_123; +typedef struct w64_RemoteStorageFileShareResult_t_111x u64_RemoteStorageFileShareResult_t_111x; +typedef struct w64_RemoteStorageFileShareResult_t_111x w64_RemoteStorageFileShareResult_t_111x; +typedef struct u32_RemoteStorageFileShareResult_t_111x u32_RemoteStorageFileShareResult_t_111x; +typedef struct w32_RemoteStorageFileShareResult_t_111x w32_RemoteStorageFileShareResult_t_111x; +typedef struct u64_RemoteStorageGetPublishedFileDetailsResult_t_126 u64_RemoteStorageGetPublishedFileDetailsResult_t_126; +typedef struct w64_RemoteStorageGetPublishedFileDetailsResult_t_126 w64_RemoteStorageGetPublishedFileDetailsResult_t_126; +typedef struct u32_RemoteStorageGetPublishedFileDetailsResult_t_126 u32_RemoteStorageGetPublishedFileDetailsResult_t_126; +typedef struct w32_RemoteStorageGetPublishedFileDetailsResult_t_126 w32_RemoteStorageGetPublishedFileDetailsResult_t_126; +typedef struct u64_RemoteStorageGetPublishedFileDetailsResult_t_123 u64_RemoteStorageGetPublishedFileDetailsResult_t_123; +typedef struct w64_RemoteStorageGetPublishedFileDetailsResult_t_123 w64_RemoteStorageGetPublishedFileDetailsResult_t_123; +typedef struct u32_RemoteStorageGetPublishedFileDetailsResult_t_123 u32_RemoteStorageGetPublishedFileDetailsResult_t_123; +typedef struct w32_RemoteStorageGetPublishedFileDetailsResult_t_123 w32_RemoteStorageGetPublishedFileDetailsResult_t_123; +typedef struct w64_RemoteStorageGetPublishedFileDetailsResult_t_119x u64_RemoteStorageGetPublishedFileDetailsResult_t_119x; +typedef struct w64_RemoteStorageGetPublishedFileDetailsResult_t_119x w64_RemoteStorageGetPublishedFileDetailsResult_t_119x; +typedef struct u32_RemoteStorageGetPublishedFileDetailsResult_t_119x u32_RemoteStorageGetPublishedFileDetailsResult_t_119x; +typedef struct w32_RemoteStorageGetPublishedFileDetailsResult_t_119x w32_RemoteStorageGetPublishedFileDetailsResult_t_119x; +typedef struct w64_RemoteStorageGetPublishedFileDetailsResult_t_119 u64_RemoteStorageGetPublishedFileDetailsResult_t_119; +typedef struct w64_RemoteStorageGetPublishedFileDetailsResult_t_119 w64_RemoteStorageGetPublishedFileDetailsResult_t_119; +typedef struct u32_RemoteStorageGetPublishedFileDetailsResult_t_119 u32_RemoteStorageGetPublishedFileDetailsResult_t_119; +typedef struct w32_RemoteStorageGetPublishedFileDetailsResult_t_119 w32_RemoteStorageGetPublishedFileDetailsResult_t_119; +typedef struct w64_RemoteStorageGetPublishedFileDetailsResult_t_118 u64_RemoteStorageGetPublishedFileDetailsResult_t_118; +typedef struct w64_RemoteStorageGetPublishedFileDetailsResult_t_118 w64_RemoteStorageGetPublishedFileDetailsResult_t_118; +typedef struct u32_RemoteStorageGetPublishedFileDetailsResult_t_118 u32_RemoteStorageGetPublishedFileDetailsResult_t_118; +typedef struct w32_RemoteStorageGetPublishedFileDetailsResult_t_118 w32_RemoteStorageGetPublishedFileDetailsResult_t_118; +typedef struct w64_RemoteStorageGetPublishedFileDetailsResult_t_116x u64_RemoteStorageGetPublishedFileDetailsResult_t_116x; +typedef struct w64_RemoteStorageGetPublishedFileDetailsResult_t_116x w64_RemoteStorageGetPublishedFileDetailsResult_t_116x; +typedef struct u32_RemoteStorageGetPublishedFileDetailsResult_t_116x u32_RemoteStorageGetPublishedFileDetailsResult_t_116x; +typedef struct w32_RemoteStorageGetPublishedFileDetailsResult_t_116x w32_RemoteStorageGetPublishedFileDetailsResult_t_116x; +typedef struct u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123 u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123; +typedef struct w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123 w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123; +typedef struct u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123 u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123; +typedef struct w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123 w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123; +typedef struct w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119 u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119; +typedef struct w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119 w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119; +typedef struct u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119 u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119; +typedef struct w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119 w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119; +typedef struct u64_RemoteStoragePublishFileResult_t_125 u64_RemoteStoragePublishFileResult_t_125; +typedef struct w64_RemoteStoragePublishFileResult_t_125 w64_RemoteStoragePublishFileResult_t_125; +typedef struct u32_RemoteStoragePublishFileResult_t_125 u32_RemoteStoragePublishFileResult_t_125; +typedef struct w32_RemoteStoragePublishFileResult_t_125 w32_RemoteStoragePublishFileResult_t_125; +typedef struct u64_RemoteStoragePublishFileResult_t_123 u64_RemoteStoragePublishFileResult_t_123; +typedef struct w64_RemoteStoragePublishFileResult_t_123 w64_RemoteStoragePublishFileResult_t_123; +typedef struct u32_RemoteStoragePublishFileResult_t_123 u32_RemoteStoragePublishFileResult_t_123; +typedef struct w32_RemoteStoragePublishFileResult_t_123 w32_RemoteStoragePublishFileResult_t_123; +typedef struct w64_RemoteStoragePublishFileResult_t_116x u64_RemoteStoragePublishFileResult_t_116x; +typedef struct w64_RemoteStoragePublishFileResult_t_116x w64_RemoteStoragePublishFileResult_t_116x; +typedef struct u32_RemoteStoragePublishFileResult_t_116x u32_RemoteStoragePublishFileResult_t_116x; +typedef struct w32_RemoteStoragePublishFileResult_t_116x w32_RemoteStoragePublishFileResult_t_116x; +typedef struct u64_RemoteStoragePublishedFileUpdated_t u64_RemoteStoragePublishedFileUpdated_t; +typedef struct w64_RemoteStoragePublishedFileUpdated_t w64_RemoteStoragePublishedFileUpdated_t; +typedef struct u32_RemoteStoragePublishedFileUpdated_t u32_RemoteStoragePublishedFileUpdated_t; +typedef struct w32_RemoteStoragePublishedFileUpdated_t w32_RemoteStoragePublishedFileUpdated_t; +typedef struct u64_RemoteStorageSetUserPublishedFileActionResult_t_123 u64_RemoteStorageSetUserPublishedFileActionResult_t_123; +typedef struct w64_RemoteStorageSetUserPublishedFileActionResult_t_123 w64_RemoteStorageSetUserPublishedFileActionResult_t_123; +typedef struct u32_RemoteStorageSetUserPublishedFileActionResult_t_123 u32_RemoteStorageSetUserPublishedFileActionResult_t_123; +typedef struct w32_RemoteStorageSetUserPublishedFileActionResult_t_123 w32_RemoteStorageSetUserPublishedFileActionResult_t_123; +typedef struct w64_RemoteStorageSetUserPublishedFileActionResult_t_119 u64_RemoteStorageSetUserPublishedFileActionResult_t_119; +typedef struct w64_RemoteStorageSetUserPublishedFileActionResult_t_119 w64_RemoteStorageSetUserPublishedFileActionResult_t_119; +typedef struct u32_RemoteStorageSetUserPublishedFileActionResult_t_119 u32_RemoteStorageSetUserPublishedFileActionResult_t_119; +typedef struct w32_RemoteStorageSetUserPublishedFileActionResult_t_119 w32_RemoteStorageSetUserPublishedFileActionResult_t_119; +typedef struct u64_RemoteStorageSubscribePublishedFileResult_t_123 u64_RemoteStorageSubscribePublishedFileResult_t_123; +typedef struct w64_RemoteStorageSubscribePublishedFileResult_t_123 w64_RemoteStorageSubscribePublishedFileResult_t_123; +typedef struct u32_RemoteStorageSubscribePublishedFileResult_t_123 u32_RemoteStorageSubscribePublishedFileResult_t_123; +typedef struct w32_RemoteStorageSubscribePublishedFileResult_t_123 w32_RemoteStorageSubscribePublishedFileResult_t_123; +typedef struct w64_RemoteStorageSubscribePublishedFileResult_t_116x u64_RemoteStorageSubscribePublishedFileResult_t_116x; +typedef struct w64_RemoteStorageSubscribePublishedFileResult_t_116x w64_RemoteStorageSubscribePublishedFileResult_t_116x; +typedef struct w32_RemoteStorageSubscribePublishedFileResult_t_116x u32_RemoteStorageSubscribePublishedFileResult_t_116x; +typedef struct w32_RemoteStorageSubscribePublishedFileResult_t_116x w32_RemoteStorageSubscribePublishedFileResult_t_116x; +typedef struct u64_RemoteStorageUnsubscribePublishedFileResult_t_123 u64_RemoteStorageUnsubscribePublishedFileResult_t_123; +typedef struct w64_RemoteStorageUnsubscribePublishedFileResult_t_123 w64_RemoteStorageUnsubscribePublishedFileResult_t_123; +typedef struct u32_RemoteStorageUnsubscribePublishedFileResult_t_123 u32_RemoteStorageUnsubscribePublishedFileResult_t_123; +typedef struct w32_RemoteStorageUnsubscribePublishedFileResult_t_123 w32_RemoteStorageUnsubscribePublishedFileResult_t_123; +typedef struct w64_RemoteStorageUnsubscribePublishedFileResult_t_116x u64_RemoteStorageUnsubscribePublishedFileResult_t_116x; +typedef struct w64_RemoteStorageUnsubscribePublishedFileResult_t_116x w64_RemoteStorageUnsubscribePublishedFileResult_t_116x; +typedef struct w32_RemoteStorageUnsubscribePublishedFileResult_t_116x u32_RemoteStorageUnsubscribePublishedFileResult_t_116x; +typedef struct w32_RemoteStorageUnsubscribePublishedFileResult_t_116x w32_RemoteStorageUnsubscribePublishedFileResult_t_116x; +typedef struct w64_RemoteStorageUpdatePublishedFileRequest_t u64_RemoteStorageUpdatePublishedFileRequest_t; +typedef struct w64_RemoteStorageUpdatePublishedFileRequest_t w64_RemoteStorageUpdatePublishedFileRequest_t; +typedef struct w32_RemoteStorageUpdatePublishedFileRequest_t u32_RemoteStorageUpdatePublishedFileRequest_t; +typedef struct w32_RemoteStorageUpdatePublishedFileRequest_t w32_RemoteStorageUpdatePublishedFileRequest_t; +typedef struct u64_RemoteStorageUpdatePublishedFileResult_t_125 u64_RemoteStorageUpdatePublishedFileResult_t_125; +typedef struct w64_RemoteStorageUpdatePublishedFileResult_t_125 w64_RemoteStorageUpdatePublishedFileResult_t_125; +typedef struct u32_RemoteStorageUpdatePublishedFileResult_t_125 u32_RemoteStorageUpdatePublishedFileResult_t_125; +typedef struct w32_RemoteStorageUpdatePublishedFileResult_t_125 w32_RemoteStorageUpdatePublishedFileResult_t_125; +typedef struct u64_RemoteStorageUpdatePublishedFileResult_t_123 u64_RemoteStorageUpdatePublishedFileResult_t_123; +typedef struct w64_RemoteStorageUpdatePublishedFileResult_t_123 w64_RemoteStorageUpdatePublishedFileResult_t_123; +typedef struct u32_RemoteStorageUpdatePublishedFileResult_t_123 u32_RemoteStorageUpdatePublishedFileResult_t_123; +typedef struct w32_RemoteStorageUpdatePublishedFileResult_t_123 w32_RemoteStorageUpdatePublishedFileResult_t_123; +typedef struct w64_RemoteStorageUpdatePublishedFileResult_t_116x u64_RemoteStorageUpdatePublishedFileResult_t_116x; +typedef struct w64_RemoteStorageUpdatePublishedFileResult_t_116x w64_RemoteStorageUpdatePublishedFileResult_t_116x; +typedef struct u32_RemoteStorageUpdatePublishedFileResult_t_116x u32_RemoteStorageUpdatePublishedFileResult_t_116x; +typedef struct w32_RemoteStorageUpdatePublishedFileResult_t_116x w32_RemoteStorageUpdatePublishedFileResult_t_116x; +typedef struct u64_RemoteStorageUpdateUserPublishedItemVoteResult_t_123 u64_RemoteStorageUpdateUserPublishedItemVoteResult_t_123; +typedef struct w64_RemoteStorageUpdateUserPublishedItemVoteResult_t_123 w64_RemoteStorageUpdateUserPublishedItemVoteResult_t_123; +typedef struct u32_RemoteStorageUpdateUserPublishedItemVoteResult_t_123 u32_RemoteStorageUpdateUserPublishedItemVoteResult_t_123; +typedef struct w32_RemoteStorageUpdateUserPublishedItemVoteResult_t_123 w32_RemoteStorageUpdateUserPublishedItemVoteResult_t_123; +typedef struct w64_RemoteStorageUpdateUserPublishedItemVoteResult_t_119 u64_RemoteStorageUpdateUserPublishedItemVoteResult_t_119; +typedef struct w64_RemoteStorageUpdateUserPublishedItemVoteResult_t_119 w64_RemoteStorageUpdateUserPublishedItemVoteResult_t_119; +typedef struct u32_RemoteStorageUpdateUserPublishedItemVoteResult_t_119 u32_RemoteStorageUpdateUserPublishedItemVoteResult_t_119; +typedef struct w32_RemoteStorageUpdateUserPublishedItemVoteResult_t_119 w32_RemoteStorageUpdateUserPublishedItemVoteResult_t_119; +typedef struct u64_RemoteStorageUserVoteDetails_t_123 u64_RemoteStorageUserVoteDetails_t_123; +typedef struct w64_RemoteStorageUserVoteDetails_t_123 w64_RemoteStorageUserVoteDetails_t_123; +typedef struct u32_RemoteStorageUserVoteDetails_t_123 u32_RemoteStorageUserVoteDetails_t_123; +typedef struct w32_RemoteStorageUserVoteDetails_t_123 w32_RemoteStorageUserVoteDetails_t_123; +typedef struct w64_RemoteStorageUserVoteDetails_t_119 u64_RemoteStorageUserVoteDetails_t_119; +typedef struct w64_RemoteStorageUserVoteDetails_t_119 w64_RemoteStorageUserVoteDetails_t_119; +typedef struct u32_RemoteStorageUserVoteDetails_t_119 u32_RemoteStorageUserVoteDetails_t_119; +typedef struct w32_RemoteStorageUserVoteDetails_t_119 w32_RemoteStorageUserVoteDetails_t_119; +typedef struct u64_RemoveAppDependencyResult_t u64_RemoveAppDependencyResult_t; +typedef struct w64_RemoveAppDependencyResult_t w64_RemoveAppDependencyResult_t; +typedef struct u32_RemoveAppDependencyResult_t u32_RemoveAppDependencyResult_t; +typedef struct w32_RemoveAppDependencyResult_t w32_RemoveAppDependencyResult_t; +typedef struct u64_RemoveUGCDependencyResult_t u64_RemoveUGCDependencyResult_t; +typedef struct w64_RemoveUGCDependencyResult_t w64_RemoveUGCDependencyResult_t; +typedef struct u32_RemoveUGCDependencyResult_t u32_RemoveUGCDependencyResult_t; +typedef struct w32_RemoveUGCDependencyResult_t w32_RemoveUGCDependencyResult_t; +typedef struct u64_RequestPlayersForGameFinalResultCallback_t u64_RequestPlayersForGameFinalResultCallback_t; +typedef struct w64_RequestPlayersForGameFinalResultCallback_t w64_RequestPlayersForGameFinalResultCallback_t; +typedef struct u32_RequestPlayersForGameFinalResultCallback_t u32_RequestPlayersForGameFinalResultCallback_t; +typedef struct w32_RequestPlayersForGameFinalResultCallback_t w32_RequestPlayersForGameFinalResultCallback_t; +typedef struct u64_RequestPlayersForGameProgressCallback_t u64_RequestPlayersForGameProgressCallback_t; +typedef struct w64_RequestPlayersForGameProgressCallback_t w64_RequestPlayersForGameProgressCallback_t; +typedef struct u32_RequestPlayersForGameProgressCallback_t u32_RequestPlayersForGameProgressCallback_t; +typedef struct w32_RequestPlayersForGameProgressCallback_t w32_RequestPlayersForGameProgressCallback_t; +typedef struct u64_RequestPlayersForGameResultCallback_t u64_RequestPlayersForGameResultCallback_t; +typedef struct w64_RequestPlayersForGameResultCallback_t w64_RequestPlayersForGameResultCallback_t; +typedef struct u32_RequestPlayersForGameResultCallback_t u32_RequestPlayersForGameResultCallback_t; +typedef struct w32_RequestPlayersForGameResultCallback_t w32_RequestPlayersForGameResultCallback_t; +typedef struct u64_SteamInputConfigurationLoaded_t u64_SteamInputConfigurationLoaded_t; +typedef struct w64_SteamInputConfigurationLoaded_t w64_SteamInputConfigurationLoaded_t; +typedef struct u32_SteamInputConfigurationLoaded_t u32_SteamInputConfigurationLoaded_t; +typedef struct w32_SteamInputConfigurationLoaded_t w32_SteamInputConfigurationLoaded_t; +typedef struct u64_SteamInputGamepadSlotChange_t u64_SteamInputGamepadSlotChange_t; +typedef struct w64_SteamInputGamepadSlotChange_t w64_SteamInputGamepadSlotChange_t; +typedef struct u32_SteamInputGamepadSlotChange_t u32_SteamInputGamepadSlotChange_t; +typedef struct w32_SteamInputGamepadSlotChange_t w32_SteamInputGamepadSlotChange_t; +typedef struct u64_SteamInventoryStartPurchaseResult_t u64_SteamInventoryStartPurchaseResult_t; +typedef struct w64_SteamInventoryStartPurchaseResult_t w64_SteamInventoryStartPurchaseResult_t; +typedef struct u32_SteamInventoryStartPurchaseResult_t u32_SteamInventoryStartPurchaseResult_t; +typedef struct w32_SteamInventoryStartPurchaseResult_t w32_SteamInventoryStartPurchaseResult_t; +typedef struct u64_SteamNetConnectionStatusChangedCallback_t_153a u64_SteamNetConnectionStatusChangedCallback_t_153a; +typedef struct w64_SteamNetConnectionStatusChangedCallback_t_153a w64_SteamNetConnectionStatusChangedCallback_t_153a; +typedef struct u32_SteamNetConnectionStatusChangedCallback_t_153a u32_SteamNetConnectionStatusChangedCallback_t_153a; +typedef struct w32_SteamNetConnectionStatusChangedCallback_t_153a w32_SteamNetConnectionStatusChangedCallback_t_153a; +typedef struct u64_SteamNetConnectionStatusChangedCallback_t_144 u64_SteamNetConnectionStatusChangedCallback_t_144; +typedef struct w64_SteamNetConnectionStatusChangedCallback_t_144 w64_SteamNetConnectionStatusChangedCallback_t_144; +typedef struct u32_SteamNetConnectionStatusChangedCallback_t_144 u32_SteamNetConnectionStatusChangedCallback_t_144; +typedef struct w32_SteamNetConnectionStatusChangedCallback_t_144 w32_SteamNetConnectionStatusChangedCallback_t_144; +typedef struct u64_SteamNetConnectionStatusChangedCallback_t_151 u64_SteamNetConnectionStatusChangedCallback_t_151; +typedef struct w64_SteamNetConnectionStatusChangedCallback_t_151 w64_SteamNetConnectionStatusChangedCallback_t_151; +typedef struct u32_SteamNetConnectionStatusChangedCallback_t_151 u32_SteamNetConnectionStatusChangedCallback_t_151; +typedef struct w32_SteamNetConnectionStatusChangedCallback_t_151 w32_SteamNetConnectionStatusChangedCallback_t_151; +typedef struct u64_SteamNetworkingMessage_t_153a u64_SteamNetworkingMessage_t_153a; +typedef struct w64_SteamNetworkingMessage_t_153a w64_SteamNetworkingMessage_t_153a; +typedef struct u32_SteamNetworkingMessage_t_153a u32_SteamNetworkingMessage_t_153a; +typedef struct w32_SteamNetworkingMessage_t_153a w32_SteamNetworkingMessage_t_153a; +typedef struct u64_SteamNetworkingMessage_t_147 u64_SteamNetworkingMessage_t_147; +typedef struct w64_SteamNetworkingMessage_t_147 w64_SteamNetworkingMessage_t_147; +typedef struct u32_SteamNetworkingMessage_t_147 u32_SteamNetworkingMessage_t_147; +typedef struct w32_SteamNetworkingMessage_t_147 w32_SteamNetworkingMessage_t_147; +typedef struct u64_SteamNetworkingMessage_t_151 u64_SteamNetworkingMessage_t_151; +typedef struct w64_SteamNetworkingMessage_t_151 w64_SteamNetworkingMessage_t_151; +typedef struct u32_SteamNetworkingMessage_t_151 u32_SteamNetworkingMessage_t_151; +typedef struct w32_SteamNetworkingMessage_t_151 w32_SteamNetworkingMessage_t_151; +typedef struct u64_SteamNetworkingMessage_t_144 u64_SteamNetworkingMessage_t_144; +typedef struct w64_SteamNetworkingMessage_t_144 w64_SteamNetworkingMessage_t_144; +typedef struct u32_SteamNetworkingMessage_t_144 u32_SteamNetworkingMessage_t_144; +typedef struct w32_SteamNetworkingMessage_t_144 w32_SteamNetworkingMessage_t_144; +typedef struct w64_SteamParamStringArray_t u64_SteamParamStringArray_t; +typedef struct w64_SteamParamStringArray_t w64_SteamParamStringArray_t; +typedef struct w32_SteamParamStringArray_t u32_SteamParamStringArray_t; +typedef struct w32_SteamParamStringArray_t w32_SteamParamStringArray_t; +typedef struct u64_SteamPartyBeaconLocation_t u64_SteamPartyBeaconLocation_t; +typedef struct w64_SteamPartyBeaconLocation_t w64_SteamPartyBeaconLocation_t; +typedef struct u32_SteamPartyBeaconLocation_t u32_SteamPartyBeaconLocation_t; +typedef struct w32_SteamPartyBeaconLocation_t w32_SteamPartyBeaconLocation_t; +typedef struct u64_SteamUGCRequestUGCDetailsResult_t_128x u64_SteamUGCRequestUGCDetailsResult_t_128x; +typedef struct w64_SteamUGCRequestUGCDetailsResult_t_128x w64_SteamUGCRequestUGCDetailsResult_t_128x; +typedef struct u32_SteamUGCRequestUGCDetailsResult_t_128x u32_SteamUGCRequestUGCDetailsResult_t_128x; +typedef struct w32_SteamUGCRequestUGCDetailsResult_t_128x w32_SteamUGCRequestUGCDetailsResult_t_128x; +typedef struct u64_SteamUGCRequestUGCDetailsResult_t_129 u64_SteamUGCRequestUGCDetailsResult_t_129; +typedef struct w64_SteamUGCRequestUGCDetailsResult_t_129 w64_SteamUGCRequestUGCDetailsResult_t_129; +typedef struct u32_SteamUGCRequestUGCDetailsResult_t_129 u32_SteamUGCRequestUGCDetailsResult_t_129; +typedef struct w32_SteamUGCRequestUGCDetailsResult_t_129 w32_SteamUGCRequestUGCDetailsResult_t_129; +typedef struct u64_SteamUGCRequestUGCDetailsResult_t_126 u64_SteamUGCRequestUGCDetailsResult_t_126; +typedef struct w64_SteamUGCRequestUGCDetailsResult_t_126 w64_SteamUGCRequestUGCDetailsResult_t_126; +typedef struct u32_SteamUGCRequestUGCDetailsResult_t_126 u32_SteamUGCRequestUGCDetailsResult_t_126; +typedef struct w32_SteamUGCRequestUGCDetailsResult_t_126 w32_SteamUGCRequestUGCDetailsResult_t_126; +typedef struct u64_SubmitPlayerResultResultCallback_t u64_SubmitPlayerResultResultCallback_t; +typedef struct w64_SubmitPlayerResultResultCallback_t w64_SubmitPlayerResultResultCallback_t; +typedef struct u32_SubmitPlayerResultResultCallback_t u32_SubmitPlayerResultResultCallback_t; +typedef struct w32_SubmitPlayerResultResultCallback_t w32_SubmitPlayerResultResultCallback_t; +#pragma pack( push, 8 ) +struct w64_SteamUGCDetails_t_128x +{ + uint64_t m_nPublishedFileId; + uint32_t m_eResult; + uint32_t m_eFileType; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + W64_ARRAY(char, 129, m_rgchTitle); + W64_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[7]; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_rtimeAddedToUserList; + uint32_t m_eVisibility; + bool m_bBanned; + bool m_bAcceptedForUse; + bool m_bTagsTruncated; + W64_ARRAY(char, 1025, m_rgchTags); + uint8_t __pad_9212[4]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + W64_ARRAY(char, 260, m_pchFileName); + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + W64_ARRAY(char, 256, m_rgchURL); + uint32_t m_unVotesUp; + uint32_t m_unVotesDown; + float m_flScore; + uint32_t m_unNumChildren; + uint8_t __pad_9772[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_SteamUGCDetails_t_128x +{ + uint64_t m_nPublishedFileId; + uint32_t m_eResult; + uint32_t m_eFileType; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + U64_ARRAY(char, 129, m_rgchTitle); + U64_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[3]; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_rtimeAddedToUserList; + uint32_t m_eVisibility; + bool m_bBanned; + bool m_bAcceptedForUse; + bool m_bTagsTruncated; + U64_ARRAY(char, 1025, m_rgchTags); + uint64_t m_hFile; + uint64_t m_hPreviewFile; + U64_ARRAY(char, 260, m_pchFileName); + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + U64_ARRAY(char, 256, m_rgchURL); + uint32_t m_unVotesUp; + uint32_t m_unVotesDown; + float m_flScore; + uint32_t m_unNumChildren; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_SteamUGCDetails_t_128x +{ + uint64_t m_nPublishedFileId; + uint32_t m_eResult; + uint32_t m_eFileType; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + W32_ARRAY(char, 129, m_rgchTitle); + W32_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[7]; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_rtimeAddedToUserList; + uint32_t m_eVisibility; + bool m_bBanned; + bool m_bAcceptedForUse; + bool m_bTagsTruncated; + W32_ARRAY(char, 1025, m_rgchTags); + uint8_t __pad_9212[4]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + W32_ARRAY(char, 260, m_pchFileName); + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + W32_ARRAY(char, 256, m_rgchURL); + uint32_t m_unVotesUp; + uint32_t m_unVotesDown; + float m_flScore; + uint32_t m_unNumChildren; + uint8_t __pad_9772[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_SteamUGCDetails_t_128x +{ + uint64_t m_nPublishedFileId; + uint32_t m_eResult; + uint32_t m_eFileType; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + U32_ARRAY(char, 129, m_rgchTitle); + U32_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[3]; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_rtimeAddedToUserList; + uint32_t m_eVisibility; + bool m_bBanned; + bool m_bAcceptedForUse; + bool m_bTagsTruncated; + U32_ARRAY(char, 1025, m_rgchTags); + uint64_t m_hFile; + uint64_t m_hPreviewFile; + U32_ARRAY(char, 260, m_pchFileName); + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + U32_ARRAY(char, 256, m_rgchURL); + uint32_t m_unVotesUp; + uint32_t m_unVotesDown; + float m_flScore; + uint32_t m_unNumChildren; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SteamUGCDetails_t_128x w_SteamUGCDetails_t_128x; +typedef u32_SteamUGCDetails_t_128x u_SteamUGCDetails_t_128x; +#endif +#ifdef __x86_64__ +typedef w64_SteamUGCDetails_t_128x w_SteamUGCDetails_t_128x; +typedef u64_SteamUGCDetails_t_128x u_SteamUGCDetails_t_128x; +#endif + +#pragma pack( push, 8 ) +struct w64_SteamUGCDetails_t_126 +{ + uint64_t m_nPublishedFileId; + uint32_t m_eResult; + uint32_t m_eFileType; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + W64_ARRAY(char, 129, m_rgchTitle); + W64_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[7]; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_rtimeAddedToUserList; + uint32_t m_eVisibility; + bool m_bBanned; + bool m_bAcceptedForUse; + bool m_bTagsTruncated; + W64_ARRAY(char, 1025, m_rgchTags); + uint8_t __pad_9212[4]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + W64_ARRAY(char, 260, m_pchFileName); + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + W64_ARRAY(char, 256, m_rgchURL); + uint32_t m_unVotesUp; + uint32_t m_unVotesDown; + float m_flScore; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_SteamUGCDetails_t_126 +{ + uint64_t m_nPublishedFileId; + uint32_t m_eResult; + uint32_t m_eFileType; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + U64_ARRAY(char, 129, m_rgchTitle); + U64_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[3]; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_rtimeAddedToUserList; + uint32_t m_eVisibility; + bool m_bBanned; + bool m_bAcceptedForUse; + bool m_bTagsTruncated; + U64_ARRAY(char, 1025, m_rgchTags); + uint64_t m_hFile; + uint64_t m_hPreviewFile; + U64_ARRAY(char, 260, m_pchFileName); + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + U64_ARRAY(char, 256, m_rgchURL); + uint32_t m_unVotesUp; + uint32_t m_unVotesDown; + float m_flScore; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_SteamUGCDetails_t_126 +{ + uint64_t m_nPublishedFileId; + uint32_t m_eResult; + uint32_t m_eFileType; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + W32_ARRAY(char, 129, m_rgchTitle); + W32_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[7]; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_rtimeAddedToUserList; + uint32_t m_eVisibility; + bool m_bBanned; + bool m_bAcceptedForUse; + bool m_bTagsTruncated; + W32_ARRAY(char, 1025, m_rgchTags); + uint8_t __pad_9212[4]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + W32_ARRAY(char, 260, m_pchFileName); + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + W32_ARRAY(char, 256, m_rgchURL); + uint32_t m_unVotesUp; + uint32_t m_unVotesDown; + float m_flScore; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_SteamUGCDetails_t_126 +{ + uint64_t m_nPublishedFileId; + uint32_t m_eResult; + uint32_t m_eFileType; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + U32_ARRAY(char, 129, m_rgchTitle); + U32_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[3]; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_rtimeAddedToUserList; + uint32_t m_eVisibility; + bool m_bBanned; + bool m_bAcceptedForUse; + bool m_bTagsTruncated; + U32_ARRAY(char, 1025, m_rgchTags); + uint64_t m_hFile; + uint64_t m_hPreviewFile; + U32_ARRAY(char, 260, m_pchFileName); + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + U32_ARRAY(char, 256, m_rgchURL); + uint32_t m_unVotesUp; + uint32_t m_unVotesDown; + float m_flScore; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SteamUGCDetails_t_126 w_SteamUGCDetails_t_126; +typedef u32_SteamUGCDetails_t_126 u_SteamUGCDetails_t_126; +#endif +#ifdef __x86_64__ +typedef w64_SteamUGCDetails_t_126 w_SteamUGCDetails_t_126; +typedef u64_SteamUGCDetails_t_126 u_SteamUGCDetails_t_126; +#endif + +#pragma pack( push, 8 ) +struct w64_AddAppDependencyResult_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_nAppID; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_AddAppDependencyResult_t +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint32_t m_nAppID; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_AddAppDependencyResult_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_nAppID; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_AddAppDependencyResult_t +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint32_t m_nAppID; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_AddAppDependencyResult_t w_AddAppDependencyResult_t; +typedef u32_AddAppDependencyResult_t u_AddAppDependencyResult_t; +#endif +#ifdef __x86_64__ +typedef w64_AddAppDependencyResult_t w_AddAppDependencyResult_t; +typedef u64_AddAppDependencyResult_t u_AddAppDependencyResult_t; +#endif + +#pragma pack( push, 8 ) +struct w64_AddUGCDependencyResult_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint64_t m_nChildPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_AddUGCDependencyResult_t +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint64_t m_nChildPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_AddUGCDependencyResult_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint64_t m_nChildPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_AddUGCDependencyResult_t +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint64_t m_nChildPublishedFileId; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_AddUGCDependencyResult_t w_AddUGCDependencyResult_t; +typedef u32_AddUGCDependencyResult_t u_AddUGCDependencyResult_t; +#endif +#ifdef __x86_64__ +typedef w64_AddUGCDependencyResult_t w_AddUGCDependencyResult_t; +typedef u64_AddUGCDependencyResult_t u_AddUGCDependencyResult_t; +#endif + +#pragma pack( push, 8 ) +struct w64_CSteamAPIContext_143 +{ + W64_PTR(void /*ISteamClient*/ *m_pSteamClient, m_pSteamClient); + W64_PTR(void /*ISteamUser*/ *m_pSteamUser, m_pSteamUser); + W64_PTR(void /*ISteamFriends*/ *m_pSteamFriends, m_pSteamFriends); + W64_PTR(void /*ISteamUtils*/ *m_pSteamUtils, m_pSteamUtils); + W64_PTR(void /*ISteamMatchmaking*/ *m_pSteamMatchmaking, m_pSteamMatchmaking); + W64_PTR(void /*ISteamGameSearch*/ *m_pSteamGameSearch, m_pSteamGameSearch); + W64_PTR(void /*ISteamUserStats*/ *m_pSteamUserStats, m_pSteamUserStats); + W64_PTR(void /*ISteamApps*/ *m_pSteamApps, m_pSteamApps); + W64_PTR(void /*ISteamMatchmakingServers*/ *m_pSteamMatchmakingServers, m_pSteamMatchmakingServers); + W64_PTR(void /*ISteamNetworking*/ *m_pSteamNetworking, m_pSteamNetworking); + W64_PTR(void /*ISteamRemoteStorage*/ *m_pSteamRemoteStorage, m_pSteamRemoteStorage); + W64_PTR(void /*ISteamScreenshots*/ *m_pSteamScreenshots, m_pSteamScreenshots); + W64_PTR(void /*ISteamHTTP*/ *m_pSteamHTTP, m_pSteamHTTP); + W64_PTR(void /*ISteamController*/ *m_pController, m_pController); + W64_PTR(void /*ISteamUGC*/ *m_pSteamUGC, m_pSteamUGC); + W64_PTR(void /*ISteamAppList*/ *m_pSteamAppList, m_pSteamAppList); + W64_PTR(void /*ISteamMusic*/ *m_pSteamMusic, m_pSteamMusic); + W64_PTR(void /*ISteamMusicRemote*/ *m_pSteamMusicRemote, m_pSteamMusicRemote); + W64_PTR(void /*ISteamHTMLSurface*/ *m_pSteamHTMLSurface, m_pSteamHTMLSurface); + W64_PTR(void /*ISteamInventory*/ *m_pSteamInventory, m_pSteamInventory); + W64_PTR(void /*ISteamVideo*/ *m_pSteamVideo, m_pSteamVideo); + W64_PTR(void /*ISteamParentalSettings*/ *m_pSteamParentalSettings, m_pSteamParentalSettings); + W64_PTR(void /*ISteamInput*/ *m_pSteamInput, m_pSteamInput); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_CSteamAPIContext_143 +{ + W32_PTR(void /*ISteamClient*/ *m_pSteamClient, m_pSteamClient); + W32_PTR(void /*ISteamUser*/ *m_pSteamUser, m_pSteamUser); + W32_PTR(void /*ISteamFriends*/ *m_pSteamFriends, m_pSteamFriends); + W32_PTR(void /*ISteamUtils*/ *m_pSteamUtils, m_pSteamUtils); + W32_PTR(void /*ISteamMatchmaking*/ *m_pSteamMatchmaking, m_pSteamMatchmaking); + W32_PTR(void /*ISteamGameSearch*/ *m_pSteamGameSearch, m_pSteamGameSearch); + W32_PTR(void /*ISteamUserStats*/ *m_pSteamUserStats, m_pSteamUserStats); + W32_PTR(void /*ISteamApps*/ *m_pSteamApps, m_pSteamApps); + W32_PTR(void /*ISteamMatchmakingServers*/ *m_pSteamMatchmakingServers, m_pSteamMatchmakingServers); + W32_PTR(void /*ISteamNetworking*/ *m_pSteamNetworking, m_pSteamNetworking); + W32_PTR(void /*ISteamRemoteStorage*/ *m_pSteamRemoteStorage, m_pSteamRemoteStorage); + W32_PTR(void /*ISteamScreenshots*/ *m_pSteamScreenshots, m_pSteamScreenshots); + W32_PTR(void /*ISteamHTTP*/ *m_pSteamHTTP, m_pSteamHTTP); + W32_PTR(void /*ISteamController*/ *m_pController, m_pController); + W32_PTR(void /*ISteamUGC*/ *m_pSteamUGC, m_pSteamUGC); + W32_PTR(void /*ISteamAppList*/ *m_pSteamAppList, m_pSteamAppList); + W32_PTR(void /*ISteamMusic*/ *m_pSteamMusic, m_pSteamMusic); + W32_PTR(void /*ISteamMusicRemote*/ *m_pSteamMusicRemote, m_pSteamMusicRemote); + W32_PTR(void /*ISteamHTMLSurface*/ *m_pSteamHTMLSurface, m_pSteamHTMLSurface); + W32_PTR(void /*ISteamInventory*/ *m_pSteamInventory, m_pSteamInventory); + W32_PTR(void /*ISteamVideo*/ *m_pSteamVideo, m_pSteamVideo); + W32_PTR(void /*ISteamParentalSettings*/ *m_pSteamParentalSettings, m_pSteamParentalSettings); + W32_PTR(void /*ISteamInput*/ *m_pSteamInput, m_pSteamInput); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_CSteamAPIContext_143 w_CSteamAPIContext_143; +typedef u32_CSteamAPIContext_143 u_CSteamAPIContext_143; +#endif +#ifdef __x86_64__ +typedef w64_CSteamAPIContext_143 w_CSteamAPIContext_143; +typedef u64_CSteamAPIContext_143 u_CSteamAPIContext_143; +#endif + +#pragma pack( push, 8 ) +struct w64_CSteamAPIContext_145 +{ + W64_PTR(void /*ISteamClient*/ *m_pSteamClient, m_pSteamClient); + W64_PTR(void /*ISteamUser*/ *m_pSteamUser, m_pSteamUser); + W64_PTR(void /*ISteamFriends*/ *m_pSteamFriends, m_pSteamFriends); + W64_PTR(void /*ISteamUtils*/ *m_pSteamUtils, m_pSteamUtils); + W64_PTR(void /*ISteamMatchmaking*/ *m_pSteamMatchmaking, m_pSteamMatchmaking); + W64_PTR(void /*ISteamGameSearch*/ *m_pSteamGameSearch, m_pSteamGameSearch); + W64_PTR(void /*ISteamUserStats*/ *m_pSteamUserStats, m_pSteamUserStats); + W64_PTR(void /*ISteamApps*/ *m_pSteamApps, m_pSteamApps); + W64_PTR(void /*ISteamMatchmakingServers*/ *m_pSteamMatchmakingServers, m_pSteamMatchmakingServers); + W64_PTR(void /*ISteamNetworking*/ *m_pSteamNetworking, m_pSteamNetworking); + W64_PTR(void /*ISteamRemoteStorage*/ *m_pSteamRemoteStorage, m_pSteamRemoteStorage); + W64_PTR(void /*ISteamScreenshots*/ *m_pSteamScreenshots, m_pSteamScreenshots); + W64_PTR(void /*ISteamHTTP*/ *m_pSteamHTTP, m_pSteamHTTP); + W64_PTR(void /*ISteamController*/ *m_pController, m_pController); + W64_PTR(void /*ISteamUGC*/ *m_pSteamUGC, m_pSteamUGC); + W64_PTR(void /*ISteamAppList*/ *m_pSteamAppList, m_pSteamAppList); + W64_PTR(void /*ISteamMusic*/ *m_pSteamMusic, m_pSteamMusic); + W64_PTR(void /*ISteamMusicRemote*/ *m_pSteamMusicRemote, m_pSteamMusicRemote); + W64_PTR(void /*ISteamHTMLSurface*/ *m_pSteamHTMLSurface, m_pSteamHTMLSurface); + W64_PTR(void /*ISteamInventory*/ *m_pSteamInventory, m_pSteamInventory); + W64_PTR(void /*ISteamVideo*/ *m_pSteamVideo, m_pSteamVideo); + W64_PTR(void /*ISteamTV*/ *m_pSteamTV, m_pSteamTV); + W64_PTR(void /*ISteamParentalSettings*/ *m_pSteamParentalSettings, m_pSteamParentalSettings); + W64_PTR(void /*ISteamInput*/ *m_pSteamInput, m_pSteamInput); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_CSteamAPIContext_145 +{ + W32_PTR(void /*ISteamClient*/ *m_pSteamClient, m_pSteamClient); + W32_PTR(void /*ISteamUser*/ *m_pSteamUser, m_pSteamUser); + W32_PTR(void /*ISteamFriends*/ *m_pSteamFriends, m_pSteamFriends); + W32_PTR(void /*ISteamUtils*/ *m_pSteamUtils, m_pSteamUtils); + W32_PTR(void /*ISteamMatchmaking*/ *m_pSteamMatchmaking, m_pSteamMatchmaking); + W32_PTR(void /*ISteamGameSearch*/ *m_pSteamGameSearch, m_pSteamGameSearch); + W32_PTR(void /*ISteamUserStats*/ *m_pSteamUserStats, m_pSteamUserStats); + W32_PTR(void /*ISteamApps*/ *m_pSteamApps, m_pSteamApps); + W32_PTR(void /*ISteamMatchmakingServers*/ *m_pSteamMatchmakingServers, m_pSteamMatchmakingServers); + W32_PTR(void /*ISteamNetworking*/ *m_pSteamNetworking, m_pSteamNetworking); + W32_PTR(void /*ISteamRemoteStorage*/ *m_pSteamRemoteStorage, m_pSteamRemoteStorage); + W32_PTR(void /*ISteamScreenshots*/ *m_pSteamScreenshots, m_pSteamScreenshots); + W32_PTR(void /*ISteamHTTP*/ *m_pSteamHTTP, m_pSteamHTTP); + W32_PTR(void /*ISteamController*/ *m_pController, m_pController); + W32_PTR(void /*ISteamUGC*/ *m_pSteamUGC, m_pSteamUGC); + W32_PTR(void /*ISteamAppList*/ *m_pSteamAppList, m_pSteamAppList); + W32_PTR(void /*ISteamMusic*/ *m_pSteamMusic, m_pSteamMusic); + W32_PTR(void /*ISteamMusicRemote*/ *m_pSteamMusicRemote, m_pSteamMusicRemote); + W32_PTR(void /*ISteamHTMLSurface*/ *m_pSteamHTMLSurface, m_pSteamHTMLSurface); + W32_PTR(void /*ISteamInventory*/ *m_pSteamInventory, m_pSteamInventory); + W32_PTR(void /*ISteamVideo*/ *m_pSteamVideo, m_pSteamVideo); + W32_PTR(void /*ISteamTV*/ *m_pSteamTV, m_pSteamTV); + W32_PTR(void /*ISteamParentalSettings*/ *m_pSteamParentalSettings, m_pSteamParentalSettings); + W32_PTR(void /*ISteamInput*/ *m_pSteamInput, m_pSteamInput); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_CSteamAPIContext_145 w_CSteamAPIContext_145; +typedef u32_CSteamAPIContext_145 u_CSteamAPIContext_145; +#endif +#ifdef __x86_64__ +typedef w64_CSteamAPIContext_145 w_CSteamAPIContext_145; +typedef u64_CSteamAPIContext_145 u_CSteamAPIContext_145; +#endif + +#pragma pack( push, 8 ) +struct w64_CSteamAPIContext_137 +{ + W64_PTR(void /*ISteamClient*/ *m_pSteamClient, m_pSteamClient); + W64_PTR(void /*ISteamUser*/ *m_pSteamUser, m_pSteamUser); + W64_PTR(void /*ISteamFriends*/ *m_pSteamFriends, m_pSteamFriends); + W64_PTR(void /*ISteamUtils*/ *m_pSteamUtils, m_pSteamUtils); + W64_PTR(void /*ISteamMatchmaking*/ *m_pSteamMatchmaking, m_pSteamMatchmaking); + W64_PTR(void /*ISteamUserStats*/ *m_pSteamUserStats, m_pSteamUserStats); + W64_PTR(void /*ISteamApps*/ *m_pSteamApps, m_pSteamApps); + W64_PTR(void /*ISteamMatchmakingServers*/ *m_pSteamMatchmakingServers, m_pSteamMatchmakingServers); + W64_PTR(void /*ISteamNetworking*/ *m_pSteamNetworking, m_pSteamNetworking); + W64_PTR(void /*ISteamRemoteStorage*/ *m_pSteamRemoteStorage, m_pSteamRemoteStorage); + W64_PTR(void /*ISteamScreenshots*/ *m_pSteamScreenshots, m_pSteamScreenshots); + W64_PTR(void /*ISteamHTTP*/ *m_pSteamHTTP, m_pSteamHTTP); + W64_PTR(void /*ISteamController*/ *m_pController, m_pController); + W64_PTR(void /*ISteamUGC*/ *m_pSteamUGC, m_pSteamUGC); + W64_PTR(void /*ISteamAppList*/ *m_pSteamAppList, m_pSteamAppList); + W64_PTR(void /*ISteamMusic*/ *m_pSteamMusic, m_pSteamMusic); + W64_PTR(void /*ISteamMusicRemote*/ *m_pSteamMusicRemote, m_pSteamMusicRemote); + W64_PTR(void /*ISteamHTMLSurface*/ *m_pSteamHTMLSurface, m_pSteamHTMLSurface); + W64_PTR(void /*ISteamInventory*/ *m_pSteamInventory, m_pSteamInventory); + W64_PTR(void /*ISteamVideo*/ *m_pSteamVideo, m_pSteamVideo); + W64_PTR(void /*ISteamParentalSettings*/ *m_pSteamParentalSettings, m_pSteamParentalSettings); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_CSteamAPIContext_137 +{ + W32_PTR(void /*ISteamClient*/ *m_pSteamClient, m_pSteamClient); + W32_PTR(void /*ISteamUser*/ *m_pSteamUser, m_pSteamUser); + W32_PTR(void /*ISteamFriends*/ *m_pSteamFriends, m_pSteamFriends); + W32_PTR(void /*ISteamUtils*/ *m_pSteamUtils, m_pSteamUtils); + W32_PTR(void /*ISteamMatchmaking*/ *m_pSteamMatchmaking, m_pSteamMatchmaking); + W32_PTR(void /*ISteamUserStats*/ *m_pSteamUserStats, m_pSteamUserStats); + W32_PTR(void /*ISteamApps*/ *m_pSteamApps, m_pSteamApps); + W32_PTR(void /*ISteamMatchmakingServers*/ *m_pSteamMatchmakingServers, m_pSteamMatchmakingServers); + W32_PTR(void /*ISteamNetworking*/ *m_pSteamNetworking, m_pSteamNetworking); + W32_PTR(void /*ISteamRemoteStorage*/ *m_pSteamRemoteStorage, m_pSteamRemoteStorage); + W32_PTR(void /*ISteamScreenshots*/ *m_pSteamScreenshots, m_pSteamScreenshots); + W32_PTR(void /*ISteamHTTP*/ *m_pSteamHTTP, m_pSteamHTTP); + W32_PTR(void /*ISteamController*/ *m_pController, m_pController); + W32_PTR(void /*ISteamUGC*/ *m_pSteamUGC, m_pSteamUGC); + W32_PTR(void /*ISteamAppList*/ *m_pSteamAppList, m_pSteamAppList); + W32_PTR(void /*ISteamMusic*/ *m_pSteamMusic, m_pSteamMusic); + W32_PTR(void /*ISteamMusicRemote*/ *m_pSteamMusicRemote, m_pSteamMusicRemote); + W32_PTR(void /*ISteamHTMLSurface*/ *m_pSteamHTMLSurface, m_pSteamHTMLSurface); + W32_PTR(void /*ISteamInventory*/ *m_pSteamInventory, m_pSteamInventory); + W32_PTR(void /*ISteamVideo*/ *m_pSteamVideo, m_pSteamVideo); + W32_PTR(void /*ISteamParentalSettings*/ *m_pSteamParentalSettings, m_pSteamParentalSettings); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_CSteamAPIContext_137 w_CSteamAPIContext_137; +typedef u32_CSteamAPIContext_137 u_CSteamAPIContext_137; +#endif +#ifdef __x86_64__ +typedef w64_CSteamAPIContext_137 w_CSteamAPIContext_137; +typedef u64_CSteamAPIContext_137 u_CSteamAPIContext_137; +#endif + +#pragma pack( push, 8 ) +struct w64_CSteamAPIContext_141 +{ + W64_PTR(void /*ISteamClient*/ *m_pSteamClient, m_pSteamClient); + W64_PTR(void /*ISteamUser*/ *m_pSteamUser, m_pSteamUser); + W64_PTR(void /*ISteamFriends*/ *m_pSteamFriends, m_pSteamFriends); + W64_PTR(void /*ISteamUtils*/ *m_pSteamUtils, m_pSteamUtils); + W64_PTR(void /*ISteamMatchmaking*/ *m_pSteamMatchmaking, m_pSteamMatchmaking); + W64_PTR(void /*ISteamUserStats*/ *m_pSteamUserStats, m_pSteamUserStats); + W64_PTR(void /*ISteamApps*/ *m_pSteamApps, m_pSteamApps); + W64_PTR(void /*ISteamMatchmakingServers*/ *m_pSteamMatchmakingServers, m_pSteamMatchmakingServers); + W64_PTR(void /*ISteamNetworking*/ *m_pSteamNetworking, m_pSteamNetworking); + W64_PTR(void /*ISteamRemoteStorage*/ *m_pSteamRemoteStorage, m_pSteamRemoteStorage); + W64_PTR(void /*ISteamScreenshots*/ *m_pSteamScreenshots, m_pSteamScreenshots); + W64_PTR(void /*ISteamHTTP*/ *m_pSteamHTTP, m_pSteamHTTP); + W64_PTR(void /*ISteamUnifiedMessages*/ *m_pSteamUnifiedMessages, m_pSteamUnifiedMessages); + W64_PTR(void /*ISteamController*/ *m_pController, m_pController); + W64_PTR(void /*ISteamUGC*/ *m_pSteamUGC, m_pSteamUGC); + W64_PTR(void /*ISteamAppList*/ *m_pSteamAppList, m_pSteamAppList); + W64_PTR(void /*ISteamMusic*/ *m_pSteamMusic, m_pSteamMusic); + W64_PTR(void /*ISteamMusicRemote*/ *m_pSteamMusicRemote, m_pSteamMusicRemote); + W64_PTR(void /*ISteamHTMLSurface*/ *m_pSteamHTMLSurface, m_pSteamHTMLSurface); + W64_PTR(void /*ISteamInventory*/ *m_pSteamInventory, m_pSteamInventory); + W64_PTR(void /*ISteamVideo*/ *m_pSteamVideo, m_pSteamVideo); + W64_PTR(void /*ISteamParentalSettings*/ *m_pSteamParentalSettings, m_pSteamParentalSettings); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_CSteamAPIContext_141 +{ + W32_PTR(void /*ISteamClient*/ *m_pSteamClient, m_pSteamClient); + W32_PTR(void /*ISteamUser*/ *m_pSteamUser, m_pSteamUser); + W32_PTR(void /*ISteamFriends*/ *m_pSteamFriends, m_pSteamFriends); + W32_PTR(void /*ISteamUtils*/ *m_pSteamUtils, m_pSteamUtils); + W32_PTR(void /*ISteamMatchmaking*/ *m_pSteamMatchmaking, m_pSteamMatchmaking); + W32_PTR(void /*ISteamUserStats*/ *m_pSteamUserStats, m_pSteamUserStats); + W32_PTR(void /*ISteamApps*/ *m_pSteamApps, m_pSteamApps); + W32_PTR(void /*ISteamMatchmakingServers*/ *m_pSteamMatchmakingServers, m_pSteamMatchmakingServers); + W32_PTR(void /*ISteamNetworking*/ *m_pSteamNetworking, m_pSteamNetworking); + W32_PTR(void /*ISteamRemoteStorage*/ *m_pSteamRemoteStorage, m_pSteamRemoteStorage); + W32_PTR(void /*ISteamScreenshots*/ *m_pSteamScreenshots, m_pSteamScreenshots); + W32_PTR(void /*ISteamHTTP*/ *m_pSteamHTTP, m_pSteamHTTP); + W32_PTR(void /*ISteamUnifiedMessages*/ *m_pSteamUnifiedMessages, m_pSteamUnifiedMessages); + W32_PTR(void /*ISteamController*/ *m_pController, m_pController); + W32_PTR(void /*ISteamUGC*/ *m_pSteamUGC, m_pSteamUGC); + W32_PTR(void /*ISteamAppList*/ *m_pSteamAppList, m_pSteamAppList); + W32_PTR(void /*ISteamMusic*/ *m_pSteamMusic, m_pSteamMusic); + W32_PTR(void /*ISteamMusicRemote*/ *m_pSteamMusicRemote, m_pSteamMusicRemote); + W32_PTR(void /*ISteamHTMLSurface*/ *m_pSteamHTMLSurface, m_pSteamHTMLSurface); + W32_PTR(void /*ISteamInventory*/ *m_pSteamInventory, m_pSteamInventory); + W32_PTR(void /*ISteamVideo*/ *m_pSteamVideo, m_pSteamVideo); + W32_PTR(void /*ISteamParentalSettings*/ *m_pSteamParentalSettings, m_pSteamParentalSettings); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_CSteamAPIContext_141 w_CSteamAPIContext_141; +typedef u32_CSteamAPIContext_141 u_CSteamAPIContext_141; +#endif +#ifdef __x86_64__ +typedef w64_CSteamAPIContext_141 w_CSteamAPIContext_141; +typedef u64_CSteamAPIContext_141 u_CSteamAPIContext_141; +#endif + +struct w_CSteamCallback +{ +#ifdef __cplusplus + virtual const char * GetCallbackName( ) = 0; + virtual uint32_t GetCallbackID( ) = 0; + virtual uint8_t * GetFixedData( ) = 0; + virtual uint32_t GetFixedSize( ) = 0; + virtual uint32_t GetNumMemberVariables( ) = 0; + virtual bool GetMemberVariable( uint32_t, uint32_t *, uint32_t *, uint32_t *, const char **, const char ** ) = 0; +#endif /* __cplusplus */ +}; + +struct u_CSteamCallback +{ +#ifdef __cplusplus + virtual const char * GetCallbackName( ) = 0; + virtual uint32_t GetCallbackID( ) = 0; + virtual uint8_t * GetFixedData( ) = 0; + virtual uint32_t GetFixedSize( ) = 0; + virtual uint32_t GetNumMemberVariables( ) = 0; + virtual bool GetMemberVariable( uint32_t, uint32_t *, uint32_t *, uint32_t *, const char **, const char ** ) = 0; +#endif /* __cplusplus */ +}; + +#pragma pack( push, 8 ) +struct w64_CSteamGameServerAPIContext_152 +{ + W64_PTR(void /*ISteamClient*/ *m_pSteamClient, m_pSteamClient); + W64_PTR(void /*ISteamGameServer*/ *m_pSteamGameServer, m_pSteamGameServer); + W64_PTR(void /*ISteamUtils*/ *m_pSteamGameServerUtils, m_pSteamGameServerUtils); + W64_PTR(void /*ISteamNetworking*/ *m_pSteamGameServerNetworking, m_pSteamGameServerNetworking); + W64_PTR(void /*ISteamGameServerStats*/ *m_pSteamGameServerStats, m_pSteamGameServerStats); + W64_PTR(void /*ISteamHTTP*/ *m_pSteamHTTP, m_pSteamHTTP); + W64_PTR(void /*ISteamInventory*/ *m_pSteamInventory, m_pSteamInventory); + W64_PTR(void /*ISteamUGC*/ *m_pSteamUGC, m_pSteamUGC); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_CSteamGameServerAPIContext_152 +{ + W32_PTR(void /*ISteamClient*/ *m_pSteamClient, m_pSteamClient); + W32_PTR(void /*ISteamGameServer*/ *m_pSteamGameServer, m_pSteamGameServer); + W32_PTR(void /*ISteamUtils*/ *m_pSteamGameServerUtils, m_pSteamGameServerUtils); + W32_PTR(void /*ISteamNetworking*/ *m_pSteamGameServerNetworking, m_pSteamGameServerNetworking); + W32_PTR(void /*ISteamGameServerStats*/ *m_pSteamGameServerStats, m_pSteamGameServerStats); + W32_PTR(void /*ISteamHTTP*/ *m_pSteamHTTP, m_pSteamHTTP); + W32_PTR(void /*ISteamInventory*/ *m_pSteamInventory, m_pSteamInventory); + W32_PTR(void /*ISteamUGC*/ *m_pSteamUGC, m_pSteamUGC); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_CSteamGameServerAPIContext_152 w_CSteamGameServerAPIContext_152; +typedef u32_CSteamGameServerAPIContext_152 u_CSteamGameServerAPIContext_152; +#endif +#ifdef __x86_64__ +typedef w64_CSteamGameServerAPIContext_152 w_CSteamGameServerAPIContext_152; +typedef u64_CSteamGameServerAPIContext_152 u_CSteamGameServerAPIContext_152; +#endif + +#pragma pack( push, 8 ) +struct w64_CSteamGameServerAPIContext_143 +{ + W64_PTR(void /*ISteamClient*/ *m_pSteamClient, m_pSteamClient); + W64_PTR(void /*ISteamGameServer*/ *m_pSteamGameServer, m_pSteamGameServer); + W64_PTR(void /*ISteamUtils*/ *m_pSteamGameServerUtils, m_pSteamGameServerUtils); + W64_PTR(void /*ISteamNetworking*/ *m_pSteamGameServerNetworking, m_pSteamGameServerNetworking); + W64_PTR(void /*ISteamGameServerStats*/ *m_pSteamGameServerStats, m_pSteamGameServerStats); + W64_PTR(void /*ISteamHTTP*/ *m_pSteamHTTP, m_pSteamHTTP); + W64_PTR(void /*ISteamInventory*/ *m_pSteamInventory, m_pSteamInventory); + W64_PTR(void /*ISteamUGC*/ *m_pSteamUGC, m_pSteamUGC); + W64_PTR(void /*ISteamApps*/ *m_pSteamApps, m_pSteamApps); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_CSteamGameServerAPIContext_143 +{ + W32_PTR(void /*ISteamClient*/ *m_pSteamClient, m_pSteamClient); + W32_PTR(void /*ISteamGameServer*/ *m_pSteamGameServer, m_pSteamGameServer); + W32_PTR(void /*ISteamUtils*/ *m_pSteamGameServerUtils, m_pSteamGameServerUtils); + W32_PTR(void /*ISteamNetworking*/ *m_pSteamGameServerNetworking, m_pSteamGameServerNetworking); + W32_PTR(void /*ISteamGameServerStats*/ *m_pSteamGameServerStats, m_pSteamGameServerStats); + W32_PTR(void /*ISteamHTTP*/ *m_pSteamHTTP, m_pSteamHTTP); + W32_PTR(void /*ISteamInventory*/ *m_pSteamInventory, m_pSteamInventory); + W32_PTR(void /*ISteamUGC*/ *m_pSteamUGC, m_pSteamUGC); + W32_PTR(void /*ISteamApps*/ *m_pSteamApps, m_pSteamApps); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_CSteamGameServerAPIContext_143 w_CSteamGameServerAPIContext_143; +typedef u32_CSteamGameServerAPIContext_143 u_CSteamGameServerAPIContext_143; +#endif +#ifdef __x86_64__ +typedef w64_CSteamGameServerAPIContext_143 w_CSteamGameServerAPIContext_143; +typedef u64_CSteamGameServerAPIContext_143 u_CSteamGameServerAPIContext_143; +#endif + +#pragma pack( push, 8 ) +struct w64_CallbackMsg_t +{ + int32_t m_hSteamUser; + int32_t m_iCallback; + W64_PTR(uint8_t *m_pubParam, m_pubParam); + int32_t m_cubParam; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_CallbackMsg_t +{ + int32_t m_hSteamUser; + int32_t m_iCallback; + W32_PTR(uint8_t *m_pubParam, m_pubParam); + int32_t m_cubParam; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_CallbackMsg_t w_CallbackMsg_t; +typedef u32_CallbackMsg_t u_CallbackMsg_t; +#endif +#ifdef __x86_64__ +typedef w64_CallbackMsg_t w_CallbackMsg_t; +typedef u64_CallbackMsg_t u_CallbackMsg_t; +#endif + +#pragma pack( push, 8 ) +struct w64_CreateBeaconCallback_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_ulBeaconID; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_CreateBeaconCallback_t +{ + uint32_t m_eResult; + uint64_t m_ulBeaconID; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_CreateBeaconCallback_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_ulBeaconID; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_CreateBeaconCallback_t +{ + uint32_t m_eResult; + uint64_t m_ulBeaconID; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_CreateBeaconCallback_t w_CreateBeaconCallback_t; +typedef u32_CreateBeaconCallback_t u_CreateBeaconCallback_t; +#endif +#ifdef __x86_64__ +typedef w64_CreateBeaconCallback_t w_CreateBeaconCallback_t; +typedef u64_CreateBeaconCallback_t u_CreateBeaconCallback_t; +#endif + +#pragma pack( push, 8 ) +struct w64_CreateItemResult_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + bool m_bUserNeedsToAcceptWorkshopLegalAgreement; + uint8_t __pad_17[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_CreateItemResult_t +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + bool m_bUserNeedsToAcceptWorkshopLegalAgreement; + uint8_t __pad_13[3]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_CreateItemResult_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + bool m_bUserNeedsToAcceptWorkshopLegalAgreement; + uint8_t __pad_17[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_CreateItemResult_t +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + bool m_bUserNeedsToAcceptWorkshopLegalAgreement; + uint8_t __pad_13[3]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_CreateItemResult_t w_CreateItemResult_t; +typedef u32_CreateItemResult_t u_CreateItemResult_t; +#endif +#ifdef __x86_64__ +typedef w64_CreateItemResult_t w_CreateItemResult_t; +typedef u64_CreateItemResult_t u_CreateItemResult_t; +#endif + +#pragma pack( push, 8 ) +struct w64_DeleteItemResult_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_DeleteItemResult_t +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_DeleteItemResult_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_DeleteItemResult_t +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_DeleteItemResult_t w_DeleteItemResult_t; +typedef u32_DeleteItemResult_t u_DeleteItemResult_t; +#endif +#ifdef __x86_64__ +typedef w64_DeleteItemResult_t w_DeleteItemResult_t; +typedef u64_DeleteItemResult_t u_DeleteItemResult_t; +#endif + +#pragma pack( push, 8 ) +struct w64_DownloadItemResult_t +{ + uint32_t m_unAppID; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_eResult; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_DownloadItemResult_t +{ + uint32_t m_unAppID; + uint64_t m_nPublishedFileId; + uint32_t m_eResult; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_DownloadItemResult_t +{ + uint32_t m_unAppID; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_eResult; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_DownloadItemResult_t +{ + uint32_t m_unAppID; + uint64_t m_nPublishedFileId; + uint32_t m_eResult; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_DownloadItemResult_t w_DownloadItemResult_t; +typedef u32_DownloadItemResult_t u_DownloadItemResult_t; +#endif +#ifdef __x86_64__ +typedef w64_DownloadItemResult_t w_DownloadItemResult_t; +typedef u64_DownloadItemResult_t u_DownloadItemResult_t; +#endif + +#pragma pack( push, 8 ) +struct w64_EndGameResultCallback_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t ullUniqueGameID; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_EndGameResultCallback_t +{ + uint32_t m_eResult; + uint64_t ullUniqueGameID; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_EndGameResultCallback_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t ullUniqueGameID; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_EndGameResultCallback_t +{ + uint32_t m_eResult; + uint64_t ullUniqueGameID; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_EndGameResultCallback_t w_EndGameResultCallback_t; +typedef u32_EndGameResultCallback_t u_EndGameResultCallback_t; +#endif +#ifdef __x86_64__ +typedef w64_EndGameResultCallback_t w_EndGameResultCallback_t; +typedef u64_EndGameResultCallback_t u_EndGameResultCallback_t; +#endif + +#pragma pack( push, 8 ) +struct w64_FileDetailsResult_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_ulFileSize; + W64_ARRAY(uint8_t, 20, m_FileSHA); + uint32_t m_unFlags; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_FileDetailsResult_t +{ + uint32_t m_eResult; + uint64_t m_ulFileSize; + U64_ARRAY(uint8_t, 20, m_FileSHA); + uint32_t m_unFlags; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_FileDetailsResult_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_ulFileSize; + W32_ARRAY(uint8_t, 20, m_FileSHA); + uint32_t m_unFlags; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_FileDetailsResult_t +{ + uint32_t m_eResult; + uint64_t m_ulFileSize; + U32_ARRAY(uint8_t, 20, m_FileSHA); + uint32_t m_unFlags; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_FileDetailsResult_t w_FileDetailsResult_t; +typedef u32_FileDetailsResult_t u_FileDetailsResult_t; +#endif +#ifdef __x86_64__ +typedef w64_FileDetailsResult_t w_FileDetailsResult_t; +typedef u64_FileDetailsResult_t u_FileDetailsResult_t; +#endif + +#pragma pack( push, 8 ) +struct w64_GSReputation_t_123 +{ + uint32_t m_eResult; + uint32_t m_unReputationScore; + bool m_bBanned; + uint8_t __pad_9[3]; + uint32_t m_unBannedIP; + uint16_t m_usBannedPort; + uint8_t __pad_18[6]; + uint64_t m_ulBannedGameID; + uint32_t m_unBanExpires; + uint8_t __pad_36[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_GSReputation_t_123 +{ + uint32_t m_eResult; + uint32_t m_unReputationScore; + bool m_bBanned; + uint8_t __pad_9[3]; + uint32_t m_unBannedIP; + uint16_t m_usBannedPort; + uint8_t __pad_18[2]; + uint64_t m_ulBannedGameID; + uint32_t m_unBanExpires; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_GSReputation_t_123 +{ + uint32_t m_eResult; + uint32_t m_unReputationScore; + bool m_bBanned; + uint8_t __pad_9[3]; + uint32_t m_unBannedIP; + uint16_t m_usBannedPort; + uint8_t __pad_18[6]; + uint64_t m_ulBannedGameID; + uint32_t m_unBanExpires; + uint8_t __pad_36[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_GSReputation_t_123 +{ + uint32_t m_eResult; + uint32_t m_unReputationScore; + bool m_bBanned; + uint8_t __pad_9[3]; + uint32_t m_unBannedIP; + uint16_t m_usBannedPort; + uint8_t __pad_18[2]; + uint64_t m_ulBannedGameID; + uint32_t m_unBanExpires; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_GSReputation_t_123 w_GSReputation_t_123; +typedef u32_GSReputation_t_123 u_GSReputation_t_123; +#endif +#ifdef __x86_64__ +typedef w64_GSReputation_t_123 w_GSReputation_t_123; +typedef u64_GSReputation_t_123 u_GSReputation_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_GSReputation_t_108 +{ + uint32_t m_eResult; + uint32_t m_unReputationScore; + bool m_bBanned; + uint8_t __pad_9[3]; + uint32_t m_unBannedIP; + uint16_t m_usBannedPort; + uint8_t __pad_18[6]; + uint64_t m_ulBannedGameID; + uint32_t m_unBanExpires; + uint8_t __pad_36[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_GSReputation_t_108 +{ + uint32_t m_eResult; + uint32_t m_unReputationScore; + bool m_bBanned; + uint8_t __pad_9[3]; + uint32_t m_unBannedIP; + uint16_t m_usBannedPort; + uint8_t __pad_18[6]; + uint64_t m_ulBannedGameID; + uint32_t m_unBanExpires; + uint8_t __pad_36[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_GSReputation_t_108 +{ + uint32_t m_eResult; + uint32_t m_unReputationScore; + bool m_bBanned; + uint8_t __pad_9[3]; + uint32_t m_unBannedIP; + uint16_t m_usBannedPort; + uint8_t __pad_18[2]; + uint64_t m_ulBannedGameID; + uint32_t m_unBanExpires; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_GSReputation_t_108 w_GSReputation_t_108; +typedef u32_GSReputation_t_108 u_GSReputation_t_108; +#endif +#ifdef __x86_64__ +typedef w64_GSReputation_t_108 w_GSReputation_t_108; +typedef u64_GSReputation_t_108 u_GSReputation_t_108; +#endif + +#pragma pack( push, 8 ) +struct w64_GetAppDependenciesResult_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + W64_ARRAY(uint32_t, 32, m_rgAppIDs); + uint32_t m_nNumAppDependencies; + uint32_t m_nTotalNumAppDependencies; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_GetAppDependenciesResult_t +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + U64_ARRAY(uint32_t, 32, m_rgAppIDs); + uint32_t m_nNumAppDependencies; + uint32_t m_nTotalNumAppDependencies; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_GetAppDependenciesResult_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + W32_ARRAY(uint32_t, 32, m_rgAppIDs); + uint32_t m_nNumAppDependencies; + uint32_t m_nTotalNumAppDependencies; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_GetAppDependenciesResult_t +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + U32_ARRAY(uint32_t, 32, m_rgAppIDs); + uint32_t m_nNumAppDependencies; + uint32_t m_nTotalNumAppDependencies; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_GetAppDependenciesResult_t w_GetAppDependenciesResult_t; +typedef u32_GetAppDependenciesResult_t u_GetAppDependenciesResult_t; +#endif +#ifdef __x86_64__ +typedef w64_GetAppDependenciesResult_t w_GetAppDependenciesResult_t; +typedef u64_GetAppDependenciesResult_t u_GetAppDependenciesResult_t; +#endif + +#pragma pack( push, 8 ) +struct w64_HTML_ChangedTitle_t +{ + uint32_t unBrowserHandle; + uint8_t __pad_4[4]; + W64_PTR(const char *pchTitle, pchTitle); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTML_ChangedTitle_t +{ + uint32_t unBrowserHandle; + U64_PTR(const char *pchTitle, pchTitle); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_HTML_ChangedTitle_t +{ + uint32_t unBrowserHandle; + W32_PTR(const char *pchTitle, pchTitle); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTML_ChangedTitle_t w_HTML_ChangedTitle_t; +typedef u32_HTML_ChangedTitle_t u_HTML_ChangedTitle_t; +#endif +#ifdef __x86_64__ +typedef w64_HTML_ChangedTitle_t w_HTML_ChangedTitle_t; +typedef u64_HTML_ChangedTitle_t u_HTML_ChangedTitle_t; +#endif + +#pragma pack( push, 8 ) +struct w64_HTML_ComboNeedsPaint_t +{ + uint32_t unBrowserHandle; + uint8_t __pad_4[4]; + W64_PTR(const char *pBGRA, pBGRA); + uint32_t unWide; + uint32_t unTall; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTML_ComboNeedsPaint_t +{ + uint32_t unBrowserHandle; + U64_PTR(const char *pBGRA, pBGRA); + uint32_t unWide; + uint32_t unTall; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_HTML_ComboNeedsPaint_t +{ + uint32_t unBrowserHandle; + W32_PTR(const char *pBGRA, pBGRA); + uint32_t unWide; + uint32_t unTall; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTML_ComboNeedsPaint_t w_HTML_ComboNeedsPaint_t; +typedef u32_HTML_ComboNeedsPaint_t u_HTML_ComboNeedsPaint_t; +#endif +#ifdef __x86_64__ +typedef w64_HTML_ComboNeedsPaint_t w_HTML_ComboNeedsPaint_t; +typedef u64_HTML_ComboNeedsPaint_t u_HTML_ComboNeedsPaint_t; +#endif + +#pragma pack( push, 8 ) +struct w64_HTML_FileOpenDialog_t +{ + uint32_t unBrowserHandle; + uint8_t __pad_4[4]; + W64_PTR(const char *pchTitle, pchTitle); + W64_PTR(const char *pchInitialFile, pchInitialFile); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTML_FileOpenDialog_t +{ + uint32_t unBrowserHandle; + U64_PTR(const char *pchTitle, pchTitle); + U64_PTR(const char *pchInitialFile, pchInitialFile); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_HTML_FileOpenDialog_t +{ + uint32_t unBrowserHandle; + W32_PTR(const char *pchTitle, pchTitle); + W32_PTR(const char *pchInitialFile, pchInitialFile); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_HTML_FileOpenDialog_t +{ + uint32_t unBrowserHandle; + U32_PTR(const char *pchTitle, pchTitle); + U32_PTR(const char *pchInitialFile, pchInitialFile); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTML_FileOpenDialog_t w_HTML_FileOpenDialog_t; +typedef u32_HTML_FileOpenDialog_t u_HTML_FileOpenDialog_t; +#endif +#ifdef __x86_64__ +typedef w64_HTML_FileOpenDialog_t w_HTML_FileOpenDialog_t; +typedef u64_HTML_FileOpenDialog_t u_HTML_FileOpenDialog_t; +#endif + +#pragma pack( push, 8 ) +struct w64_HTML_FinishedRequest_t +{ + uint32_t unBrowserHandle; + uint8_t __pad_4[4]; + W64_PTR(const char *pchURL, pchURL); + W64_PTR(const char *pchPageTitle, pchPageTitle); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTML_FinishedRequest_t +{ + uint32_t unBrowserHandle; + U64_PTR(const char *pchURL, pchURL); + U64_PTR(const char *pchPageTitle, pchPageTitle); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_HTML_FinishedRequest_t +{ + uint32_t unBrowserHandle; + W32_PTR(const char *pchURL, pchURL); + W32_PTR(const char *pchPageTitle, pchPageTitle); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_HTML_FinishedRequest_t +{ + uint32_t unBrowserHandle; + U32_PTR(const char *pchURL, pchURL); + U32_PTR(const char *pchPageTitle, pchPageTitle); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTML_FinishedRequest_t w_HTML_FinishedRequest_t; +typedef u32_HTML_FinishedRequest_t u_HTML_FinishedRequest_t; +#endif +#ifdef __x86_64__ +typedef w64_HTML_FinishedRequest_t w_HTML_FinishedRequest_t; +typedef u64_HTML_FinishedRequest_t u_HTML_FinishedRequest_t; +#endif + +#pragma pack( push, 8 ) +struct w64_HTML_JSAlert_t +{ + uint32_t unBrowserHandle; + uint8_t __pad_4[4]; + W64_PTR(const char *pchMessage, pchMessage); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTML_JSAlert_t +{ + uint32_t unBrowserHandle; + U64_PTR(const char *pchMessage, pchMessage); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_HTML_JSAlert_t +{ + uint32_t unBrowserHandle; + W32_PTR(const char *pchMessage, pchMessage); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTML_JSAlert_t w_HTML_JSAlert_t; +typedef u32_HTML_JSAlert_t u_HTML_JSAlert_t; +#endif +#ifdef __x86_64__ +typedef w64_HTML_JSAlert_t w_HTML_JSAlert_t; +typedef u64_HTML_JSAlert_t u_HTML_JSAlert_t; +#endif + +#pragma pack( push, 8 ) +struct w64_HTML_JSConfirm_t +{ + uint32_t unBrowserHandle; + uint8_t __pad_4[4]; + W64_PTR(const char *pchMessage, pchMessage); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTML_JSConfirm_t +{ + uint32_t unBrowserHandle; + U64_PTR(const char *pchMessage, pchMessage); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_HTML_JSConfirm_t +{ + uint32_t unBrowserHandle; + W32_PTR(const char *pchMessage, pchMessage); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTML_JSConfirm_t w_HTML_JSConfirm_t; +typedef u32_HTML_JSConfirm_t u_HTML_JSConfirm_t; +#endif +#ifdef __x86_64__ +typedef w64_HTML_JSConfirm_t w_HTML_JSConfirm_t; +typedef u64_HTML_JSConfirm_t u_HTML_JSConfirm_t; +#endif + +#pragma pack( push, 8 ) +struct w64_HTML_LinkAtPosition_t +{ + uint32_t unBrowserHandle; + uint32_t x; + uint32_t y; + uint8_t __pad_12[4]; + W64_PTR(const char *pchURL, pchURL); + bool bInput; + bool bLiveLink; + uint8_t __pad_26[6]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTML_LinkAtPosition_t +{ + uint32_t unBrowserHandle; + uint32_t x; + uint32_t y; + U64_PTR(const char *pchURL, pchURL); + bool bInput; + bool bLiveLink; + uint8_t __pad_22[2]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_HTML_LinkAtPosition_t +{ + uint32_t unBrowserHandle; + uint32_t x; + uint32_t y; + W32_PTR(const char *pchURL, pchURL); + bool bInput; + bool bLiveLink; + uint8_t __pad_18[2]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_HTML_LinkAtPosition_t +{ + uint32_t unBrowserHandle; + uint32_t x; + uint32_t y; + U32_PTR(const char *pchURL, pchURL); + bool bInput; + bool bLiveLink; + uint8_t __pad_18[2]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTML_LinkAtPosition_t w_HTML_LinkAtPosition_t; +typedef u32_HTML_LinkAtPosition_t u_HTML_LinkAtPosition_t; +#endif +#ifdef __x86_64__ +typedef w64_HTML_LinkAtPosition_t w_HTML_LinkAtPosition_t; +typedef u64_HTML_LinkAtPosition_t u_HTML_LinkAtPosition_t; +#endif + +#pragma pack( push, 8 ) +struct w64_HTML_NeedsPaint_t +{ + uint32_t unBrowserHandle; + uint8_t __pad_4[4]; + W64_PTR(const char *pBGRA, pBGRA); + uint32_t unWide; + uint32_t unTall; + uint32_t unUpdateX; + uint32_t unUpdateY; + uint32_t unUpdateWide; + uint32_t unUpdateTall; + uint32_t unScrollX; + uint32_t unScrollY; + float flPageScale; + uint32_t unPageSerial; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTML_NeedsPaint_t +{ + uint32_t unBrowserHandle; + U64_PTR(const char *pBGRA, pBGRA); + uint32_t unWide; + uint32_t unTall; + uint32_t unUpdateX; + uint32_t unUpdateY; + uint32_t unUpdateWide; + uint32_t unUpdateTall; + uint32_t unScrollX; + uint32_t unScrollY; + float flPageScale; + uint32_t unPageSerial; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_HTML_NeedsPaint_t +{ + uint32_t unBrowserHandle; + W32_PTR(const char *pBGRA, pBGRA); + uint32_t unWide; + uint32_t unTall; + uint32_t unUpdateX; + uint32_t unUpdateY; + uint32_t unUpdateWide; + uint32_t unUpdateTall; + uint32_t unScrollX; + uint32_t unScrollY; + float flPageScale; + uint32_t unPageSerial; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTML_NeedsPaint_t w_HTML_NeedsPaint_t; +typedef u32_HTML_NeedsPaint_t u_HTML_NeedsPaint_t; +#endif +#ifdef __x86_64__ +typedef w64_HTML_NeedsPaint_t w_HTML_NeedsPaint_t; +typedef u64_HTML_NeedsPaint_t u_HTML_NeedsPaint_t; +#endif + +#pragma pack( push, 8 ) +struct w64_HTML_NewWindow_t_132x +{ + uint32_t unBrowserHandle; + uint8_t __pad_4[4]; + W64_PTR(const char *pchURL, pchURL); + uint32_t unX; + uint32_t unY; + uint32_t unWide; + uint32_t unTall; + uint32_t unNewWindow_BrowserHandle_IGNORE; + uint8_t __pad_36[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTML_NewWindow_t_132x +{ + uint32_t unBrowserHandle; + U64_PTR(const char *pchURL, pchURL); + uint32_t unX; + uint32_t unY; + uint32_t unWide; + uint32_t unTall; + uint32_t unNewWindow_BrowserHandle_IGNORE; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_HTML_NewWindow_t_132x +{ + uint32_t unBrowserHandle; + W32_PTR(const char *pchURL, pchURL); + uint32_t unX; + uint32_t unY; + uint32_t unWide; + uint32_t unTall; + uint32_t unNewWindow_BrowserHandle_IGNORE; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_HTML_NewWindow_t_132x +{ + uint32_t unBrowserHandle; + U32_PTR(const char *pchURL, pchURL); + uint32_t unX; + uint32_t unY; + uint32_t unWide; + uint32_t unTall; + uint32_t unNewWindow_BrowserHandle_IGNORE; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTML_NewWindow_t_132x w_HTML_NewWindow_t_132x; +typedef u32_HTML_NewWindow_t_132x u_HTML_NewWindow_t_132x; +#endif +#ifdef __x86_64__ +typedef w64_HTML_NewWindow_t_132x w_HTML_NewWindow_t_132x; +typedef u64_HTML_NewWindow_t_132x u_HTML_NewWindow_t_132x; +#endif + +#pragma pack( push, 8 ) +struct w64_HTML_NewWindow_t_130x +{ + uint32_t unBrowserHandle; + uint8_t __pad_4[4]; + W64_PTR(const char *pchURL, pchURL); + uint32_t unX; + uint32_t unY; + uint32_t unWide; + uint32_t unTall; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTML_NewWindow_t_130x +{ + uint32_t unBrowserHandle; + U64_PTR(const char *pchURL, pchURL); + uint32_t unX; + uint32_t unY; + uint32_t unWide; + uint32_t unTall; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_HTML_NewWindow_t_130x +{ + uint32_t unBrowserHandle; + W32_PTR(const char *pchURL, pchURL); + uint32_t unX; + uint32_t unY; + uint32_t unWide; + uint32_t unTall; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_HTML_NewWindow_t_130x +{ + uint32_t unBrowserHandle; + U32_PTR(const char *pchURL, pchURL); + uint32_t unX; + uint32_t unY; + uint32_t unWide; + uint32_t unTall; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTML_NewWindow_t_130x w_HTML_NewWindow_t_130x; +typedef u32_HTML_NewWindow_t_130x u_HTML_NewWindow_t_130x; +#endif +#ifdef __x86_64__ +typedef w64_HTML_NewWindow_t_130x w_HTML_NewWindow_t_130x; +typedef u64_HTML_NewWindow_t_130x u_HTML_NewWindow_t_130x; +#endif + +#pragma pack( push, 8 ) +struct w64_HTML_OpenLinkInNewTab_t +{ + uint32_t unBrowserHandle; + uint8_t __pad_4[4]; + W64_PTR(const char *pchURL, pchURL); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTML_OpenLinkInNewTab_t +{ + uint32_t unBrowserHandle; + U64_PTR(const char *pchURL, pchURL); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_HTML_OpenLinkInNewTab_t +{ + uint32_t unBrowserHandle; + W32_PTR(const char *pchURL, pchURL); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_HTML_OpenLinkInNewTab_t +{ + uint32_t unBrowserHandle; + U32_PTR(const char *pchURL, pchURL); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTML_OpenLinkInNewTab_t w_HTML_OpenLinkInNewTab_t; +typedef u32_HTML_OpenLinkInNewTab_t u_HTML_OpenLinkInNewTab_t; +#endif +#ifdef __x86_64__ +typedef w64_HTML_OpenLinkInNewTab_t w_HTML_OpenLinkInNewTab_t; +typedef u64_HTML_OpenLinkInNewTab_t u_HTML_OpenLinkInNewTab_t; +#endif + +#pragma pack( push, 8 ) +struct w64_HTML_ShowToolTip_t +{ + uint32_t unBrowserHandle; + uint8_t __pad_4[4]; + W64_PTR(const char *pchMsg, pchMsg); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTML_ShowToolTip_t +{ + uint32_t unBrowserHandle; + U64_PTR(const char *pchMsg, pchMsg); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_HTML_ShowToolTip_t +{ + uint32_t unBrowserHandle; + W32_PTR(const char *pchMsg, pchMsg); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTML_ShowToolTip_t w_HTML_ShowToolTip_t; +typedef u32_HTML_ShowToolTip_t u_HTML_ShowToolTip_t; +#endif +#ifdef __x86_64__ +typedef w64_HTML_ShowToolTip_t w_HTML_ShowToolTip_t; +typedef u64_HTML_ShowToolTip_t u_HTML_ShowToolTip_t; +#endif + +#pragma pack( push, 8 ) +struct w64_HTML_StartRequest_t +{ + uint32_t unBrowserHandle; + uint8_t __pad_4[4]; + W64_PTR(const char *pchURL, pchURL); + W64_PTR(const char *pchTarget, pchTarget); + W64_PTR(const char *pchPostData, pchPostData); + bool bIsRedirect; + uint8_t __pad_33[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTML_StartRequest_t +{ + uint32_t unBrowserHandle; + U64_PTR(const char *pchURL, pchURL); + U64_PTR(const char *pchTarget, pchTarget); + U64_PTR(const char *pchPostData, pchPostData); + bool bIsRedirect; + uint8_t __pad_29[3]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_HTML_StartRequest_t +{ + uint32_t unBrowserHandle; + W32_PTR(const char *pchURL, pchURL); + W32_PTR(const char *pchTarget, pchTarget); + W32_PTR(const char *pchPostData, pchPostData); + bool bIsRedirect; + uint8_t __pad_17[3]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_HTML_StartRequest_t +{ + uint32_t unBrowserHandle; + U32_PTR(const char *pchURL, pchURL); + U32_PTR(const char *pchTarget, pchTarget); + U32_PTR(const char *pchPostData, pchPostData); + bool bIsRedirect; + uint8_t __pad_17[3]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTML_StartRequest_t w_HTML_StartRequest_t; +typedef u32_HTML_StartRequest_t u_HTML_StartRequest_t; +#endif +#ifdef __x86_64__ +typedef w64_HTML_StartRequest_t w_HTML_StartRequest_t; +typedef u64_HTML_StartRequest_t u_HTML_StartRequest_t; +#endif + +#pragma pack( push, 8 ) +struct w64_HTML_StatusText_t +{ + uint32_t unBrowserHandle; + uint8_t __pad_4[4]; + W64_PTR(const char *pchMsg, pchMsg); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTML_StatusText_t +{ + uint32_t unBrowserHandle; + U64_PTR(const char *pchMsg, pchMsg); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_HTML_StatusText_t +{ + uint32_t unBrowserHandle; + W32_PTR(const char *pchMsg, pchMsg); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTML_StatusText_t w_HTML_StatusText_t; +typedef u32_HTML_StatusText_t u_HTML_StatusText_t; +#endif +#ifdef __x86_64__ +typedef w64_HTML_StatusText_t w_HTML_StatusText_t; +typedef u64_HTML_StatusText_t u_HTML_StatusText_t; +#endif + +#pragma pack( push, 8 ) +struct w64_HTML_URLChanged_t +{ + uint32_t unBrowserHandle; + uint8_t __pad_4[4]; + W64_PTR(const char *pchURL, pchURL); + W64_PTR(const char *pchPostData, pchPostData); + bool bIsRedirect; + uint8_t __pad_25[7]; + W64_PTR(const char *pchPageTitle, pchPageTitle); + bool bNewNavigation; + uint8_t __pad_41[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTML_URLChanged_t +{ + uint32_t unBrowserHandle; + U64_PTR(const char *pchURL, pchURL); + U64_PTR(const char *pchPostData, pchPostData); + bool bIsRedirect; + uint8_t __pad_21[3]; + U64_PTR(const char *pchPageTitle, pchPageTitle); + bool bNewNavigation; + uint8_t __pad_33[3]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_HTML_URLChanged_t +{ + uint32_t unBrowserHandle; + W32_PTR(const char *pchURL, pchURL); + W32_PTR(const char *pchPostData, pchPostData); + bool bIsRedirect; + uint8_t __pad_13[3]; + W32_PTR(const char *pchPageTitle, pchPageTitle); + bool bNewNavigation; + uint8_t __pad_21[3]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_HTML_URLChanged_t +{ + uint32_t unBrowserHandle; + U32_PTR(const char *pchURL, pchURL); + U32_PTR(const char *pchPostData, pchPostData); + bool bIsRedirect; + uint8_t __pad_13[3]; + U32_PTR(const char *pchPageTitle, pchPageTitle); + bool bNewNavigation; + uint8_t __pad_21[3]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTML_URLChanged_t w_HTML_URLChanged_t; +typedef u32_HTML_URLChanged_t u_HTML_URLChanged_t; +#endif +#ifdef __x86_64__ +typedef w64_HTML_URLChanged_t w_HTML_URLChanged_t; +typedef u64_HTML_URLChanged_t u_HTML_URLChanged_t; +#endif + +#pragma pack( push, 8 ) +struct w64_HTML_UpdateToolTip_t +{ + uint32_t unBrowserHandle; + uint8_t __pad_4[4]; + W64_PTR(const char *pchMsg, pchMsg); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTML_UpdateToolTip_t +{ + uint32_t unBrowserHandle; + U64_PTR(const char *pchMsg, pchMsg); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_HTML_UpdateToolTip_t +{ + uint32_t unBrowserHandle; + W32_PTR(const char *pchMsg, pchMsg); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTML_UpdateToolTip_t w_HTML_UpdateToolTip_t; +typedef u32_HTML_UpdateToolTip_t u_HTML_UpdateToolTip_t; +#endif +#ifdef __x86_64__ +typedef w64_HTML_UpdateToolTip_t w_HTML_UpdateToolTip_t; +typedef u64_HTML_UpdateToolTip_t u_HTML_UpdateToolTip_t; +#endif + +#pragma pack( push, 8 ) +struct w64_HTTPRequestCompleted_t_132x +{ + uint32_t m_hRequest; + uint8_t __pad_4[4]; + uint64_t m_ulContextValue; + bool m_bRequestSuccessful; + uint8_t __pad_17[3]; + uint32_t m_eStatusCode; + uint32_t m_unBodySize; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTTPRequestCompleted_t_132x +{ + uint32_t m_hRequest; + uint64_t m_ulContextValue; + bool m_bRequestSuccessful; + uint8_t __pad_13[3]; + uint32_t m_eStatusCode; + uint32_t m_unBodySize; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_HTTPRequestCompleted_t_132x +{ + uint32_t m_hRequest; + uint8_t __pad_4[4]; + uint64_t m_ulContextValue; + bool m_bRequestSuccessful; + uint8_t __pad_17[3]; + uint32_t m_eStatusCode; + uint32_t m_unBodySize; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_HTTPRequestCompleted_t_132x +{ + uint32_t m_hRequest; + uint64_t m_ulContextValue; + bool m_bRequestSuccessful; + uint8_t __pad_13[3]; + uint32_t m_eStatusCode; + uint32_t m_unBodySize; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTTPRequestCompleted_t_132x w_HTTPRequestCompleted_t_132x; +typedef u32_HTTPRequestCompleted_t_132x u_HTTPRequestCompleted_t_132x; +#endif +#ifdef __x86_64__ +typedef w64_HTTPRequestCompleted_t_132x w_HTTPRequestCompleted_t_132x; +typedef u64_HTTPRequestCompleted_t_132x u_HTTPRequestCompleted_t_132x; +#endif + +#pragma pack( push, 8 ) +struct w64_HTTPRequestCompleted_t_123 +{ + uint32_t m_hRequest; + uint8_t __pad_4[4]; + uint64_t m_ulContextValue; + bool m_bRequestSuccessful; + uint8_t __pad_17[3]; + uint32_t m_eStatusCode; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTTPRequestCompleted_t_123 +{ + uint32_t m_hRequest; + uint64_t m_ulContextValue; + bool m_bRequestSuccessful; + uint8_t __pad_13[3]; + uint32_t m_eStatusCode; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_HTTPRequestCompleted_t_123 +{ + uint32_t m_hRequest; + uint8_t __pad_4[4]; + uint64_t m_ulContextValue; + bool m_bRequestSuccessful; + uint8_t __pad_17[3]; + uint32_t m_eStatusCode; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_HTTPRequestCompleted_t_123 +{ + uint32_t m_hRequest; + uint64_t m_ulContextValue; + bool m_bRequestSuccessful; + uint8_t __pad_13[3]; + uint32_t m_eStatusCode; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTTPRequestCompleted_t_123 w_HTTPRequestCompleted_t_123; +typedef u32_HTTPRequestCompleted_t_123 u_HTTPRequestCompleted_t_123; +#endif +#ifdef __x86_64__ +typedef w64_HTTPRequestCompleted_t_123 w_HTTPRequestCompleted_t_123; +typedef u64_HTTPRequestCompleted_t_123 u_HTTPRequestCompleted_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_HTTPRequestCompleted_t_115 +{ + uint32_t m_hRequest; + uint8_t __pad_4[4]; + uint64_t m_ulContextValue; + bool m_bRequestSuccessful; + uint8_t __pad_17[3]; + uint32_t m_eStatusCode; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_HTTPRequestCompleted_t_115 +{ + uint32_t m_hRequest; + uint8_t __pad_4[4]; + uint64_t m_ulContextValue; + bool m_bRequestSuccessful; + uint8_t __pad_17[3]; + uint32_t m_eStatusCode; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_HTTPRequestCompleted_t_115 +{ + uint32_t m_hRequest; + uint64_t m_ulContextValue; + bool m_bRequestSuccessful; + uint8_t __pad_13[3]; + uint32_t m_eStatusCode; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTTPRequestCompleted_t_115 w_HTTPRequestCompleted_t_115; +typedef u32_HTTPRequestCompleted_t_115 u_HTTPRequestCompleted_t_115; +#endif +#ifdef __x86_64__ +typedef w64_HTTPRequestCompleted_t_115 w_HTTPRequestCompleted_t_115; +typedef u64_HTTPRequestCompleted_t_115 u_HTTPRequestCompleted_t_115; +#endif + +#pragma pack( push, 8 ) +struct w64_HTTPRequestDataReceived_t_123 +{ + uint32_t m_hRequest; + uint8_t __pad_4[4]; + uint64_t m_ulContextValue; + uint32_t m_cOffset; + uint32_t m_cBytesReceived; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTTPRequestDataReceived_t_123 +{ + uint32_t m_hRequest; + uint64_t m_ulContextValue; + uint32_t m_cOffset; + uint32_t m_cBytesReceived; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_HTTPRequestDataReceived_t_123 +{ + uint32_t m_hRequest; + uint8_t __pad_4[4]; + uint64_t m_ulContextValue; + uint32_t m_cOffset; + uint32_t m_cBytesReceived; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_HTTPRequestDataReceived_t_123 +{ + uint32_t m_hRequest; + uint64_t m_ulContextValue; + uint32_t m_cOffset; + uint32_t m_cBytesReceived; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTTPRequestDataReceived_t_123 w_HTTPRequestDataReceived_t_123; +typedef u32_HTTPRequestDataReceived_t_123 u_HTTPRequestDataReceived_t_123; +#endif +#ifdef __x86_64__ +typedef w64_HTTPRequestDataReceived_t_123 w_HTTPRequestDataReceived_t_123; +typedef u64_HTTPRequestDataReceived_t_123 u_HTTPRequestDataReceived_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_HTTPRequestDataReceived_t_121x +{ + uint32_t m_hRequest; + uint8_t __pad_4[4]; + uint64_t m_ulContextValue; + uint32_t m_cOffset; + uint32_t m_cBytesReceived; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_HTTPRequestDataReceived_t_121x +{ + uint32_t m_hRequest; + uint8_t __pad_4[4]; + uint64_t m_ulContextValue; + uint32_t m_cOffset; + uint32_t m_cBytesReceived; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_HTTPRequestDataReceived_t_121x +{ + uint32_t m_hRequest; + uint64_t m_ulContextValue; + uint32_t m_cOffset; + uint32_t m_cBytesReceived; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTTPRequestDataReceived_t_121x w_HTTPRequestDataReceived_t_121x; +typedef u32_HTTPRequestDataReceived_t_121x u_HTTPRequestDataReceived_t_121x; +#endif +#ifdef __x86_64__ +typedef w64_HTTPRequestDataReceived_t_121x w_HTTPRequestDataReceived_t_121x; +typedef u64_HTTPRequestDataReceived_t_121x u_HTTPRequestDataReceived_t_121x; +#endif + +#pragma pack( push, 8 ) +struct w64_HTTPRequestHeadersReceived_t_123 +{ + uint32_t m_hRequest; + uint8_t __pad_4[4]; + uint64_t m_ulContextValue; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_HTTPRequestHeadersReceived_t_123 +{ + uint32_t m_hRequest; + uint64_t m_ulContextValue; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_HTTPRequestHeadersReceived_t_123 +{ + uint32_t m_hRequest; + uint8_t __pad_4[4]; + uint64_t m_ulContextValue; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_HTTPRequestHeadersReceived_t_123 +{ + uint32_t m_hRequest; + uint64_t m_ulContextValue; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTTPRequestHeadersReceived_t_123 w_HTTPRequestHeadersReceived_t_123; +typedef u32_HTTPRequestHeadersReceived_t_123 u_HTTPRequestHeadersReceived_t_123; +#endif +#ifdef __x86_64__ +typedef w64_HTTPRequestHeadersReceived_t_123 w_HTTPRequestHeadersReceived_t_123; +typedef u64_HTTPRequestHeadersReceived_t_123 u_HTTPRequestHeadersReceived_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_HTTPRequestHeadersReceived_t_121x +{ + uint32_t m_hRequest; + uint8_t __pad_4[4]; + uint64_t m_ulContextValue; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_HTTPRequestHeadersReceived_t_121x +{ + uint32_t m_hRequest; + uint8_t __pad_4[4]; + uint64_t m_ulContextValue; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_HTTPRequestHeadersReceived_t_121x +{ + uint32_t m_hRequest; + uint64_t m_ulContextValue; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_HTTPRequestHeadersReceived_t_121x w_HTTPRequestHeadersReceived_t_121x; +typedef u32_HTTPRequestHeadersReceived_t_121x u_HTTPRequestHeadersReceived_t_121x; +#endif +#ifdef __x86_64__ +typedef w64_HTTPRequestHeadersReceived_t_121x w_HTTPRequestHeadersReceived_t_121x; +typedef u64_HTTPRequestHeadersReceived_t_121x u_HTTPRequestHeadersReceived_t_121x; +#endif + +struct w_ISteamMatchmakingPingResponse +{ +#ifdef __cplusplus + virtual void ServerResponded( gameserveritem_t_105 * ) = 0; + virtual void ServerFailedToRespond( ) = 0; +#endif /* __cplusplus */ +}; + +struct u_ISteamMatchmakingPingResponse +{ +#ifdef __cplusplus + virtual void ServerResponded( gameserveritem_t_105 * ) = 0; + virtual void ServerFailedToRespond( ) = 0; +#endif /* __cplusplus */ +}; + +struct w_ISteamMatchmakingPlayersResponse +{ +#ifdef __cplusplus + virtual void AddPlayerToList( const char *, int32_t, float ) = 0; + virtual void PlayersFailedToRespond( ) = 0; + virtual void PlayersRefreshComplete( ) = 0; +#endif /* __cplusplus */ +}; + +struct u_ISteamMatchmakingPlayersResponse +{ +#ifdef __cplusplus + virtual void AddPlayerToList( const char *, int32_t, float ) = 0; + virtual void PlayersFailedToRespond( ) = 0; + virtual void PlayersRefreshComplete( ) = 0; +#endif /* __cplusplus */ +}; + +struct w_ISteamMatchmakingRulesResponse +{ +#ifdef __cplusplus + virtual void RulesResponded( const char *, const char * ) = 0; + virtual void RulesFailedToRespond( ) = 0; + virtual void RulesRefreshComplete( ) = 0; +#endif /* __cplusplus */ +}; + +struct u_ISteamMatchmakingRulesResponse +{ +#ifdef __cplusplus + virtual void RulesResponded( const char *, const char * ) = 0; + virtual void RulesFailedToRespond( ) = 0; + virtual void RulesRefreshComplete( ) = 0; +#endif /* __cplusplus */ +}; + +struct w_ISteamMatchmakingServerListResponse +{ +#ifdef __cplusplus + virtual void ServerResponded( void *, int32_t ) = 0; + virtual void ServerFailedToRespond( void *, int32_t ) = 0; + virtual void RefreshComplete( void *, uint32_t ) = 0; +#endif /* __cplusplus */ +}; + +struct u_ISteamMatchmakingServerListResponse +{ +#ifdef __cplusplus + virtual void ServerResponded( void *, int32_t ) = 0; + virtual void ServerFailedToRespond( void *, int32_t ) = 0; + virtual void RefreshComplete( void *, uint32_t ) = 0; +#endif /* __cplusplus */ +}; + +struct w_ISteamNetworkingConnectionCustomSignaling +{ +#ifdef __cplusplus + virtual bool SendSignal( uint32_t, const SteamNetConnectionInfo_t_144 *, const void *, int32_t ) = 0; + virtual void Release( ) = 0; +#endif /* __cplusplus */ +}; + +struct u_ISteamNetworkingConnectionCustomSignaling +{ +#ifdef __cplusplus + virtual bool SendSignal( uint32_t, const SteamNetConnectionInfo_t_144 *, const void *, int32_t ) = 0; + virtual void Release( ) = 0; +#endif /* __cplusplus */ +}; + +struct w_ISteamNetworkingCustomSignalingRecvContext +{ +#ifdef __cplusplus + virtual void /*ISteamNetworkingConnectionCustomSignaling*/ * OnConnectRequest( uint32_t, const SteamNetworkingIdentity_144 * ) = 0; + virtual void SendRejectionSignal( const SteamNetworkingIdentity_144 *, const void *, int32_t ) = 0; +#endif /* __cplusplus */ +}; + +struct u_ISteamNetworkingCustomSignalingRecvContext +{ +#ifdef __cplusplus + virtual void /*ISteamNetworkingConnectionCustomSignaling*/ * OnConnectRequest( uint32_t, const SteamNetworkingIdentity_144 * ) = 0; + virtual void SendRejectionSignal( const SteamNetworkingIdentity_144 *, const void *, int32_t ) = 0; +#endif /* __cplusplus */ +}; + +#pragma pack( push, 8 ) +struct w64_ItemInstalled_t +{ + uint32_t m_unAppID; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_ItemInstalled_t +{ + uint32_t m_unAppID; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_ItemInstalled_t +{ + uint32_t m_unAppID; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_ItemInstalled_t +{ + uint32_t m_unAppID; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_ItemInstalled_t w_ItemInstalled_t; +typedef u32_ItemInstalled_t u_ItemInstalled_t; +#endif +#ifdef __x86_64__ +typedef w64_ItemInstalled_t w_ItemInstalled_t; +typedef u64_ItemInstalled_t u_ItemInstalled_t; +#endif + +#pragma pack( push, 8 ) +struct w64_JoinPartyCallback_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_ulBeaconID; + CSteamID m_SteamIDBeaconOwner; + W64_ARRAY(char, 256, m_rgchConnectString); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_JoinPartyCallback_t +{ + uint32_t m_eResult; + uint64_t m_ulBeaconID; + CSteamID m_SteamIDBeaconOwner; + U64_ARRAY(char, 256, m_rgchConnectString); +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_JoinPartyCallback_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_ulBeaconID; + CSteamID m_SteamIDBeaconOwner; + W32_ARRAY(char, 256, m_rgchConnectString); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_JoinPartyCallback_t +{ + uint32_t m_eResult; + uint64_t m_ulBeaconID; + CSteamID m_SteamIDBeaconOwner; + U32_ARRAY(char, 256, m_rgchConnectString); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_JoinPartyCallback_t w_JoinPartyCallback_t; +typedef u32_JoinPartyCallback_t u_JoinPartyCallback_t; +#endif +#ifdef __x86_64__ +typedef w64_JoinPartyCallback_t w_JoinPartyCallback_t; +typedef u64_JoinPartyCallback_t u_JoinPartyCallback_t; +#endif + +#pragma pack( push, 8 ) +struct w64_LeaderboardEntry_t_123 +{ + CSteamID m_steamIDUser; + int32_t m_nGlobalRank; + int32_t m_nScore; + int32_t m_cDetails; + uint8_t __pad_20[4]; + uint64_t m_hUGC; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_LeaderboardEntry_t_123 +{ + CSteamID m_steamIDUser; + int32_t m_nGlobalRank; + int32_t m_nScore; + int32_t m_cDetails; + uint64_t m_hUGC; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_LeaderboardEntry_t_123 +{ + CSteamID m_steamIDUser; + int32_t m_nGlobalRank; + int32_t m_nScore; + int32_t m_cDetails; + uint8_t __pad_20[4]; + uint64_t m_hUGC; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_LeaderboardEntry_t_123 +{ + CSteamID m_steamIDUser; + int32_t m_nGlobalRank; + int32_t m_nScore; + int32_t m_cDetails; + uint64_t m_hUGC; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_LeaderboardEntry_t_123 w_LeaderboardEntry_t_123; +typedef u32_LeaderboardEntry_t_123 u_LeaderboardEntry_t_123; +#endif +#ifdef __x86_64__ +typedef w64_LeaderboardEntry_t_123 w_LeaderboardEntry_t_123; +typedef u64_LeaderboardEntry_t_123 u_LeaderboardEntry_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_LeaderboardEntry_t_111x +{ + CSteamID m_steamIDUser; + int32_t m_nGlobalRank; + int32_t m_nScore; + int32_t m_cDetails; + uint8_t __pad_20[4]; + uint64_t m_hUGC; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_LeaderboardEntry_t_111x +{ + CSteamID m_steamIDUser; + int32_t m_nGlobalRank; + int32_t m_nScore; + int32_t m_cDetails; + uint8_t __pad_20[4]; + uint64_t m_hUGC; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_LeaderboardEntry_t_111x +{ + CSteamID m_steamIDUser; + int32_t m_nGlobalRank; + int32_t m_nScore; + int32_t m_cDetails; + uint64_t m_hUGC; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_LeaderboardEntry_t_111x w_LeaderboardEntry_t_111x; +typedef u32_LeaderboardEntry_t_111x u_LeaderboardEntry_t_111x; +#endif +#ifdef __x86_64__ +typedef w64_LeaderboardEntry_t_111x w_LeaderboardEntry_t_111x; +typedef u64_LeaderboardEntry_t_111x u_LeaderboardEntry_t_111x; +#endif + +#pragma pack( push, 4 ) +struct w64_LeaderboardEntry_t_104 +{ + CSteamID m_steamIDUser; + int32_t m_nGlobalRank; + int32_t m_nScore; + int32_t m_cDetails; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_LeaderboardEntry_t_104 +{ + CSteamID m_steamIDUser; + int32_t m_nGlobalRank; + int32_t m_nScore; + int32_t m_cDetails; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_LeaderboardEntry_t_104 w_LeaderboardEntry_t_104; +typedef u32_LeaderboardEntry_t_104 u_LeaderboardEntry_t_104; +#endif +#ifdef __x86_64__ +typedef w64_LeaderboardEntry_t_104 w_LeaderboardEntry_t_104; +typedef u64_LeaderboardEntry_t_104 u_LeaderboardEntry_t_104; +#endif + +#pragma pack( push, 8 ) +struct w64_LeaderboardScoreUploaded_t_123 +{ + uint8_t m_bSuccess; + uint8_t __pad_1[7]; + uint64_t m_hSteamLeaderboard; + int32_t m_nScore; + uint8_t m_bScoreChanged; + uint8_t __pad_21[3]; + int32_t m_nGlobalRankNew; + int32_t m_nGlobalRankPrevious; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_LeaderboardScoreUploaded_t_123 +{ + uint8_t m_bSuccess; + uint8_t __pad_1[3]; + uint64_t m_hSteamLeaderboard; + int32_t m_nScore; + uint8_t m_bScoreChanged; + uint8_t __pad_17[3]; + int32_t m_nGlobalRankNew; + int32_t m_nGlobalRankPrevious; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_LeaderboardScoreUploaded_t_123 +{ + uint8_t m_bSuccess; + uint8_t __pad_1[7]; + uint64_t m_hSteamLeaderboard; + int32_t m_nScore; + uint8_t m_bScoreChanged; + uint8_t __pad_21[3]; + int32_t m_nGlobalRankNew; + int32_t m_nGlobalRankPrevious; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_LeaderboardScoreUploaded_t_123 +{ + uint8_t m_bSuccess; + uint8_t __pad_1[3]; + uint64_t m_hSteamLeaderboard; + int32_t m_nScore; + uint8_t m_bScoreChanged; + uint8_t __pad_17[3]; + int32_t m_nGlobalRankNew; + int32_t m_nGlobalRankPrevious; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_LeaderboardScoreUploaded_t_123 w_LeaderboardScoreUploaded_t_123; +typedef u32_LeaderboardScoreUploaded_t_123 u_LeaderboardScoreUploaded_t_123; +#endif +#ifdef __x86_64__ +typedef w64_LeaderboardScoreUploaded_t_123 w_LeaderboardScoreUploaded_t_123; +typedef u64_LeaderboardScoreUploaded_t_123 u_LeaderboardScoreUploaded_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_LeaderboardScoreUploaded_t_104 +{ + uint8_t m_bSuccess; + uint8_t __pad_1[7]; + uint64_t m_hSteamLeaderboard; + int32_t m_nScore; + uint8_t m_bScoreChanged; + uint8_t __pad_21[3]; + int32_t m_nGlobalRankNew; + int32_t m_nGlobalRankPrevious; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_LeaderboardScoreUploaded_t_104 +{ + uint8_t m_bSuccess; + uint8_t __pad_1[7]; + uint64_t m_hSteamLeaderboard; + int32_t m_nScore; + uint8_t m_bScoreChanged; + uint8_t __pad_21[3]; + int32_t m_nGlobalRankNew; + int32_t m_nGlobalRankPrevious; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_LeaderboardScoreUploaded_t_104 +{ + uint8_t m_bSuccess; + uint8_t __pad_1[3]; + uint64_t m_hSteamLeaderboard; + int32_t m_nScore; + uint8_t m_bScoreChanged; + uint8_t __pad_17[3]; + int32_t m_nGlobalRankNew; + int32_t m_nGlobalRankPrevious; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_LeaderboardScoreUploaded_t_104 w_LeaderboardScoreUploaded_t_104; +typedef u32_LeaderboardScoreUploaded_t_104 u_LeaderboardScoreUploaded_t_104; +#endif +#ifdef __x86_64__ +typedef w64_LeaderboardScoreUploaded_t_104 w_LeaderboardScoreUploaded_t_104; +typedef u64_LeaderboardScoreUploaded_t_104 u_LeaderboardScoreUploaded_t_104; +#endif + +#pragma pack( push, 8 ) +struct w64_LeaderboardUGCSet_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_hSteamLeaderboard; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_LeaderboardUGCSet_t_123 +{ + uint32_t m_eResult; + uint64_t m_hSteamLeaderboard; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_LeaderboardUGCSet_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_hSteamLeaderboard; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_LeaderboardUGCSet_t_123 +{ + uint32_t m_eResult; + uint64_t m_hSteamLeaderboard; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_LeaderboardUGCSet_t_123 w_LeaderboardUGCSet_t_123; +typedef u32_LeaderboardUGCSet_t_123 u_LeaderboardUGCSet_t_123; +#endif +#ifdef __x86_64__ +typedef w64_LeaderboardUGCSet_t_123 w_LeaderboardUGCSet_t_123; +typedef u64_LeaderboardUGCSet_t_123 u_LeaderboardUGCSet_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_LeaderboardUGCSet_t_111x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_hSteamLeaderboard; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_LeaderboardUGCSet_t_111x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_hSteamLeaderboard; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_LeaderboardUGCSet_t_111x +{ + uint32_t m_eResult; + uint64_t m_hSteamLeaderboard; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_LeaderboardUGCSet_t_111x w_LeaderboardUGCSet_t_111x; +typedef u32_LeaderboardUGCSet_t_111x u_LeaderboardUGCSet_t_111x; +#endif +#ifdef __x86_64__ +typedef w64_LeaderboardUGCSet_t_111x w_LeaderboardUGCSet_t_111x; +typedef u64_LeaderboardUGCSet_t_111x u_LeaderboardUGCSet_t_111x; +#endif + +#pragma pack( push, 8 ) +struct w64_LobbyCreated_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_ulSteamIDLobby; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_LobbyCreated_t_123 +{ + uint32_t m_eResult; + uint64_t m_ulSteamIDLobby; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_LobbyCreated_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_ulSteamIDLobby; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_LobbyCreated_t_123 +{ + uint32_t m_eResult; + uint64_t m_ulSteamIDLobby; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_LobbyCreated_t_123 w_LobbyCreated_t_123; +typedef u32_LobbyCreated_t_123 u_LobbyCreated_t_123; +#endif +#ifdef __x86_64__ +typedef w64_LobbyCreated_t_123 w_LobbyCreated_t_123; +typedef u64_LobbyCreated_t_123 u_LobbyCreated_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_LobbyCreated_t_099u +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_ulSteamIDLobby; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_LobbyCreated_t_099u +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_ulSteamIDLobby; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_LobbyCreated_t_099u +{ + uint32_t m_eResult; + uint64_t m_ulSteamIDLobby; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_LobbyCreated_t_099u w_LobbyCreated_t_099u; +typedef u32_LobbyCreated_t_099u u_LobbyCreated_t_099u; +#endif +#ifdef __x86_64__ +typedef w64_LobbyCreated_t_099u w_LobbyCreated_t_099u; +typedef u64_LobbyCreated_t_099u u_LobbyCreated_t_099u; +#endif + +#pragma pack( push, 8 ) +struct w64_MicroTxnAuthorizationResponse_t_123 +{ + uint32_t m_unAppID; + uint8_t __pad_4[4]; + uint64_t m_ulOrderID; + uint8_t m_bAuthorized; + uint8_t __pad_17[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_MicroTxnAuthorizationResponse_t_123 +{ + uint32_t m_unAppID; + uint64_t m_ulOrderID; + uint8_t m_bAuthorized; + uint8_t __pad_13[3]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_MicroTxnAuthorizationResponse_t_123 +{ + uint32_t m_unAppID; + uint8_t __pad_4[4]; + uint64_t m_ulOrderID; + uint8_t m_bAuthorized; + uint8_t __pad_17[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_MicroTxnAuthorizationResponse_t_123 +{ + uint32_t m_unAppID; + uint64_t m_ulOrderID; + uint8_t m_bAuthorized; + uint8_t __pad_13[3]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_MicroTxnAuthorizationResponse_t_123 w_MicroTxnAuthorizationResponse_t_123; +typedef u32_MicroTxnAuthorizationResponse_t_123 u_MicroTxnAuthorizationResponse_t_123; +#endif +#ifdef __x86_64__ +typedef w64_MicroTxnAuthorizationResponse_t_123 w_MicroTxnAuthorizationResponse_t_123; +typedef u64_MicroTxnAuthorizationResponse_t_123 u_MicroTxnAuthorizationResponse_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_MicroTxnAuthorizationResponse_t_109 +{ + uint32_t m_unAppID; + uint8_t __pad_4[4]; + uint64_t m_ulOrderID; + uint8_t m_bAuthorized; + uint8_t __pad_17[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_MicroTxnAuthorizationResponse_t_109 +{ + uint32_t m_unAppID; + uint8_t __pad_4[4]; + uint64_t m_ulOrderID; + uint8_t m_bAuthorized; + uint8_t __pad_17[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_MicroTxnAuthorizationResponse_t_109 +{ + uint32_t m_unAppID; + uint64_t m_ulOrderID; + uint8_t m_bAuthorized; + uint8_t __pad_13[3]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_MicroTxnAuthorizationResponse_t_109 w_MicroTxnAuthorizationResponse_t_109; +typedef u32_MicroTxnAuthorizationResponse_t_109 u_MicroTxnAuthorizationResponse_t_109; +#endif +#ifdef __x86_64__ +typedef w64_MicroTxnAuthorizationResponse_t_109 w_MicroTxnAuthorizationResponse_t_109; +typedef u64_MicroTxnAuthorizationResponse_t_109 u_MicroTxnAuthorizationResponse_t_109; +#endif + +#pragma pack( push, 8 ) +struct w64_PS3TrophiesInstalled_t_123 +{ + uint64_t m_nGameID; + uint32_t m_eResult; + uint8_t __pad_12[4]; + uint64_t m_ulRequiredDiskSpace; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_PS3TrophiesInstalled_t_123 +{ + uint64_t m_nGameID; + uint32_t m_eResult; + uint64_t m_ulRequiredDiskSpace; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_PS3TrophiesInstalled_t_123 +{ + uint64_t m_nGameID; + uint32_t m_eResult; + uint8_t __pad_12[4]; + uint64_t m_ulRequiredDiskSpace; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_PS3TrophiesInstalled_t_123 +{ + uint64_t m_nGameID; + uint32_t m_eResult; + uint64_t m_ulRequiredDiskSpace; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_PS3TrophiesInstalled_t_123 w_PS3TrophiesInstalled_t_123; +typedef u32_PS3TrophiesInstalled_t_123 u_PS3TrophiesInstalled_t_123; +#endif +#ifdef __x86_64__ +typedef w64_PS3TrophiesInstalled_t_123 w_PS3TrophiesInstalled_t_123; +typedef u64_PS3TrophiesInstalled_t_123 u_PS3TrophiesInstalled_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_PS3TrophiesInstalled_t_112x +{ + uint64_t m_nGameID; + uint32_t m_eResult; + uint8_t __pad_12[4]; + uint64_t m_ulRequiredDiskSpace; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_PS3TrophiesInstalled_t_112x +{ + uint64_t m_nGameID; + uint32_t m_eResult; + uint8_t __pad_12[4]; + uint64_t m_ulRequiredDiskSpace; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_PS3TrophiesInstalled_t_112x +{ + uint64_t m_nGameID; + uint32_t m_eResult; + uint64_t m_ulRequiredDiskSpace; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_PS3TrophiesInstalled_t_112x w_PS3TrophiesInstalled_t_112x; +typedef u32_PS3TrophiesInstalled_t_112x u_PS3TrophiesInstalled_t_112x; +#endif +#ifdef __x86_64__ +typedef w64_PS3TrophiesInstalled_t_112x w_PS3TrophiesInstalled_t_112x; +typedef u64_PS3TrophiesInstalled_t_112x u_PS3TrophiesInstalled_t_112x; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageAppSyncProgress_t_123 +{ + W64_ARRAY(char, 260, m_rgchCurrentFile); + uint32_t m_nAppID; + uint32_t m_uBytesTransferredThisChunk; + uint8_t __pad_268[4]; + double m_dAppPercentComplete; + bool m_bUploading; + uint8_t __pad_281[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageAppSyncProgress_t_123 +{ + U64_ARRAY(char, 260, m_rgchCurrentFile); + uint32_t m_nAppID; + uint32_t m_uBytesTransferredThisChunk; + double m_dAppPercentComplete; + bool m_bUploading; + uint8_t __pad_277[3]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageAppSyncProgress_t_123 +{ + W32_ARRAY(char, 260, m_rgchCurrentFile); + uint32_t m_nAppID; + uint32_t m_uBytesTransferredThisChunk; + uint8_t __pad_268[4]; + double m_dAppPercentComplete; + bool m_bUploading; + uint8_t __pad_281[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageAppSyncProgress_t_123 +{ + U32_ARRAY(char, 260, m_rgchCurrentFile); + uint32_t m_nAppID; + uint32_t m_uBytesTransferredThisChunk; + double m_dAppPercentComplete; + bool m_bUploading; + uint8_t __pad_277[3]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageAppSyncProgress_t_123 w_RemoteStorageAppSyncProgress_t_123; +typedef u32_RemoteStorageAppSyncProgress_t_123 u_RemoteStorageAppSyncProgress_t_123; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageAppSyncProgress_t_123 w_RemoteStorageAppSyncProgress_t_123; +typedef u64_RemoteStorageAppSyncProgress_t_123 u_RemoteStorageAppSyncProgress_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageAppSyncProgress_t_111x +{ + W64_ARRAY(char, 260, m_rgchCurrentFile); + uint32_t m_nAppID; + uint32_t m_uBytesTransferredThisChunk; + uint8_t __pad_268[4]; + double m_dAppPercentComplete; + bool m_bUploading; + uint8_t __pad_281[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageAppSyncProgress_t_111x +{ + W32_ARRAY(char, 260, m_rgchCurrentFile); + uint32_t m_nAppID; + uint32_t m_uBytesTransferredThisChunk; + uint8_t __pad_268[4]; + double m_dAppPercentComplete; + bool m_bUploading; + uint8_t __pad_281[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageAppSyncProgress_t_111x +{ + U32_ARRAY(char, 260, m_rgchCurrentFile); + uint32_t m_nAppID; + uint32_t m_uBytesTransferredThisChunk; + double m_dAppPercentComplete; + bool m_bUploading; + uint8_t __pad_277[3]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageAppSyncProgress_t_111x w_RemoteStorageAppSyncProgress_t_111x; +typedef u32_RemoteStorageAppSyncProgress_t_111x u_RemoteStorageAppSyncProgress_t_111x; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageAppSyncProgress_t_111x w_RemoteStorageAppSyncProgress_t_111x; +typedef u64_RemoteStorageAppSyncProgress_t_111x u_RemoteStorageAppSyncProgress_t_111x; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageDeletePublishedFileResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageDeletePublishedFileResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageDeletePublishedFileResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageDeletePublishedFileResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageDeletePublishedFileResult_t_123 w_RemoteStorageDeletePublishedFileResult_t_123; +typedef u32_RemoteStorageDeletePublishedFileResult_t_123 u_RemoteStorageDeletePublishedFileResult_t_123; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageDeletePublishedFileResult_t_123 w_RemoteStorageDeletePublishedFileResult_t_123; +typedef u64_RemoteStorageDeletePublishedFileResult_t_123 u_RemoteStorageDeletePublishedFileResult_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageDeletePublishedFileResult_t_116x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageDeletePublishedFileResult_t_116x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageDeletePublishedFileResult_t_116x +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageDeletePublishedFileResult_t_116x w_RemoteStorageDeletePublishedFileResult_t_116x; +typedef u32_RemoteStorageDeletePublishedFileResult_t_116x u_RemoteStorageDeletePublishedFileResult_t_116x; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageDeletePublishedFileResult_t_116x w_RemoteStorageDeletePublishedFileResult_t_116x; +typedef u64_RemoteStorageDeletePublishedFileResult_t_116x u_RemoteStorageDeletePublishedFileResult_t_116x; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageDownloadUGCResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_hFile; + uint32_t m_nAppID; + int32_t m_nSizeInBytes; + W64_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_284[4]; + uint64_t m_ulSteamIDOwner; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageDownloadUGCResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_hFile; + uint32_t m_nAppID; + int32_t m_nSizeInBytes; + U64_ARRAY(char, 260, m_pchFileName); + uint64_t m_ulSteamIDOwner; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageDownloadUGCResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_hFile; + uint32_t m_nAppID; + int32_t m_nSizeInBytes; + W32_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_284[4]; + uint64_t m_ulSteamIDOwner; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageDownloadUGCResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_hFile; + uint32_t m_nAppID; + int32_t m_nSizeInBytes; + U32_ARRAY(char, 260, m_pchFileName); + uint64_t m_ulSteamIDOwner; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageDownloadUGCResult_t_123 w_RemoteStorageDownloadUGCResult_t_123; +typedef u32_RemoteStorageDownloadUGCResult_t_123 u_RemoteStorageDownloadUGCResult_t_123; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageDownloadUGCResult_t_123 w_RemoteStorageDownloadUGCResult_t_123; +typedef u64_RemoteStorageDownloadUGCResult_t_123 u_RemoteStorageDownloadUGCResult_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageDownloadUGCResult_t_116x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_hFile; + uint32_t m_nAppID; + int32_t m_nSizeInBytes; + W64_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_284[4]; + uint64_t m_ulSteamIDOwner; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageDownloadUGCResult_t_116x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_hFile; + uint32_t m_nAppID; + int32_t m_nSizeInBytes; + W32_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_284[4]; + uint64_t m_ulSteamIDOwner; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageDownloadUGCResult_t_116x +{ + uint32_t m_eResult; + uint64_t m_hFile; + uint32_t m_nAppID; + int32_t m_nSizeInBytes; + U32_ARRAY(char, 260, m_pchFileName); + uint64_t m_ulSteamIDOwner; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageDownloadUGCResult_t_116x w_RemoteStorageDownloadUGCResult_t_116x; +typedef u32_RemoteStorageDownloadUGCResult_t_116x u_RemoteStorageDownloadUGCResult_t_116x; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageDownloadUGCResult_t_116x w_RemoteStorageDownloadUGCResult_t_116x; +typedef u64_RemoteStorageDownloadUGCResult_t_116x u_RemoteStorageDownloadUGCResult_t_116x; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageDownloadUGCResult_t_111x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_hFile; + uint32_t m_nAppID; + int32_t m_nSizeInBytes; + W64_PTR(char *m_pchFileName, m_pchFileName); + uint64_t m_ulSteamIDOwner; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageDownloadUGCResult_t_111x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_hFile; + uint32_t m_nAppID; + int32_t m_nSizeInBytes; + W32_PTR(char *m_pchFileName, m_pchFileName); + uint8_t __pad_28[4]; + uint64_t m_ulSteamIDOwner; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageDownloadUGCResult_t_111x +{ + uint32_t m_eResult; + uint64_t m_hFile; + uint32_t m_nAppID; + int32_t m_nSizeInBytes; + U32_PTR(char *m_pchFileName, m_pchFileName); + uint64_t m_ulSteamIDOwner; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageDownloadUGCResult_t_111x w_RemoteStorageDownloadUGCResult_t_111x; +typedef u32_RemoteStorageDownloadUGCResult_t_111x u_RemoteStorageDownloadUGCResult_t_111x; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageDownloadUGCResult_t_111x w_RemoteStorageDownloadUGCResult_t_111x; +typedef u64_RemoteStorageDownloadUGCResult_t_111x u_RemoteStorageDownloadUGCResult_t_111x; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageEnumerateUserPublishedFilesResult_t_123 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + uint8_t __pad_12[4]; + W64_ARRAY(uint64_t, 50, m_rgPublishedFileId); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageEnumerateUserPublishedFilesResult_t_123 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + U64_ARRAY(uint64_t, 50, m_rgPublishedFileId); +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageEnumerateUserPublishedFilesResult_t_123 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + uint8_t __pad_12[4]; + W32_ARRAY(uint64_t, 50, m_rgPublishedFileId); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageEnumerateUserPublishedFilesResult_t_123 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + U32_ARRAY(uint64_t, 50, m_rgPublishedFileId); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageEnumerateUserPublishedFilesResult_t_123 w_RemoteStorageEnumerateUserPublishedFilesResult_t_123; +typedef u32_RemoteStorageEnumerateUserPublishedFilesResult_t_123 u_RemoteStorageEnumerateUserPublishedFilesResult_t_123; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageEnumerateUserPublishedFilesResult_t_123 w_RemoteStorageEnumerateUserPublishedFilesResult_t_123; +typedef u64_RemoteStorageEnumerateUserPublishedFilesResult_t_123 u_RemoteStorageEnumerateUserPublishedFilesResult_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + uint8_t __pad_12[4]; + W64_ARRAY(uint64_t, 50, m_rgPublishedFileId); +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + uint8_t __pad_12[4]; + W32_ARRAY(uint64_t, 50, m_rgPublishedFileId); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + U32_ARRAY(uint64_t, 50, m_rgPublishedFileId); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x w_RemoteStorageEnumerateUserPublishedFilesResult_t_116x; +typedef u32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x u_RemoteStorageEnumerateUserPublishedFilesResult_t_116x; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x w_RemoteStorageEnumerateUserPublishedFilesResult_t_116x; +typedef u64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x u_RemoteStorageEnumerateUserPublishedFilesResult_t_116x; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + uint8_t __pad_12[4]; + W64_ARRAY(uint64_t, 50, m_rgPublishedFileId); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + U64_ARRAY(uint64_t, 50, m_rgPublishedFileId); +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + uint8_t __pad_12[4]; + W32_ARRAY(uint64_t, 50, m_rgPublishedFileId); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + U32_ARRAY(uint64_t, 50, m_rgPublishedFileId); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123 w_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123; +typedef u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123 u_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123 w_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123; +typedef u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123 u_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + uint8_t __pad_12[4]; + W64_ARRAY(uint64_t, 50, m_rgPublishedFileId); +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + uint8_t __pad_12[4]; + W32_ARRAY(uint64_t, 50, m_rgPublishedFileId); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + U32_ARRAY(uint64_t, 50, m_rgPublishedFileId); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119 w_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119; +typedef u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119 u_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119 w_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119; +typedef u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119 u_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + uint8_t __pad_12[4]; + W64_ARRAY(uint64_t, 50, m_rgPublishedFileId); + W64_ARRAY(uint32_t, 50, m_rgRTimeSubscribed); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + U64_ARRAY(uint64_t, 50, m_rgPublishedFileId); + U64_ARRAY(uint32_t, 50, m_rgRTimeSubscribed); +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + uint8_t __pad_12[4]; + W32_ARRAY(uint64_t, 50, m_rgPublishedFileId); + W32_ARRAY(uint32_t, 50, m_rgRTimeSubscribed); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + U32_ARRAY(uint64_t, 50, m_rgPublishedFileId); + U32_ARRAY(uint32_t, 50, m_rgRTimeSubscribed); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123 w_RemoteStorageEnumerateUserSubscribedFilesResult_t_123; +typedef u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123 u_RemoteStorageEnumerateUserSubscribedFilesResult_t_123; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123 w_RemoteStorageEnumerateUserSubscribedFilesResult_t_123; +typedef u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123 u_RemoteStorageEnumerateUserSubscribedFilesResult_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + uint8_t __pad_12[4]; + W64_ARRAY(uint64_t, 50, m_rgPublishedFileId); + W64_ARRAY(uint32_t, 50, m_rgRTimeSubscribed); +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + uint8_t __pad_12[4]; + W32_ARRAY(uint64_t, 50, m_rgPublishedFileId); + W32_ARRAY(uint32_t, 50, m_rgRTimeSubscribed); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + U32_ARRAY(uint64_t, 50, m_rgPublishedFileId); + U32_ARRAY(uint32_t, 50, m_rgRTimeSubscribed); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x w_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x; +typedef u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x u_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x w_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x; +typedef u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x u_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageEnumerateWorkshopFilesResult_t_125 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + uint8_t __pad_12[4]; + W64_ARRAY(uint64_t, 50, m_rgPublishedFileId); + W64_ARRAY(float, 50, m_rgScore); + uint32_t m_nAppId; + uint32_t m_unStartIndex; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageEnumerateWorkshopFilesResult_t_125 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + U64_ARRAY(uint64_t, 50, m_rgPublishedFileId); + U64_ARRAY(float, 50, m_rgScore); + uint32_t m_nAppId; + uint32_t m_unStartIndex; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageEnumerateWorkshopFilesResult_t_125 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + uint8_t __pad_12[4]; + W32_ARRAY(uint64_t, 50, m_rgPublishedFileId); + W32_ARRAY(float, 50, m_rgScore); + uint32_t m_nAppId; + uint32_t m_unStartIndex; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageEnumerateWorkshopFilesResult_t_125 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + U32_ARRAY(uint64_t, 50, m_rgPublishedFileId); + U32_ARRAY(float, 50, m_rgScore); + uint32_t m_nAppId; + uint32_t m_unStartIndex; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageEnumerateWorkshopFilesResult_t_125 w_RemoteStorageEnumerateWorkshopFilesResult_t_125; +typedef u32_RemoteStorageEnumerateWorkshopFilesResult_t_125 u_RemoteStorageEnumerateWorkshopFilesResult_t_125; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageEnumerateWorkshopFilesResult_t_125 w_RemoteStorageEnumerateWorkshopFilesResult_t_125; +typedef u64_RemoteStorageEnumerateWorkshopFilesResult_t_125 u_RemoteStorageEnumerateWorkshopFilesResult_t_125; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageEnumerateWorkshopFilesResult_t_123 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + uint8_t __pad_12[4]; + W64_ARRAY(uint64_t, 50, m_rgPublishedFileId); + W64_ARRAY(float, 50, m_rgScore); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageEnumerateWorkshopFilesResult_t_123 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + U64_ARRAY(uint64_t, 50, m_rgPublishedFileId); + U64_ARRAY(float, 50, m_rgScore); +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageEnumerateWorkshopFilesResult_t_123 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + uint8_t __pad_12[4]; + W32_ARRAY(uint64_t, 50, m_rgPublishedFileId); + W32_ARRAY(float, 50, m_rgScore); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageEnumerateWorkshopFilesResult_t_123 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + U32_ARRAY(uint64_t, 50, m_rgPublishedFileId); + U32_ARRAY(float, 50, m_rgScore); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageEnumerateWorkshopFilesResult_t_123 w_RemoteStorageEnumerateWorkshopFilesResult_t_123; +typedef u32_RemoteStorageEnumerateWorkshopFilesResult_t_123 u_RemoteStorageEnumerateWorkshopFilesResult_t_123; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageEnumerateWorkshopFilesResult_t_123 w_RemoteStorageEnumerateWorkshopFilesResult_t_123; +typedef u64_RemoteStorageEnumerateWorkshopFilesResult_t_123 u_RemoteStorageEnumerateWorkshopFilesResult_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageEnumerateWorkshopFilesResult_t_119 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + uint8_t __pad_12[4]; + W64_ARRAY(uint64_t, 50, m_rgPublishedFileId); + W64_ARRAY(float, 50, m_rgScore); +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageEnumerateWorkshopFilesResult_t_119 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + uint8_t __pad_12[4]; + W32_ARRAY(uint64_t, 50, m_rgPublishedFileId); + W32_ARRAY(float, 50, m_rgScore); +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageEnumerateWorkshopFilesResult_t_119 +{ + uint32_t m_eResult; + int32_t m_nResultsReturned; + int32_t m_nTotalResultCount; + U32_ARRAY(uint64_t, 50, m_rgPublishedFileId); + U32_ARRAY(float, 50, m_rgScore); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageEnumerateWorkshopFilesResult_t_119 w_RemoteStorageEnumerateWorkshopFilesResult_t_119; +typedef u32_RemoteStorageEnumerateWorkshopFilesResult_t_119 u_RemoteStorageEnumerateWorkshopFilesResult_t_119; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageEnumerateWorkshopFilesResult_t_119 w_RemoteStorageEnumerateWorkshopFilesResult_t_119; +typedef u64_RemoteStorageEnumerateWorkshopFilesResult_t_119 u_RemoteStorageEnumerateWorkshopFilesResult_t_119; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageFileShareResult_t_128x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_hFile; + W64_ARRAY(char, 260, m_rgchFilename); + uint8_t __pad_276[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageFileShareResult_t_128x +{ + uint32_t m_eResult; + uint64_t m_hFile; + U64_ARRAY(char, 260, m_rgchFilename); +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageFileShareResult_t_128x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_hFile; + W32_ARRAY(char, 260, m_rgchFilename); + uint8_t __pad_276[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageFileShareResult_t_128x +{ + uint32_t m_eResult; + uint64_t m_hFile; + U32_ARRAY(char, 260, m_rgchFilename); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageFileShareResult_t_128x w_RemoteStorageFileShareResult_t_128x; +typedef u32_RemoteStorageFileShareResult_t_128x u_RemoteStorageFileShareResult_t_128x; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageFileShareResult_t_128x w_RemoteStorageFileShareResult_t_128x; +typedef u64_RemoteStorageFileShareResult_t_128x u_RemoteStorageFileShareResult_t_128x; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageFileShareResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_hFile; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageFileShareResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_hFile; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageFileShareResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_hFile; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageFileShareResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_hFile; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageFileShareResult_t_123 w_RemoteStorageFileShareResult_t_123; +typedef u32_RemoteStorageFileShareResult_t_123 u_RemoteStorageFileShareResult_t_123; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageFileShareResult_t_123 w_RemoteStorageFileShareResult_t_123; +typedef u64_RemoteStorageFileShareResult_t_123 u_RemoteStorageFileShareResult_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageFileShareResult_t_111x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_hFile; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageFileShareResult_t_111x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_hFile; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageFileShareResult_t_111x +{ + uint32_t m_eResult; + uint64_t m_hFile; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageFileShareResult_t_111x w_RemoteStorageFileShareResult_t_111x; +typedef u32_RemoteStorageFileShareResult_t_111x u_RemoteStorageFileShareResult_t_111x; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageFileShareResult_t_111x w_RemoteStorageFileShareResult_t_111x; +typedef u64_RemoteStorageFileShareResult_t_111x u_RemoteStorageFileShareResult_t_111x; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageGetPublishedFileDetailsResult_t_126 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + W64_ARRAY(char, 129, m_rgchTitle); + W64_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[7]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + W64_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + W64_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_9483[1]; + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + W64_ARRAY(char, 256, m_rgchURL); + uint32_t m_eFileType; + bool m_bAcceptedForUse; + uint8_t __pad_9753[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageGetPublishedFileDetailsResult_t_126 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + U64_ARRAY(char, 129, m_rgchTitle); + U64_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8149[3]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + U64_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + U64_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_9475[1]; + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + U64_ARRAY(char, 256, m_rgchURL); + uint32_t m_eFileType; + bool m_bAcceptedForUse; + uint8_t __pad_9745[3]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageGetPublishedFileDetailsResult_t_126 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + W32_ARRAY(char, 129, m_rgchTitle); + W32_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[7]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + W32_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + W32_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_9483[1]; + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + W32_ARRAY(char, 256, m_rgchURL); + uint32_t m_eFileType; + bool m_bAcceptedForUse; + uint8_t __pad_9753[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageGetPublishedFileDetailsResult_t_126 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + U32_ARRAY(char, 129, m_rgchTitle); + U32_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8149[3]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + U32_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + U32_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_9475[1]; + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + U32_ARRAY(char, 256, m_rgchURL); + uint32_t m_eFileType; + bool m_bAcceptedForUse; + uint8_t __pad_9745[3]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageGetPublishedFileDetailsResult_t_126 w_RemoteStorageGetPublishedFileDetailsResult_t_126; +typedef u32_RemoteStorageGetPublishedFileDetailsResult_t_126 u_RemoteStorageGetPublishedFileDetailsResult_t_126; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageGetPublishedFileDetailsResult_t_126 w_RemoteStorageGetPublishedFileDetailsResult_t_126; +typedef u64_RemoteStorageGetPublishedFileDetailsResult_t_126 u_RemoteStorageGetPublishedFileDetailsResult_t_126; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageGetPublishedFileDetailsResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + W64_ARRAY(char, 129, m_rgchTitle); + W64_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[7]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + W64_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + W64_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_9483[1]; + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + W64_ARRAY(char, 256, m_rgchURL); + uint32_t m_eFileType; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageGetPublishedFileDetailsResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + U64_ARRAY(char, 129, m_rgchTitle); + U64_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8149[3]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + U64_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + U64_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_9475[1]; + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + U64_ARRAY(char, 256, m_rgchURL); + uint32_t m_eFileType; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageGetPublishedFileDetailsResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + W32_ARRAY(char, 129, m_rgchTitle); + W32_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[7]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + W32_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + W32_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_9483[1]; + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + W32_ARRAY(char, 256, m_rgchURL); + uint32_t m_eFileType; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageGetPublishedFileDetailsResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + U32_ARRAY(char, 129, m_rgchTitle); + U32_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8149[3]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + U32_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + U32_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_9475[1]; + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + U32_ARRAY(char, 256, m_rgchURL); + uint32_t m_eFileType; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageGetPublishedFileDetailsResult_t_123 w_RemoteStorageGetPublishedFileDetailsResult_t_123; +typedef u32_RemoteStorageGetPublishedFileDetailsResult_t_123 u_RemoteStorageGetPublishedFileDetailsResult_t_123; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageGetPublishedFileDetailsResult_t_123 w_RemoteStorageGetPublishedFileDetailsResult_t_123; +typedef u64_RemoteStorageGetPublishedFileDetailsResult_t_123 u_RemoteStorageGetPublishedFileDetailsResult_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageGetPublishedFileDetailsResult_t_119x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + W64_ARRAY(char, 129, m_rgchTitle); + W64_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[7]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + W64_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + W64_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_9483[1]; + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + W64_ARRAY(char, 256, m_rgchURL); + uint32_t m_eFileType; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageGetPublishedFileDetailsResult_t_119x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + W32_ARRAY(char, 129, m_rgchTitle); + W32_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[7]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + W32_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + W32_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_9483[1]; + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + W32_ARRAY(char, 256, m_rgchURL); + uint32_t m_eFileType; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageGetPublishedFileDetailsResult_t_119x +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + U32_ARRAY(char, 129, m_rgchTitle); + U32_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8149[3]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + U32_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + U32_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_9475[1]; + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + U32_ARRAY(char, 256, m_rgchURL); + uint32_t m_eFileType; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageGetPublishedFileDetailsResult_t_119x w_RemoteStorageGetPublishedFileDetailsResult_t_119x; +typedef u32_RemoteStorageGetPublishedFileDetailsResult_t_119x u_RemoteStorageGetPublishedFileDetailsResult_t_119x; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageGetPublishedFileDetailsResult_t_119x w_RemoteStorageGetPublishedFileDetailsResult_t_119x; +typedef u64_RemoteStorageGetPublishedFileDetailsResult_t_119x u_RemoteStorageGetPublishedFileDetailsResult_t_119x; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageGetPublishedFileDetailsResult_t_119 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + W64_ARRAY(char, 129, m_rgchTitle); + W64_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[7]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + W64_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + W64_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_9483[1]; + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + W64_ARRAY(char, 256, m_rgchURL); + uint8_t __pad_9748[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageGetPublishedFileDetailsResult_t_119 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + W32_ARRAY(char, 129, m_rgchTitle); + W32_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[7]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + W32_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + W32_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_9483[1]; + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + W32_ARRAY(char, 256, m_rgchURL); + uint8_t __pad_9748[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageGetPublishedFileDetailsResult_t_119 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + U32_ARRAY(char, 129, m_rgchTitle); + U32_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8149[3]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + U32_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + U32_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_9475[1]; + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + U32_ARRAY(char, 256, m_rgchURL); +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageGetPublishedFileDetailsResult_t_119 w_RemoteStorageGetPublishedFileDetailsResult_t_119; +typedef u32_RemoteStorageGetPublishedFileDetailsResult_t_119 u_RemoteStorageGetPublishedFileDetailsResult_t_119; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageGetPublishedFileDetailsResult_t_119 w_RemoteStorageGetPublishedFileDetailsResult_t_119; +typedef u64_RemoteStorageGetPublishedFileDetailsResult_t_119 u_RemoteStorageGetPublishedFileDetailsResult_t_119; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageGetPublishedFileDetailsResult_t_118 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + W64_ARRAY(char, 129, m_rgchTitle); + W64_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[7]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + W64_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + W64_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_9483[1]; + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + uint8_t __pad_9492[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageGetPublishedFileDetailsResult_t_118 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + W32_ARRAY(char, 129, m_rgchTitle); + W32_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8153[7]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + W32_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + W32_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_9483[1]; + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; + uint8_t __pad_9492[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageGetPublishedFileDetailsResult_t_118 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + U32_ARRAY(char, 129, m_rgchTitle); + U32_ARRAY(char, 8000, m_rgchDescription); + uint8_t __pad_8149[3]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + U32_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + U32_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_9475[1]; + int32_t m_nFileSize; + int32_t m_nPreviewFileSize; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageGetPublishedFileDetailsResult_t_118 w_RemoteStorageGetPublishedFileDetailsResult_t_118; +typedef u32_RemoteStorageGetPublishedFileDetailsResult_t_118 u_RemoteStorageGetPublishedFileDetailsResult_t_118; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageGetPublishedFileDetailsResult_t_118 w_RemoteStorageGetPublishedFileDetailsResult_t_118; +typedef u64_RemoteStorageGetPublishedFileDetailsResult_t_118 u_RemoteStorageGetPublishedFileDetailsResult_t_118; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageGetPublishedFileDetailsResult_t_116x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + W64_ARRAY(char, 129, m_rgchTitle); + W64_ARRAY(char, 257, m_rgchDescription); + uint8_t __pad_410[6]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + W64_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + W64_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_1739[5]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageGetPublishedFileDetailsResult_t_116x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + W32_ARRAY(char, 129, m_rgchTitle); + W32_ARRAY(char, 257, m_rgchDescription); + uint8_t __pad_410[6]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + W32_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + W32_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_1739[5]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageGetPublishedFileDetailsResult_t_116x +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint32_t m_nCreatorAppID; + uint32_t m_nConsumerAppID; + U32_ARRAY(char, 129, m_rgchTitle); + U32_ARRAY(char, 257, m_rgchDescription); + uint8_t __pad_406[2]; + uint64_t m_hFile; + uint64_t m_hPreviewFile; + uint64_t m_ulSteamIDOwner; + uint32_t m_rtimeCreated; + uint32_t m_rtimeUpdated; + uint32_t m_eVisibility; + bool m_bBanned; + U32_ARRAY(char, 1025, m_rgchTags); + bool m_bTagsTruncated; + U32_ARRAY(char, 260, m_pchFileName); + uint8_t __pad_1731[1]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageGetPublishedFileDetailsResult_t_116x w_RemoteStorageGetPublishedFileDetailsResult_t_116x; +typedef u32_RemoteStorageGetPublishedFileDetailsResult_t_116x u_RemoteStorageGetPublishedFileDetailsResult_t_116x; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageGetPublishedFileDetailsResult_t_116x w_RemoteStorageGetPublishedFileDetailsResult_t_116x; +typedef u64_RemoteStorageGetPublishedFileDetailsResult_t_116x u_RemoteStorageGetPublishedFileDetailsResult_t_116x; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_unPublishedFileId; + int32_t m_nVotesFor; + int32_t m_nVotesAgainst; + int32_t m_nReports; + float m_fScore; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_unPublishedFileId; + int32_t m_nVotesFor; + int32_t m_nVotesAgainst; + int32_t m_nReports; + float m_fScore; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_unPublishedFileId; + int32_t m_nVotesFor; + int32_t m_nVotesAgainst; + int32_t m_nReports; + float m_fScore; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_unPublishedFileId; + int32_t m_nVotesFor; + int32_t m_nVotesAgainst; + int32_t m_nReports; + float m_fScore; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123 w_RemoteStorageGetPublishedItemVoteDetailsResult_t_123; +typedef u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123 u_RemoteStorageGetPublishedItemVoteDetailsResult_t_123; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123 w_RemoteStorageGetPublishedItemVoteDetailsResult_t_123; +typedef u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123 u_RemoteStorageGetPublishedItemVoteDetailsResult_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_unPublishedFileId; + int32_t m_nVotesFor; + int32_t m_nVotesAgainst; + int32_t m_nReports; + float m_fScore; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_unPublishedFileId; + int32_t m_nVotesFor; + int32_t m_nVotesAgainst; + int32_t m_nReports; + float m_fScore; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119 +{ + uint32_t m_eResult; + uint64_t m_unPublishedFileId; + int32_t m_nVotesFor; + int32_t m_nVotesAgainst; + int32_t m_nReports; + float m_fScore; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119 w_RemoteStorageGetPublishedItemVoteDetailsResult_t_119; +typedef u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119 u_RemoteStorageGetPublishedItemVoteDetailsResult_t_119; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119 w_RemoteStorageGetPublishedItemVoteDetailsResult_t_119; +typedef u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119 u_RemoteStorageGetPublishedItemVoteDetailsResult_t_119; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStoragePublishFileResult_t_125 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + bool m_bUserNeedsToAcceptWorkshopLegalAgreement; + uint8_t __pad_17[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStoragePublishFileResult_t_125 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + bool m_bUserNeedsToAcceptWorkshopLegalAgreement; + uint8_t __pad_13[3]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStoragePublishFileResult_t_125 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + bool m_bUserNeedsToAcceptWorkshopLegalAgreement; + uint8_t __pad_17[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStoragePublishFileResult_t_125 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + bool m_bUserNeedsToAcceptWorkshopLegalAgreement; + uint8_t __pad_13[3]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStoragePublishFileResult_t_125 w_RemoteStoragePublishFileResult_t_125; +typedef u32_RemoteStoragePublishFileResult_t_125 u_RemoteStoragePublishFileResult_t_125; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStoragePublishFileResult_t_125 w_RemoteStoragePublishFileResult_t_125; +typedef u64_RemoteStoragePublishFileResult_t_125 u_RemoteStoragePublishFileResult_t_125; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStoragePublishFileResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStoragePublishFileResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStoragePublishFileResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStoragePublishFileResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStoragePublishFileResult_t_123 w_RemoteStoragePublishFileResult_t_123; +typedef u32_RemoteStoragePublishFileResult_t_123 u_RemoteStoragePublishFileResult_t_123; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStoragePublishFileResult_t_123 w_RemoteStoragePublishFileResult_t_123; +typedef u64_RemoteStoragePublishFileResult_t_123 u_RemoteStoragePublishFileResult_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStoragePublishFileResult_t_116x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStoragePublishFileResult_t_116x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStoragePublishFileResult_t_116x +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStoragePublishFileResult_t_116x w_RemoteStoragePublishFileResult_t_116x; +typedef u32_RemoteStoragePublishFileResult_t_116x u_RemoteStoragePublishFileResult_t_116x; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStoragePublishFileResult_t_116x w_RemoteStoragePublishFileResult_t_116x; +typedef u64_RemoteStoragePublishFileResult_t_116x u_RemoteStoragePublishFileResult_t_116x; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStoragePublishedFileUpdated_t +{ + uint64_t m_nPublishedFileId; + uint32_t m_nAppID; + uint8_t __pad_12[4]; + uint64_t m_ulUnused; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStoragePublishedFileUpdated_t +{ + uint64_t m_nPublishedFileId; + uint32_t m_nAppID; + uint64_t m_ulUnused; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStoragePublishedFileUpdated_t +{ + uint64_t m_nPublishedFileId; + uint32_t m_nAppID; + uint8_t __pad_12[4]; + uint64_t m_ulUnused; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStoragePublishedFileUpdated_t +{ + uint64_t m_nPublishedFileId; + uint32_t m_nAppID; + uint64_t m_ulUnused; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStoragePublishedFileUpdated_t w_RemoteStoragePublishedFileUpdated_t; +typedef u32_RemoteStoragePublishedFileUpdated_t u_RemoteStoragePublishedFileUpdated_t; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStoragePublishedFileUpdated_t w_RemoteStoragePublishedFileUpdated_t; +typedef u64_RemoteStoragePublishedFileUpdated_t u_RemoteStoragePublishedFileUpdated_t; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageSetUserPublishedFileActionResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_eAction; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageSetUserPublishedFileActionResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint32_t m_eAction; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageSetUserPublishedFileActionResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_eAction; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageSetUserPublishedFileActionResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint32_t m_eAction; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageSetUserPublishedFileActionResult_t_123 w_RemoteStorageSetUserPublishedFileActionResult_t_123; +typedef u32_RemoteStorageSetUserPublishedFileActionResult_t_123 u_RemoteStorageSetUserPublishedFileActionResult_t_123; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageSetUserPublishedFileActionResult_t_123 w_RemoteStorageSetUserPublishedFileActionResult_t_123; +typedef u64_RemoteStorageSetUserPublishedFileActionResult_t_123 u_RemoteStorageSetUserPublishedFileActionResult_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageSetUserPublishedFileActionResult_t_119 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_eAction; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageSetUserPublishedFileActionResult_t_119 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_eAction; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageSetUserPublishedFileActionResult_t_119 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint32_t m_eAction; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageSetUserPublishedFileActionResult_t_119 w_RemoteStorageSetUserPublishedFileActionResult_t_119; +typedef u32_RemoteStorageSetUserPublishedFileActionResult_t_119 u_RemoteStorageSetUserPublishedFileActionResult_t_119; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageSetUserPublishedFileActionResult_t_119 w_RemoteStorageSetUserPublishedFileActionResult_t_119; +typedef u64_RemoteStorageSetUserPublishedFileActionResult_t_119 u_RemoteStorageSetUserPublishedFileActionResult_t_119; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageSubscribePublishedFileResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageSubscribePublishedFileResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageSubscribePublishedFileResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageSubscribePublishedFileResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageSubscribePublishedFileResult_t_123 w_RemoteStorageSubscribePublishedFileResult_t_123; +typedef u32_RemoteStorageSubscribePublishedFileResult_t_123 u_RemoteStorageSubscribePublishedFileResult_t_123; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageSubscribePublishedFileResult_t_123 w_RemoteStorageSubscribePublishedFileResult_t_123; +typedef u64_RemoteStorageSubscribePublishedFileResult_t_123 u_RemoteStorageSubscribePublishedFileResult_t_123; +#endif + +#pragma pack( push, 4 ) +struct w64_RemoteStorageSubscribePublishedFileResult_t_116x +{ + uint32_t m_eResult; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_RemoteStorageSubscribePublishedFileResult_t_116x +{ + uint32_t m_eResult; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageSubscribePublishedFileResult_t_116x w_RemoteStorageSubscribePublishedFileResult_t_116x; +typedef u32_RemoteStorageSubscribePublishedFileResult_t_116x u_RemoteStorageSubscribePublishedFileResult_t_116x; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageSubscribePublishedFileResult_t_116x w_RemoteStorageSubscribePublishedFileResult_t_116x; +typedef u64_RemoteStorageSubscribePublishedFileResult_t_116x u_RemoteStorageSubscribePublishedFileResult_t_116x; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageUnsubscribePublishedFileResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageUnsubscribePublishedFileResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageUnsubscribePublishedFileResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageUnsubscribePublishedFileResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageUnsubscribePublishedFileResult_t_123 w_RemoteStorageUnsubscribePublishedFileResult_t_123; +typedef u32_RemoteStorageUnsubscribePublishedFileResult_t_123 u_RemoteStorageUnsubscribePublishedFileResult_t_123; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageUnsubscribePublishedFileResult_t_123 w_RemoteStorageUnsubscribePublishedFileResult_t_123; +typedef u64_RemoteStorageUnsubscribePublishedFileResult_t_123 u_RemoteStorageUnsubscribePublishedFileResult_t_123; +#endif + +#pragma pack( push, 4 ) +struct w64_RemoteStorageUnsubscribePublishedFileResult_t_116x +{ + uint32_t m_eResult; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_RemoteStorageUnsubscribePublishedFileResult_t_116x +{ + uint32_t m_eResult; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageUnsubscribePublishedFileResult_t_116x w_RemoteStorageUnsubscribePublishedFileResult_t_116x; +typedef u32_RemoteStorageUnsubscribePublishedFileResult_t_116x u_RemoteStorageUnsubscribePublishedFileResult_t_116x; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageUnsubscribePublishedFileResult_t_116x w_RemoteStorageUnsubscribePublishedFileResult_t_116x; +typedef u64_RemoteStorageUnsubscribePublishedFileResult_t_116x u_RemoteStorageUnsubscribePublishedFileResult_t_116x; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageUpdatePublishedFileRequest_t +{ + uint64_t m_unPublishedFileId; + W64_PTR(const char *m_pchFile, m_pchFile); + W64_PTR(const char *m_pchPreviewFile, m_pchPreviewFile); + W64_PTR(const char *m_pchTitle, m_pchTitle); + W64_PTR(const char *m_pchDescription, m_pchDescription); + uint32_t m_eVisibility; + uint8_t __pad_44[4]; + W64_PTR(w64_SteamParamStringArray_t *m_pTags, m_pTags); + bool m_bUpdateFile; + bool m_bUpdatePreviewFile; + bool m_bUpdateTitle; + bool m_bUpdateDescription; + bool m_bUpdateVisibility; + bool m_bUpdateTags; + uint8_t __pad_62[2]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageUpdatePublishedFileRequest_t +{ + uint64_t m_unPublishedFileId; + W32_PTR(const char *m_pchFile, m_pchFile); + W32_PTR(const char *m_pchPreviewFile, m_pchPreviewFile); + W32_PTR(const char *m_pchTitle, m_pchTitle); + W32_PTR(const char *m_pchDescription, m_pchDescription); + uint32_t m_eVisibility; + W32_PTR(w32_SteamParamStringArray_t *m_pTags, m_pTags); + bool m_bUpdateFile; + bool m_bUpdatePreviewFile; + bool m_bUpdateTitle; + bool m_bUpdateDescription; + bool m_bUpdateVisibility; + bool m_bUpdateTags; + uint8_t __pad_38[2]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageUpdatePublishedFileRequest_t w_RemoteStorageUpdatePublishedFileRequest_t; +typedef u32_RemoteStorageUpdatePublishedFileRequest_t u_RemoteStorageUpdatePublishedFileRequest_t; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageUpdatePublishedFileRequest_t w_RemoteStorageUpdatePublishedFileRequest_t; +typedef u64_RemoteStorageUpdatePublishedFileRequest_t u_RemoteStorageUpdatePublishedFileRequest_t; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageUpdatePublishedFileResult_t_125 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + bool m_bUserNeedsToAcceptWorkshopLegalAgreement; + uint8_t __pad_17[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageUpdatePublishedFileResult_t_125 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + bool m_bUserNeedsToAcceptWorkshopLegalAgreement; + uint8_t __pad_13[3]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageUpdatePublishedFileResult_t_125 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + bool m_bUserNeedsToAcceptWorkshopLegalAgreement; + uint8_t __pad_17[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageUpdatePublishedFileResult_t_125 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + bool m_bUserNeedsToAcceptWorkshopLegalAgreement; + uint8_t __pad_13[3]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageUpdatePublishedFileResult_t_125 w_RemoteStorageUpdatePublishedFileResult_t_125; +typedef u32_RemoteStorageUpdatePublishedFileResult_t_125 u_RemoteStorageUpdatePublishedFileResult_t_125; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageUpdatePublishedFileResult_t_125 w_RemoteStorageUpdatePublishedFileResult_t_125; +typedef u64_RemoteStorageUpdatePublishedFileResult_t_125 u_RemoteStorageUpdatePublishedFileResult_t_125; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageUpdatePublishedFileResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageUpdatePublishedFileResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageUpdatePublishedFileResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageUpdatePublishedFileResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageUpdatePublishedFileResult_t_123 w_RemoteStorageUpdatePublishedFileResult_t_123; +typedef u32_RemoteStorageUpdatePublishedFileResult_t_123 u_RemoteStorageUpdatePublishedFileResult_t_123; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageUpdatePublishedFileResult_t_123 w_RemoteStorageUpdatePublishedFileResult_t_123; +typedef u64_RemoteStorageUpdatePublishedFileResult_t_123 u_RemoteStorageUpdatePublishedFileResult_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageUpdatePublishedFileResult_t_116x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageUpdatePublishedFileResult_t_116x +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageUpdatePublishedFileResult_t_116x +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageUpdatePublishedFileResult_t_116x w_RemoteStorageUpdatePublishedFileResult_t_116x; +typedef u32_RemoteStorageUpdatePublishedFileResult_t_116x u_RemoteStorageUpdatePublishedFileResult_t_116x; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageUpdatePublishedFileResult_t_116x w_RemoteStorageUpdatePublishedFileResult_t_116x; +typedef u64_RemoteStorageUpdatePublishedFileResult_t_116x u_RemoteStorageUpdatePublishedFileResult_t_116x; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageUpdateUserPublishedItemVoteResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageUpdateUserPublishedItemVoteResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageUpdateUserPublishedItemVoteResult_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageUpdateUserPublishedItemVoteResult_t_123 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageUpdateUserPublishedItemVoteResult_t_123 w_RemoteStorageUpdateUserPublishedItemVoteResult_t_123; +typedef u32_RemoteStorageUpdateUserPublishedItemVoteResult_t_123 u_RemoteStorageUpdateUserPublishedItemVoteResult_t_123; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageUpdateUserPublishedItemVoteResult_t_123 w_RemoteStorageUpdateUserPublishedItemVoteResult_t_123; +typedef u64_RemoteStorageUpdateUserPublishedItemVoteResult_t_123 u_RemoteStorageUpdateUserPublishedItemVoteResult_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageUpdateUserPublishedItemVoteResult_t_119 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageUpdateUserPublishedItemVoteResult_t_119 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageUpdateUserPublishedItemVoteResult_t_119 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageUpdateUserPublishedItemVoteResult_t_119 w_RemoteStorageUpdateUserPublishedItemVoteResult_t_119; +typedef u32_RemoteStorageUpdateUserPublishedItemVoteResult_t_119 u_RemoteStorageUpdateUserPublishedItemVoteResult_t_119; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageUpdateUserPublishedItemVoteResult_t_119 w_RemoteStorageUpdateUserPublishedItemVoteResult_t_119; +typedef u64_RemoteStorageUpdateUserPublishedItemVoteResult_t_119 u_RemoteStorageUpdateUserPublishedItemVoteResult_t_119; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageUserVoteDetails_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_eVote; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoteStorageUserVoteDetails_t_123 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint32_t m_eVote; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageUserVoteDetails_t_123 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_eVote; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageUserVoteDetails_t_123 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint32_t m_eVote; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageUserVoteDetails_t_123 w_RemoteStorageUserVoteDetails_t_123; +typedef u32_RemoteStorageUserVoteDetails_t_123 u_RemoteStorageUserVoteDetails_t_123; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageUserVoteDetails_t_123 w_RemoteStorageUserVoteDetails_t_123; +typedef u64_RemoteStorageUserVoteDetails_t_123 u_RemoteStorageUserVoteDetails_t_123; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoteStorageUserVoteDetails_t_119 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_eVote; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoteStorageUserVoteDetails_t_119 +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_eVote; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoteStorageUserVoteDetails_t_119 +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint32_t m_eVote; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoteStorageUserVoteDetails_t_119 w_RemoteStorageUserVoteDetails_t_119; +typedef u32_RemoteStorageUserVoteDetails_t_119 u_RemoteStorageUserVoteDetails_t_119; +#endif +#ifdef __x86_64__ +typedef w64_RemoteStorageUserVoteDetails_t_119 w_RemoteStorageUserVoteDetails_t_119; +typedef u64_RemoteStorageUserVoteDetails_t_119 u_RemoteStorageUserVoteDetails_t_119; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoveAppDependencyResult_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_nAppID; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoveAppDependencyResult_t +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint32_t m_nAppID; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoveAppDependencyResult_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint32_t m_nAppID; + uint8_t __pad_20[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoveAppDependencyResult_t +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint32_t m_nAppID; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoveAppDependencyResult_t w_RemoveAppDependencyResult_t; +typedef u32_RemoveAppDependencyResult_t u_RemoveAppDependencyResult_t; +#endif +#ifdef __x86_64__ +typedef w64_RemoveAppDependencyResult_t w_RemoveAppDependencyResult_t; +typedef u64_RemoveAppDependencyResult_t u_RemoveAppDependencyResult_t; +#endif + +#pragma pack( push, 8 ) +struct w64_RemoveUGCDependencyResult_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint64_t m_nChildPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RemoveUGCDependencyResult_t +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint64_t m_nChildPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RemoveUGCDependencyResult_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_nPublishedFileId; + uint64_t m_nChildPublishedFileId; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RemoveUGCDependencyResult_t +{ + uint32_t m_eResult; + uint64_t m_nPublishedFileId; + uint64_t m_nChildPublishedFileId; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RemoveUGCDependencyResult_t w_RemoveUGCDependencyResult_t; +typedef u32_RemoveUGCDependencyResult_t u_RemoveUGCDependencyResult_t; +#endif +#ifdef __x86_64__ +typedef w64_RemoveUGCDependencyResult_t w_RemoveUGCDependencyResult_t; +typedef u64_RemoveUGCDependencyResult_t u_RemoveUGCDependencyResult_t; +#endif + +#pragma pack( push, 8 ) +struct w64_RequestPlayersForGameFinalResultCallback_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_ullSearchID; + uint64_t m_ullUniqueGameID; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RequestPlayersForGameFinalResultCallback_t +{ + uint32_t m_eResult; + uint64_t m_ullSearchID; + uint64_t m_ullUniqueGameID; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RequestPlayersForGameFinalResultCallback_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_ullSearchID; + uint64_t m_ullUniqueGameID; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RequestPlayersForGameFinalResultCallback_t +{ + uint32_t m_eResult; + uint64_t m_ullSearchID; + uint64_t m_ullUniqueGameID; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RequestPlayersForGameFinalResultCallback_t w_RequestPlayersForGameFinalResultCallback_t; +typedef u32_RequestPlayersForGameFinalResultCallback_t u_RequestPlayersForGameFinalResultCallback_t; +#endif +#ifdef __x86_64__ +typedef w64_RequestPlayersForGameFinalResultCallback_t w_RequestPlayersForGameFinalResultCallback_t; +typedef u64_RequestPlayersForGameFinalResultCallback_t u_RequestPlayersForGameFinalResultCallback_t; +#endif + +#pragma pack( push, 8 ) +struct w64_RequestPlayersForGameProgressCallback_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_ullSearchID; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RequestPlayersForGameProgressCallback_t +{ + uint32_t m_eResult; + uint64_t m_ullSearchID; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RequestPlayersForGameProgressCallback_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_ullSearchID; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RequestPlayersForGameProgressCallback_t +{ + uint32_t m_eResult; + uint64_t m_ullSearchID; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RequestPlayersForGameProgressCallback_t w_RequestPlayersForGameProgressCallback_t; +typedef u32_RequestPlayersForGameProgressCallback_t u_RequestPlayersForGameProgressCallback_t; +#endif +#ifdef __x86_64__ +typedef w64_RequestPlayersForGameProgressCallback_t w_RequestPlayersForGameProgressCallback_t; +typedef u64_RequestPlayersForGameProgressCallback_t u_RequestPlayersForGameProgressCallback_t; +#endif + +#pragma pack( push, 8 ) +struct w64_RequestPlayersForGameResultCallback_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_ullSearchID; + CSteamID m_SteamIDPlayerFound; + CSteamID m_SteamIDLobby; + uint32_t m_ePlayerAcceptState; + int32_t m_nPlayerIndex; + int32_t m_nTotalPlayersFound; + int32_t m_nTotalPlayersAcceptedGame; + int32_t m_nSuggestedTeamIndex; + uint8_t __pad_52[4]; + uint64_t m_ullUniqueGameID; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_RequestPlayersForGameResultCallback_t +{ + uint32_t m_eResult; + uint64_t m_ullSearchID; + CSteamID m_SteamIDPlayerFound; + CSteamID m_SteamIDLobby; + uint32_t m_ePlayerAcceptState; + int32_t m_nPlayerIndex; + int32_t m_nTotalPlayersFound; + int32_t m_nTotalPlayersAcceptedGame; + int32_t m_nSuggestedTeamIndex; + uint64_t m_ullUniqueGameID; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_RequestPlayersForGameResultCallback_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t m_ullSearchID; + CSteamID m_SteamIDPlayerFound; + CSteamID m_SteamIDLobby; + uint32_t m_ePlayerAcceptState; + int32_t m_nPlayerIndex; + int32_t m_nTotalPlayersFound; + int32_t m_nTotalPlayersAcceptedGame; + int32_t m_nSuggestedTeamIndex; + uint8_t __pad_52[4]; + uint64_t m_ullUniqueGameID; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_RequestPlayersForGameResultCallback_t +{ + uint32_t m_eResult; + uint64_t m_ullSearchID; + CSteamID m_SteamIDPlayerFound; + CSteamID m_SteamIDLobby; + uint32_t m_ePlayerAcceptState; + int32_t m_nPlayerIndex; + int32_t m_nTotalPlayersFound; + int32_t m_nTotalPlayersAcceptedGame; + int32_t m_nSuggestedTeamIndex; + uint64_t m_ullUniqueGameID; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_RequestPlayersForGameResultCallback_t w_RequestPlayersForGameResultCallback_t; +typedef u32_RequestPlayersForGameResultCallback_t u_RequestPlayersForGameResultCallback_t; +#endif +#ifdef __x86_64__ +typedef w64_RequestPlayersForGameResultCallback_t w_RequestPlayersForGameResultCallback_t; +typedef u64_RequestPlayersForGameResultCallback_t u_RequestPlayersForGameResultCallback_t; +#endif + +#pragma pack( push, 8 ) +struct w64_SteamInputConfigurationLoaded_t +{ + uint32_t m_unAppID; + uint8_t __pad_4[4]; + uint64_t m_ulDeviceHandle; + CSteamID m_ulMappingCreator; + uint32_t m_unMajorRevision; + uint32_t m_unMinorRevision; + bool m_bUsesSteamInputAPI; + bool m_bUsesGamepadAPI; + uint8_t __pad_34[6]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_SteamInputConfigurationLoaded_t +{ + uint32_t m_unAppID; + uint64_t m_ulDeviceHandle; + CSteamID m_ulMappingCreator; + uint32_t m_unMajorRevision; + uint32_t m_unMinorRevision; + bool m_bUsesSteamInputAPI; + bool m_bUsesGamepadAPI; + uint8_t __pad_30[2]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_SteamInputConfigurationLoaded_t +{ + uint32_t m_unAppID; + uint8_t __pad_4[4]; + uint64_t m_ulDeviceHandle; + CSteamID m_ulMappingCreator; + uint32_t m_unMajorRevision; + uint32_t m_unMinorRevision; + bool m_bUsesSteamInputAPI; + bool m_bUsesGamepadAPI; + uint8_t __pad_34[6]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_SteamInputConfigurationLoaded_t +{ + uint32_t m_unAppID; + uint64_t m_ulDeviceHandle; + CSteamID m_ulMappingCreator; + uint32_t m_unMajorRevision; + uint32_t m_unMinorRevision; + bool m_bUsesSteamInputAPI; + bool m_bUsesGamepadAPI; + uint8_t __pad_30[2]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SteamInputConfigurationLoaded_t w_SteamInputConfigurationLoaded_t; +typedef u32_SteamInputConfigurationLoaded_t u_SteamInputConfigurationLoaded_t; +#endif +#ifdef __x86_64__ +typedef w64_SteamInputConfigurationLoaded_t w_SteamInputConfigurationLoaded_t; +typedef u64_SteamInputConfigurationLoaded_t u_SteamInputConfigurationLoaded_t; +#endif + +#pragma pack( push, 8 ) +struct w64_SteamInputGamepadSlotChange_t +{ + uint32_t m_unAppID; + uint8_t __pad_4[4]; + uint64_t m_ulDeviceHandle; + uint32_t m_eDeviceType; + int32_t m_nOldGamepadSlot; + int32_t m_nNewGamepadSlot; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_SteamInputGamepadSlotChange_t +{ + uint32_t m_unAppID; + uint64_t m_ulDeviceHandle; + uint32_t m_eDeviceType; + int32_t m_nOldGamepadSlot; + int32_t m_nNewGamepadSlot; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_SteamInputGamepadSlotChange_t +{ + uint32_t m_unAppID; + uint8_t __pad_4[4]; + uint64_t m_ulDeviceHandle; + uint32_t m_eDeviceType; + int32_t m_nOldGamepadSlot; + int32_t m_nNewGamepadSlot; + uint8_t __pad_28[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_SteamInputGamepadSlotChange_t +{ + uint32_t m_unAppID; + uint64_t m_ulDeviceHandle; + uint32_t m_eDeviceType; + int32_t m_nOldGamepadSlot; + int32_t m_nNewGamepadSlot; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SteamInputGamepadSlotChange_t w_SteamInputGamepadSlotChange_t; +typedef u32_SteamInputGamepadSlotChange_t u_SteamInputGamepadSlotChange_t; +#endif +#ifdef __x86_64__ +typedef w64_SteamInputGamepadSlotChange_t w_SteamInputGamepadSlotChange_t; +typedef u64_SteamInputGamepadSlotChange_t u_SteamInputGamepadSlotChange_t; +#endif + +#pragma pack( push, 8 ) +struct w64_SteamInventoryStartPurchaseResult_t +{ + uint32_t m_result; + uint8_t __pad_4[4]; + uint64_t m_ulOrderID; + uint64_t m_ulTransID; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_SteamInventoryStartPurchaseResult_t +{ + uint32_t m_result; + uint64_t m_ulOrderID; + uint64_t m_ulTransID; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_SteamInventoryStartPurchaseResult_t +{ + uint32_t m_result; + uint8_t __pad_4[4]; + uint64_t m_ulOrderID; + uint64_t m_ulTransID; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_SteamInventoryStartPurchaseResult_t +{ + uint32_t m_result; + uint64_t m_ulOrderID; + uint64_t m_ulTransID; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SteamInventoryStartPurchaseResult_t w_SteamInventoryStartPurchaseResult_t; +typedef u32_SteamInventoryStartPurchaseResult_t u_SteamInventoryStartPurchaseResult_t; +#endif +#ifdef __x86_64__ +typedef w64_SteamInventoryStartPurchaseResult_t w_SteamInventoryStartPurchaseResult_t; +typedef u64_SteamInventoryStartPurchaseResult_t u_SteamInventoryStartPurchaseResult_t; +#endif + +#pragma pack( push, 8 ) +struct w64_SteamNetConnectionStatusChangedCallback_t_153a +{ + uint32_t m_hConn; + uint8_t __pad_4[4]; + SteamNetConnectionInfo_t_153a m_info; + uint32_t m_eOldState; + uint8_t __pad_708[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_SteamNetConnectionStatusChangedCallback_t_153a +{ + uint32_t m_hConn; + SteamNetConnectionInfo_t_153a m_info; + uint32_t m_eOldState; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_SteamNetConnectionStatusChangedCallback_t_153a +{ + uint32_t m_hConn; + uint8_t __pad_4[4]; + SteamNetConnectionInfo_t_153a m_info; + uint32_t m_eOldState; + uint8_t __pad_708[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_SteamNetConnectionStatusChangedCallback_t_153a +{ + uint32_t m_hConn; + SteamNetConnectionInfo_t_153a m_info; + uint32_t m_eOldState; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SteamNetConnectionStatusChangedCallback_t_153a w_SteamNetConnectionStatusChangedCallback_t_153a; +typedef u32_SteamNetConnectionStatusChangedCallback_t_153a u_SteamNetConnectionStatusChangedCallback_t_153a; +#endif +#ifdef __x86_64__ +typedef w64_SteamNetConnectionStatusChangedCallback_t_153a w_SteamNetConnectionStatusChangedCallback_t_153a; +typedef u64_SteamNetConnectionStatusChangedCallback_t_153a u_SteamNetConnectionStatusChangedCallback_t_153a; +#endif + +#pragma pack( push, 8 ) +struct w64_SteamNetConnectionStatusChangedCallback_t_144 +{ + uint32_t m_hConn; + uint8_t __pad_4[4]; + SteamNetConnectionInfo_t_144 m_info; + uint32_t m_eOldState; + uint8_t __pad_708[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_SteamNetConnectionStatusChangedCallback_t_144 +{ + uint32_t m_hConn; + SteamNetConnectionInfo_t_144 m_info; + uint32_t m_eOldState; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_SteamNetConnectionStatusChangedCallback_t_144 +{ + uint32_t m_hConn; + uint8_t __pad_4[4]; + SteamNetConnectionInfo_t_144 m_info; + uint32_t m_eOldState; + uint8_t __pad_708[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_SteamNetConnectionStatusChangedCallback_t_144 +{ + uint32_t m_hConn; + SteamNetConnectionInfo_t_144 m_info; + uint32_t m_eOldState; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SteamNetConnectionStatusChangedCallback_t_144 w_SteamNetConnectionStatusChangedCallback_t_144; +typedef u32_SteamNetConnectionStatusChangedCallback_t_144 u_SteamNetConnectionStatusChangedCallback_t_144; +#endif +#ifdef __x86_64__ +typedef w64_SteamNetConnectionStatusChangedCallback_t_144 w_SteamNetConnectionStatusChangedCallback_t_144; +typedef u64_SteamNetConnectionStatusChangedCallback_t_144 u_SteamNetConnectionStatusChangedCallback_t_144; +#endif + +#pragma pack( push, 8 ) +struct w64_SteamNetConnectionStatusChangedCallback_t_151 +{ + uint32_t m_hConn; + uint8_t __pad_4[4]; + SteamNetConnectionInfo_t_151 m_info; + uint32_t m_eOldState; + uint8_t __pad_580[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_SteamNetConnectionStatusChangedCallback_t_151 +{ + uint32_t m_hConn; + SteamNetConnectionInfo_t_151 m_info; + uint32_t m_eOldState; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_SteamNetConnectionStatusChangedCallback_t_151 +{ + uint32_t m_hConn; + uint8_t __pad_4[4]; + SteamNetConnectionInfo_t_151 m_info; + uint32_t m_eOldState; + uint8_t __pad_580[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_SteamNetConnectionStatusChangedCallback_t_151 +{ + uint32_t m_hConn; + SteamNetConnectionInfo_t_151 m_info; + uint32_t m_eOldState; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SteamNetConnectionStatusChangedCallback_t_151 w_SteamNetConnectionStatusChangedCallback_t_151; +typedef u32_SteamNetConnectionStatusChangedCallback_t_151 u_SteamNetConnectionStatusChangedCallback_t_151; +#endif +#ifdef __x86_64__ +typedef w64_SteamNetConnectionStatusChangedCallback_t_151 w_SteamNetConnectionStatusChangedCallback_t_151; +typedef u64_SteamNetConnectionStatusChangedCallback_t_151 u_SteamNetConnectionStatusChangedCallback_t_151; +#endif + +#pragma pack( push, 8 ) +struct w64_SteamNetworkingMessage_t_153a +{ + W64_PTR(void *m_pData, m_pData); + int32_t m_cbSize; + uint32_t m_conn; + SteamNetworkingIdentity_144 m_identityPeer; + int64_t m_nConnUserData; + int64_t m_usecTimeReceived; + int64_t m_nMessageNumber; + W64_PTR(void (*W_STDCALL m_pfnFreeData)(w64_SteamNetworkingMessage_t_153a *), m_pfnFreeData); + W64_PTR(void (*W_STDCALL m_pfnRelease)(w64_SteamNetworkingMessage_t_153a *), m_pfnRelease); + int32_t m_nChannel; + int32_t m_nFlags; + int64_t m_nUserData; + uint16_t m_idxLane; + uint16_t _pad1__; + uint8_t __pad_212[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct u64_SteamNetworkingMessage_t_153a +{ + U64_PTR(void *m_pData, m_pData); + int32_t m_cbSize; + uint32_t m_conn; + SteamNetworkingIdentity_144 m_identityPeer; + int64_t m_nConnUserData; + int64_t m_usecTimeReceived; + int64_t m_nMessageNumber; + U64_PTR(void (*U_STDCALL m_pfnFreeData)(u64_SteamNetworkingMessage_t_153a *), m_pfnFreeData); + U64_PTR(void (*U_STDCALL m_pfnRelease)(u64_SteamNetworkingMessage_t_153a *), m_pfnRelease); + int32_t m_nChannel; + int32_t m_nFlags; + int64_t m_nUserData; + uint16_t m_idxLane; + uint16_t _pad1__; + uint8_t __pad_212[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_SteamNetworkingMessage_t_153a +{ + W32_PTR(void *m_pData, m_pData); + int32_t m_cbSize; + uint32_t m_conn; + SteamNetworkingIdentity_144 m_identityPeer; + uint8_t __pad_148[4]; + int64_t m_nConnUserData; + int64_t m_usecTimeReceived; + int64_t m_nMessageNumber; + W32_PTR(void (*W_STDCALL m_pfnFreeData)(w32_SteamNetworkingMessage_t_153a *), m_pfnFreeData); + W32_PTR(void (*W_STDCALL m_pfnRelease)(w32_SteamNetworkingMessage_t_153a *), m_pfnRelease); + int32_t m_nChannel; + int32_t m_nFlags; + int64_t m_nUserData; + uint16_t m_idxLane; + uint16_t _pad1__; + uint8_t __pad_204[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_SteamNetworkingMessage_t_153a +{ + U32_PTR(void *m_pData, m_pData); + int32_t m_cbSize; + uint32_t m_conn; + SteamNetworkingIdentity_144 m_identityPeer; + int64_t m_nConnUserData; + int64_t m_usecTimeReceived; + int64_t m_nMessageNumber; + U32_PTR(void (*U_STDCALL m_pfnFreeData)(u32_SteamNetworkingMessage_t_153a *), m_pfnFreeData); + U32_PTR(void (*U_STDCALL m_pfnRelease)(u32_SteamNetworkingMessage_t_153a *), m_pfnRelease); + int32_t m_nChannel; + int32_t m_nFlags; + int64_t m_nUserData; + uint16_t m_idxLane; + uint16_t _pad1__; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SteamNetworkingMessage_t_153a w_SteamNetworkingMessage_t_153a; +typedef u32_SteamNetworkingMessage_t_153a u_SteamNetworkingMessage_t_153a; +#endif +#ifdef __x86_64__ +typedef w64_SteamNetworkingMessage_t_153a w_SteamNetworkingMessage_t_153a; +typedef u64_SteamNetworkingMessage_t_153a u_SteamNetworkingMessage_t_153a; +#endif + +#pragma pack( push, 8 ) +struct w64_SteamNetworkingMessage_t_147 +{ + W64_PTR(void *m_pData, m_pData); + int32_t m_cbSize; + uint32_t m_conn; + SteamNetworkingIdentity_144 m_identityPeer; + int64_t m_nConnUserData; + int64_t m_usecTimeReceived; + int64_t m_nMessageNumber; + W64_PTR(void (*W_STDCALL m_pfnFreeData)(w64_SteamNetworkingMessage_t_147 *), m_pfnFreeData); + W64_PTR(void (*W_STDCALL m_pfnRelease)(w64_SteamNetworkingMessage_t_147 *), m_pfnRelease); + int32_t m_nChannel; + int32_t m_nFlags; + int64_t m_nUserData; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct u64_SteamNetworkingMessage_t_147 +{ + U64_PTR(void *m_pData, m_pData); + int32_t m_cbSize; + uint32_t m_conn; + SteamNetworkingIdentity_144 m_identityPeer; + int64_t m_nConnUserData; + int64_t m_usecTimeReceived; + int64_t m_nMessageNumber; + U64_PTR(void (*U_STDCALL m_pfnFreeData)(u64_SteamNetworkingMessage_t_147 *), m_pfnFreeData); + U64_PTR(void (*U_STDCALL m_pfnRelease)(u64_SteamNetworkingMessage_t_147 *), m_pfnRelease); + int32_t m_nChannel; + int32_t m_nFlags; + int64_t m_nUserData; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_SteamNetworkingMessage_t_147 +{ + W32_PTR(void *m_pData, m_pData); + int32_t m_cbSize; + uint32_t m_conn; + SteamNetworkingIdentity_144 m_identityPeer; + uint8_t __pad_148[4]; + int64_t m_nConnUserData; + int64_t m_usecTimeReceived; + int64_t m_nMessageNumber; + W32_PTR(void (*W_STDCALL m_pfnFreeData)(w32_SteamNetworkingMessage_t_147 *), m_pfnFreeData); + W32_PTR(void (*W_STDCALL m_pfnRelease)(w32_SteamNetworkingMessage_t_147 *), m_pfnRelease); + int32_t m_nChannel; + int32_t m_nFlags; + int64_t m_nUserData; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_SteamNetworkingMessage_t_147 +{ + U32_PTR(void *m_pData, m_pData); + int32_t m_cbSize; + uint32_t m_conn; + SteamNetworkingIdentity_144 m_identityPeer; + int64_t m_nConnUserData; + int64_t m_usecTimeReceived; + int64_t m_nMessageNumber; + U32_PTR(void (*U_STDCALL m_pfnFreeData)(u32_SteamNetworkingMessage_t_147 *), m_pfnFreeData); + U32_PTR(void (*U_STDCALL m_pfnRelease)(u32_SteamNetworkingMessage_t_147 *), m_pfnRelease); + int32_t m_nChannel; + int32_t m_nFlags; + int64_t m_nUserData; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SteamNetworkingMessage_t_147 w_SteamNetworkingMessage_t_147; +typedef u32_SteamNetworkingMessage_t_147 u_SteamNetworkingMessage_t_147; +#endif +#ifdef __x86_64__ +typedef w64_SteamNetworkingMessage_t_147 w_SteamNetworkingMessage_t_147; +typedef u64_SteamNetworkingMessage_t_147 u_SteamNetworkingMessage_t_147; +#endif + +#pragma pack( push, 8 ) +struct w64_SteamNetworkingMessage_t_151 +{ + W64_PTR(void *m_pData, m_pData); + int32_t m_cbSize; + uint32_t m_conn; + SteamNetworkingIdentity_151 m_identityPeer; + int64_t m_nConnUserData; + int64_t m_usecTimeReceived; + int64_t m_nMessageNumber; + W64_PTR(void (*W_STDCALL m_pfnFreeData)(w64_SteamNetworkingMessage_t_151 *), m_pfnFreeData); + W64_PTR(void (*W_STDCALL m_pfnRelease)(w64_SteamNetworkingMessage_t_151 *), m_pfnRelease); + int32_t m_nChannel; + int32_t m_nFlags; + int64_t m_nUserData; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct u64_SteamNetworkingMessage_t_151 +{ + U64_PTR(void *m_pData, m_pData); + int32_t m_cbSize; + uint32_t m_conn; + SteamNetworkingIdentity_151 m_identityPeer; + int64_t m_nConnUserData; + int64_t m_usecTimeReceived; + int64_t m_nMessageNumber; + U64_PTR(void (*U_STDCALL m_pfnFreeData)(u64_SteamNetworkingMessage_t_151 *), m_pfnFreeData); + U64_PTR(void (*U_STDCALL m_pfnRelease)(u64_SteamNetworkingMessage_t_151 *), m_pfnRelease); + int32_t m_nChannel; + int32_t m_nFlags; + int64_t m_nUserData; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_SteamNetworkingMessage_t_151 +{ + W32_PTR(void *m_pData, m_pData); + int32_t m_cbSize; + uint32_t m_conn; + SteamNetworkingIdentity_151 m_identityPeer; + uint8_t __pad_20[4]; + int64_t m_nConnUserData; + int64_t m_usecTimeReceived; + int64_t m_nMessageNumber; + W32_PTR(void (*W_STDCALL m_pfnFreeData)(w32_SteamNetworkingMessage_t_151 *), m_pfnFreeData); + W32_PTR(void (*W_STDCALL m_pfnRelease)(w32_SteamNetworkingMessage_t_151 *), m_pfnRelease); + int32_t m_nChannel; + int32_t m_nFlags; + int64_t m_nUserData; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_SteamNetworkingMessage_t_151 +{ + U32_PTR(void *m_pData, m_pData); + int32_t m_cbSize; + uint32_t m_conn; + SteamNetworkingIdentity_151 m_identityPeer; + int64_t m_nConnUserData; + int64_t m_usecTimeReceived; + int64_t m_nMessageNumber; + U32_PTR(void (*U_STDCALL m_pfnFreeData)(u32_SteamNetworkingMessage_t_151 *), m_pfnFreeData); + U32_PTR(void (*U_STDCALL m_pfnRelease)(u32_SteamNetworkingMessage_t_151 *), m_pfnRelease); + int32_t m_nChannel; + int32_t m_nFlags; + int64_t m_nUserData; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SteamNetworkingMessage_t_151 w_SteamNetworkingMessage_t_151; +typedef u32_SteamNetworkingMessage_t_151 u_SteamNetworkingMessage_t_151; +#endif +#ifdef __x86_64__ +typedef w64_SteamNetworkingMessage_t_151 w_SteamNetworkingMessage_t_151; +typedef u64_SteamNetworkingMessage_t_151 u_SteamNetworkingMessage_t_151; +#endif + +#pragma pack( push, 8 ) +struct w64_SteamNetworkingMessage_t_144 +{ + W64_PTR(void *m_pData, m_pData); + uint32_t m_cbSize; + uint32_t m_conn; + SteamNetworkingIdentity_144 m_sender; + int64_t m_nConnUserData; + int64_t m_usecTimeReceived; + int64_t m_nMessageNumber; + W64_PTR(void (*W_STDCALL m_pfnFreeData)(w64_SteamNetworkingMessage_t_144 *), m_pfnFreeData); + W64_PTR(void (*W_STDCALL m_pfnRelease)(w64_SteamNetworkingMessage_t_144 *), m_pfnRelease); + int32_t m_nChannel; + int32_t m___nPadDummy; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct u64_SteamNetworkingMessage_t_144 +{ + U64_PTR(void *m_pData, m_pData); + uint32_t m_cbSize; + uint32_t m_conn; + SteamNetworkingIdentity_144 m_sender; + int64_t m_nConnUserData; + int64_t m_usecTimeReceived; + int64_t m_nMessageNumber; + U64_PTR(void (*U_STDCALL m_pfnFreeData)(u64_SteamNetworkingMessage_t_144 *), m_pfnFreeData); + U64_PTR(void (*U_STDCALL m_pfnRelease)(u64_SteamNetworkingMessage_t_144 *), m_pfnRelease); + int32_t m_nChannel; + int32_t m___nPadDummy; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_SteamNetworkingMessage_t_144 +{ + W32_PTR(void *m_pData, m_pData); + uint32_t m_cbSize; + uint32_t m_conn; + SteamNetworkingIdentity_144 m_sender; + uint8_t __pad_148[4]; + int64_t m_nConnUserData; + int64_t m_usecTimeReceived; + int64_t m_nMessageNumber; + W32_PTR(void (*W_STDCALL m_pfnFreeData)(w32_SteamNetworkingMessage_t_144 *), m_pfnFreeData); + W32_PTR(void (*W_STDCALL m_pfnRelease)(w32_SteamNetworkingMessage_t_144 *), m_pfnRelease); + int32_t m_nChannel; + int32_t m___nPadDummy; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_SteamNetworkingMessage_t_144 +{ + U32_PTR(void *m_pData, m_pData); + uint32_t m_cbSize; + uint32_t m_conn; + SteamNetworkingIdentity_144 m_sender; + int64_t m_nConnUserData; + int64_t m_usecTimeReceived; + int64_t m_nMessageNumber; + U32_PTR(void (*U_STDCALL m_pfnFreeData)(u32_SteamNetworkingMessage_t_144 *), m_pfnFreeData); + U32_PTR(void (*U_STDCALL m_pfnRelease)(u32_SteamNetworkingMessage_t_144 *), m_pfnRelease); + int32_t m_nChannel; + int32_t m___nPadDummy; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SteamNetworkingMessage_t_144 w_SteamNetworkingMessage_t_144; +typedef u32_SteamNetworkingMessage_t_144 u_SteamNetworkingMessage_t_144; +#endif +#ifdef __x86_64__ +typedef w64_SteamNetworkingMessage_t_144 w_SteamNetworkingMessage_t_144; +typedef u64_SteamNetworkingMessage_t_144 u_SteamNetworkingMessage_t_144; +#endif + +#pragma pack( push, 8 ) +struct w64_SteamParamStringArray_t +{ + W64_PTR(const char **m_ppStrings, m_ppStrings); + int32_t m_nNumStrings; + uint8_t __pad_12[4]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct w32_SteamParamStringArray_t +{ + W32_PTR(const char **m_ppStrings, m_ppStrings); + int32_t m_nNumStrings; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SteamParamStringArray_t w_SteamParamStringArray_t; +typedef u32_SteamParamStringArray_t u_SteamParamStringArray_t; +#endif +#ifdef __x86_64__ +typedef w64_SteamParamStringArray_t w_SteamParamStringArray_t; +typedef u64_SteamParamStringArray_t u_SteamParamStringArray_t; +#endif + +#pragma pack( push, 8 ) +struct w64_SteamPartyBeaconLocation_t +{ + uint32_t m_eType; + uint8_t __pad_4[4]; + uint64_t m_ulLocationID; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_SteamPartyBeaconLocation_t +{ + uint32_t m_eType; + uint64_t m_ulLocationID; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_SteamPartyBeaconLocation_t +{ + uint32_t m_eType; + uint8_t __pad_4[4]; + uint64_t m_ulLocationID; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_SteamPartyBeaconLocation_t +{ + uint32_t m_eType; + uint64_t m_ulLocationID; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SteamPartyBeaconLocation_t w_SteamPartyBeaconLocation_t; +typedef u32_SteamPartyBeaconLocation_t u_SteamPartyBeaconLocation_t; +#endif +#ifdef __x86_64__ +typedef w64_SteamPartyBeaconLocation_t w_SteamPartyBeaconLocation_t; +typedef u64_SteamPartyBeaconLocation_t u_SteamPartyBeaconLocation_t; +#endif + +#pragma pack( push, 8 ) +struct w64_SteamUGCRequestUGCDetailsResult_t_128x +{ + w64_SteamUGCDetails_t_128x m_details; + bool m_bCachedData; + uint8_t __pad_9777[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_SteamUGCRequestUGCDetailsResult_t_128x +{ + u64_SteamUGCDetails_t_128x m_details; + bool m_bCachedData; + uint8_t __pad_9765[3]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_SteamUGCRequestUGCDetailsResult_t_128x +{ + w32_SteamUGCDetails_t_128x m_details; + bool m_bCachedData; + uint8_t __pad_9777[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_SteamUGCRequestUGCDetailsResult_t_128x +{ + u32_SteamUGCDetails_t_128x m_details; + bool m_bCachedData; + uint8_t __pad_9765[3]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SteamUGCRequestUGCDetailsResult_t_128x w_SteamUGCRequestUGCDetailsResult_t_128x; +typedef u32_SteamUGCRequestUGCDetailsResult_t_128x u_SteamUGCRequestUGCDetailsResult_t_128x; +#endif +#ifdef __x86_64__ +typedef w64_SteamUGCRequestUGCDetailsResult_t_128x w_SteamUGCRequestUGCDetailsResult_t_128x; +typedef u64_SteamUGCRequestUGCDetailsResult_t_128x u_SteamUGCRequestUGCDetailsResult_t_128x; +#endif + +#pragma pack( push, 8 ) +struct w64_SteamUGCRequestUGCDetailsResult_t_129 +{ + w64_SteamUGCDetails_t_126 m_details; + bool m_bCachedData; + uint8_t __pad_9769[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_SteamUGCRequestUGCDetailsResult_t_129 +{ + u64_SteamUGCDetails_t_126 m_details; + bool m_bCachedData; + uint8_t __pad_9761[3]; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_SteamUGCRequestUGCDetailsResult_t_129 +{ + w32_SteamUGCDetails_t_126 m_details; + bool m_bCachedData; + uint8_t __pad_9769[7]; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_SteamUGCRequestUGCDetailsResult_t_129 +{ + u32_SteamUGCDetails_t_126 m_details; + bool m_bCachedData; + uint8_t __pad_9761[3]; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SteamUGCRequestUGCDetailsResult_t_129 w_SteamUGCRequestUGCDetailsResult_t_129; +typedef u32_SteamUGCRequestUGCDetailsResult_t_129 u_SteamUGCRequestUGCDetailsResult_t_129; +#endif +#ifdef __x86_64__ +typedef w64_SteamUGCRequestUGCDetailsResult_t_129 w_SteamUGCRequestUGCDetailsResult_t_129; +typedef u64_SteamUGCRequestUGCDetailsResult_t_129 u_SteamUGCRequestUGCDetailsResult_t_129; +#endif + +#pragma pack( push, 8 ) +struct w64_SteamUGCRequestUGCDetailsResult_t_126 +{ + w64_SteamUGCDetails_t_126 m_details; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_SteamUGCRequestUGCDetailsResult_t_126 +{ + u64_SteamUGCDetails_t_126 m_details; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_SteamUGCRequestUGCDetailsResult_t_126 +{ + w32_SteamUGCDetails_t_126 m_details; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_SteamUGCRequestUGCDetailsResult_t_126 +{ + u32_SteamUGCDetails_t_126 m_details; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SteamUGCRequestUGCDetailsResult_t_126 w_SteamUGCRequestUGCDetailsResult_t_126; +typedef u32_SteamUGCRequestUGCDetailsResult_t_126 u_SteamUGCRequestUGCDetailsResult_t_126; +#endif +#ifdef __x86_64__ +typedef w64_SteamUGCRequestUGCDetailsResult_t_126 w_SteamUGCRequestUGCDetailsResult_t_126; +typedef u64_SteamUGCRequestUGCDetailsResult_t_126 u_SteamUGCRequestUGCDetailsResult_t_126; +#endif + +#pragma pack( push, 8 ) +struct w64_SubmitPlayerResultResultCallback_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t ullUniqueGameID; + CSteamID steamIDPlayer; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u64_SubmitPlayerResultResultCallback_t +{ + uint32_t m_eResult; + uint64_t ullUniqueGameID; + CSteamID steamIDPlayer; +}; +#pragma pack( pop ) + +#pragma pack( push, 8 ) +struct w32_SubmitPlayerResultResultCallback_t +{ + uint32_t m_eResult; + uint8_t __pad_4[4]; + uint64_t ullUniqueGameID; + CSteamID steamIDPlayer; +}; +#pragma pack( pop ) + +#pragma pack( push, 4 ) +struct u32_SubmitPlayerResultResultCallback_t +{ + uint32_t m_eResult; + uint64_t ullUniqueGameID; + CSteamID steamIDPlayer; +}; +#pragma pack( pop ) + +#ifdef __i386__ +typedef w32_SubmitPlayerResultResultCallback_t w_SubmitPlayerResultResultCallback_t; +typedef u32_SubmitPlayerResultResultCallback_t u_SubmitPlayerResultResultCallback_t; +#endif +#ifdef __x86_64__ +typedef w64_SubmitPlayerResultResultCallback_t w_SubmitPlayerResultResultCallback_t; +typedef u64_SubmitPlayerResultResultCallback_t u_SubmitPlayerResultResultCallback_t; +#endif + diff --git a/lsteamclient/unixlib_generated.cpp b/lsteamclient/unixlib_generated.cpp new file mode 100644 index 00000000..fd030eed --- /dev/null +++ b/lsteamclient/unixlib_generated.cpp @@ -0,0 +1,8438 @@ +/* This file is auto-generated, do not edit. */ + +#include "steamclient_structs.h" + +C_ASSERT( sizeof(SteamNetworkingIPAddr) >= 18 ); +C_ASSERT( offsetof(SteamNetworkingIPAddr, data) == 0 ); +C_ASSERT( sizeof(SteamNetworkingIPAddr().data) >= 16 ); +C_ASSERT( offsetof(SteamNetworkingIPAddr, m_port) == 16 ); +C_ASSERT( sizeof(SteamNetworkingIPAddr().m_port) >= 2 ); + +C_ASSERT( sizeof(SteamNetworkingIdentity_144) >= 136 ); +C_ASSERT( offsetof(SteamNetworkingIdentity_144, m_eType) == 0 ); +C_ASSERT( sizeof(SteamNetworkingIdentity_144().m_eType) >= 4 ); +C_ASSERT( offsetof(SteamNetworkingIdentity_144, m_cbSize) == 4 ); +C_ASSERT( sizeof(SteamNetworkingIdentity_144().m_cbSize) >= 4 ); +C_ASSERT( offsetof(SteamNetworkingIdentity_144, data) == 8 ); +C_ASSERT( sizeof(SteamNetworkingIdentity_144().data) >= 128 ); + +C_ASSERT( sizeof(SteamNetworkingIdentity_151) >= 8 ); +C_ASSERT( offsetof(SteamNetworkingIdentity_151, m_eType) == 0 ); +C_ASSERT( sizeof(SteamNetworkingIdentity_151().m_eType) >= 4 ); +C_ASSERT( offsetof(SteamNetworkingIdentity_151, m_cbSize) == 4 ); +C_ASSERT( sizeof(SteamNetworkingIdentity_151().m_cbSize) >= 4 ); + +C_ASSERT( sizeof(SteamNetConnectionInfo_t_153a) >= 696 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_153a, m_identityRemote) == 0 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_153a().m_identityRemote) >= 136 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_153a, m_nUserData) == 136 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_153a().m_nUserData) >= 8 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_153a, m_hListenSocket) == 144 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_153a().m_hListenSocket) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_153a, m_addrRemote) == 148 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_153a().m_addrRemote) >= 18 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_153a, m__pad1) == 166 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_153a().m__pad1) >= 2 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_153a, m_idPOPRemote) == 168 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_153a().m_idPOPRemote) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_153a, m_idPOPRelay) == 172 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_153a().m_idPOPRelay) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_153a, m_eState) == 176 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_153a().m_eState) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_153a, m_eEndReason) == 180 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_153a().m_eEndReason) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_153a, m_szEndDebug) == 184 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_153a().m_szEndDebug) >= 128 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_153a, m_szConnectionDescription) == 312 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_153a().m_szConnectionDescription) >= 128 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_153a, m_nFlags) == 440 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_153a().m_nFlags) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_153a, reserved) == 444 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_153a().reserved) >= 252 ); + +C_ASSERT( sizeof(SteamNetConnectionInfo_t_144) >= 696 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_144, m_identityRemote) == 0 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_144().m_identityRemote) >= 136 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_144, m_nUserData) == 136 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_144().m_nUserData) >= 8 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_144, m_hListenSocket) == 144 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_144().m_hListenSocket) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_144, m_addrRemote) == 148 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_144().m_addrRemote) >= 18 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_144, m__pad1) == 166 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_144().m__pad1) >= 2 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_144, m_idPOPRemote) == 168 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_144().m_idPOPRemote) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_144, m_idPOPRelay) == 172 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_144().m_idPOPRelay) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_144, m_eState) == 176 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_144().m_eState) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_144, m_eEndReason) == 180 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_144().m_eEndReason) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_144, m_szEndDebug) == 184 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_144().m_szEndDebug) >= 128 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_144, m_szConnectionDescription) == 312 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_144().m_szConnectionDescription) >= 128 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_144, reserved) == 440 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_144().reserved) >= 256 ); + +C_ASSERT( sizeof(SteamNetConnectionInfo_t_151) >= 568 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_151, m_identityRemote) == 0 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_151().m_identityRemote) >= 8 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_151, m_nUserData) == 8 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_151().m_nUserData) >= 8 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_151, m_hListenSocket) == 16 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_151().m_hListenSocket) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_151, m_addrRemote) == 20 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_151().m_addrRemote) >= 18 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_151, m__pad1) == 38 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_151().m__pad1) >= 2 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_151, m_idPOPRemote) == 40 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_151().m_idPOPRemote) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_151, m_idPOPRelay) == 44 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_151().m_idPOPRelay) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_151, m_eState) == 48 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_151().m_eState) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_151, m_eEndReason) == 52 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_151().m_eEndReason) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_151, m_szEndDebug) == 56 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_151().m_szEndDebug) >= 128 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_151, m_szConnectionDescription) == 184 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_151().m_szConnectionDescription) >= 128 ); +C_ASSERT( offsetof(SteamNetConnectionInfo_t_151, reserved) == 312 ); +C_ASSERT( sizeof(SteamNetConnectionInfo_t_151().reserved) >= 256 ); + +C_ASSERT( sizeof(servernetadr_t) >= 8 ); +C_ASSERT( offsetof(servernetadr_t, m_usConnectionPort) == 0 ); +C_ASSERT( sizeof(servernetadr_t().m_usConnectionPort) >= 2 ); +C_ASSERT( offsetof(servernetadr_t, m_usQueryPort) == 2 ); +C_ASSERT( sizeof(servernetadr_t().m_usQueryPort) >= 2 ); +C_ASSERT( offsetof(servernetadr_t, m_unIP) == 4 ); +C_ASSERT( sizeof(servernetadr_t().m_unIP) >= 4 ); + +C_ASSERT( sizeof(ActiveBeaconsUpdated_t) >= 1 ); + +C_ASSERT( sizeof(AppDataChanged_t) >= 8 ); +C_ASSERT( offsetof(AppDataChanged_t, m_nAppID) == 0 ); +C_ASSERT( sizeof(AppDataChanged_t().m_nAppID) >= 4 ); +C_ASSERT( offsetof(AppDataChanged_t, m_bBySteamUI) == 4 ); +C_ASSERT( sizeof(AppDataChanged_t().m_bBySteamUI) >= 1 ); +C_ASSERT( offsetof(AppDataChanged_t, m_bCDDBUpdate) == 5 ); +C_ASSERT( sizeof(AppDataChanged_t().m_bCDDBUpdate) >= 1 ); + +C_ASSERT( sizeof(AppProofOfPurchaseKeyResponse_t_137) >= 252 ); +C_ASSERT( offsetof(AppProofOfPurchaseKeyResponse_t_137, m_eResult) == 0 ); +C_ASSERT( sizeof(AppProofOfPurchaseKeyResponse_t_137().m_eResult) >= 4 ); +C_ASSERT( offsetof(AppProofOfPurchaseKeyResponse_t_137, m_nAppID) == 4 ); +C_ASSERT( sizeof(AppProofOfPurchaseKeyResponse_t_137().m_nAppID) >= 4 ); +C_ASSERT( offsetof(AppProofOfPurchaseKeyResponse_t_137, m_cchKeyLength) == 8 ); +C_ASSERT( sizeof(AppProofOfPurchaseKeyResponse_t_137().m_cchKeyLength) >= 4 ); +C_ASSERT( offsetof(AppProofOfPurchaseKeyResponse_t_137, m_rgchKey) == 12 ); +C_ASSERT( sizeof(AppProofOfPurchaseKeyResponse_t_137().m_rgchKey) >= 240 ); + +C_ASSERT( sizeof(AppProofOfPurchaseKeyResponse_t_118) >= 72 ); +C_ASSERT( offsetof(AppProofOfPurchaseKeyResponse_t_118, m_eResult) == 0 ); +C_ASSERT( sizeof(AppProofOfPurchaseKeyResponse_t_118().m_eResult) >= 4 ); +C_ASSERT( offsetof(AppProofOfPurchaseKeyResponse_t_118, m_nAppID) == 4 ); +C_ASSERT( sizeof(AppProofOfPurchaseKeyResponse_t_118().m_nAppID) >= 4 ); +C_ASSERT( offsetof(AppProofOfPurchaseKeyResponse_t_118, m_rgchKey) == 8 ); +C_ASSERT( sizeof(AppProofOfPurchaseKeyResponse_t_118().m_rgchKey) >= 64 ); + +C_ASSERT( sizeof(AppResumingFromSuspend_t) >= 1 ); + +C_ASSERT( sizeof(AssociateWithClanResult_t) >= 4 ); +C_ASSERT( offsetof(AssociateWithClanResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(AssociateWithClanResult_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(AvailableBeaconLocationsUpdated_t) >= 1 ); + +C_ASSERT( sizeof(AvatarImageLoaded_t) >= 20 ); +C_ASSERT( offsetof(AvatarImageLoaded_t, m_steamID) == 0 ); +C_ASSERT( sizeof(AvatarImageLoaded_t().m_steamID) >= 8 ); +C_ASSERT( offsetof(AvatarImageLoaded_t, m_iImage) == 8 ); +C_ASSERT( sizeof(AvatarImageLoaded_t().m_iImage) >= 4 ); +C_ASSERT( offsetof(AvatarImageLoaded_t, m_iWide) == 12 ); +C_ASSERT( sizeof(AvatarImageLoaded_t().m_iWide) >= 4 ); +C_ASSERT( offsetof(AvatarImageLoaded_t, m_iTall) == 16 ); +C_ASSERT( sizeof(AvatarImageLoaded_t().m_iTall) >= 4 ); + +C_ASSERT( sizeof(BroadcastUploadStart_t) >= 1 ); + +C_ASSERT( sizeof(BroadcastUploadStop_t) >= 4 ); +C_ASSERT( offsetof(BroadcastUploadStop_t, m_eResult) == 0 ); +C_ASSERT( sizeof(BroadcastUploadStop_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(CallbackPipeFailure_t) >= 1 ); + +C_ASSERT( sizeof(ChangeNumOpenSlotsCallback_t) >= 4 ); +C_ASSERT( offsetof(ChangeNumOpenSlotsCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(ChangeNumOpenSlotsCallback_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(CheckFileSignature_t) >= 4 ); +C_ASSERT( offsetof(CheckFileSignature_t, m_eCheckFileSignature) == 0 ); +C_ASSERT( sizeof(CheckFileSignature_t().m_eCheckFileSignature) >= 4 ); + +C_ASSERT( sizeof(ClanOfficerListResponse_t) >= 16 ); +C_ASSERT( offsetof(ClanOfficerListResponse_t, m_steamIDClan) == 0 ); +C_ASSERT( sizeof(ClanOfficerListResponse_t().m_steamIDClan) >= 8 ); +C_ASSERT( offsetof(ClanOfficerListResponse_t, m_cOfficers) == 8 ); +C_ASSERT( sizeof(ClanOfficerListResponse_t().m_cOfficers) >= 4 ); +C_ASSERT( offsetof(ClanOfficerListResponse_t, m_bSuccess) == 12 ); +C_ASSERT( sizeof(ClanOfficerListResponse_t().m_bSuccess) >= 1 ); + +C_ASSERT( sizeof(ClientGameServerDeny_t) >= 16 ); +C_ASSERT( offsetof(ClientGameServerDeny_t, m_uAppID) == 0 ); +C_ASSERT( sizeof(ClientGameServerDeny_t().m_uAppID) >= 4 ); +C_ASSERT( offsetof(ClientGameServerDeny_t, m_unGameServerIP) == 4 ); +C_ASSERT( sizeof(ClientGameServerDeny_t().m_unGameServerIP) >= 4 ); +C_ASSERT( offsetof(ClientGameServerDeny_t, m_usGameServerPort) == 8 ); +C_ASSERT( sizeof(ClientGameServerDeny_t().m_usGameServerPort) >= 2 ); +C_ASSERT( offsetof(ClientGameServerDeny_t, m_bSecure) == 10 ); +C_ASSERT( sizeof(ClientGameServerDeny_t().m_bSecure) >= 2 ); +C_ASSERT( offsetof(ClientGameServerDeny_t, m_uReason) == 12 ); +C_ASSERT( sizeof(ClientGameServerDeny_t().m_uReason) >= 4 ); + +C_ASSERT( sizeof(ComputeNewPlayerCompatibilityResult_t_119) >= 24 ); +C_ASSERT( offsetof(ComputeNewPlayerCompatibilityResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(ComputeNewPlayerCompatibilityResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(ComputeNewPlayerCompatibilityResult_t_119, m_cPlayersThatDontLikeCandidate) == 4 ); +C_ASSERT( sizeof(ComputeNewPlayerCompatibilityResult_t_119().m_cPlayersThatDontLikeCandidate) >= 4 ); +C_ASSERT( offsetof(ComputeNewPlayerCompatibilityResult_t_119, m_cPlayersThatCandidateDoesntLike) == 8 ); +C_ASSERT( sizeof(ComputeNewPlayerCompatibilityResult_t_119().m_cPlayersThatCandidateDoesntLike) >= 4 ); +C_ASSERT( offsetof(ComputeNewPlayerCompatibilityResult_t_119, m_cClanPlayersThatDontLikeCandidate) == 12 ); +C_ASSERT( sizeof(ComputeNewPlayerCompatibilityResult_t_119().m_cClanPlayersThatDontLikeCandidate) >= 4 ); +C_ASSERT( offsetof(ComputeNewPlayerCompatibilityResult_t_119, m_SteamIDCandidate) == 16 ); +C_ASSERT( sizeof(ComputeNewPlayerCompatibilityResult_t_119().m_SteamIDCandidate) >= 8 ); + +C_ASSERT( sizeof(ComputeNewPlayerCompatibilityResult_t_116x) >= 16 ); +C_ASSERT( offsetof(ComputeNewPlayerCompatibilityResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(ComputeNewPlayerCompatibilityResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(ComputeNewPlayerCompatibilityResult_t_116x, m_cPlayersThatDontLikeCandidate) == 4 ); +C_ASSERT( sizeof(ComputeNewPlayerCompatibilityResult_t_116x().m_cPlayersThatDontLikeCandidate) >= 4 ); +C_ASSERT( offsetof(ComputeNewPlayerCompatibilityResult_t_116x, m_cPlayersThatCandidateDoesntLike) == 8 ); +C_ASSERT( sizeof(ComputeNewPlayerCompatibilityResult_t_116x().m_cPlayersThatCandidateDoesntLike) >= 4 ); +C_ASSERT( offsetof(ComputeNewPlayerCompatibilityResult_t_116x, m_cClanPlayersThatDontLikeCandidate) == 12 ); +C_ASSERT( sizeof(ComputeNewPlayerCompatibilityResult_t_116x().m_cClanPlayersThatDontLikeCandidate) >= 4 ); + +C_ASSERT( sizeof(ControllerAnalogActionData_t) >= 13 ); +C_ASSERT( offsetof(ControllerAnalogActionData_t, eMode) == 0 ); +C_ASSERT( sizeof(ControllerAnalogActionData_t().eMode) >= 4 ); +C_ASSERT( offsetof(ControllerAnalogActionData_t, x) == 4 ); +C_ASSERT( sizeof(ControllerAnalogActionData_t().x) >= 4 ); +C_ASSERT( offsetof(ControllerAnalogActionData_t, y) == 8 ); +C_ASSERT( sizeof(ControllerAnalogActionData_t().y) >= 4 ); +C_ASSERT( offsetof(ControllerAnalogActionData_t, bActive) == 12 ); +C_ASSERT( sizeof(ControllerAnalogActionData_t().bActive) >= 1 ); + +C_ASSERT( sizeof(ControllerDigitalActionData_t) >= 2 ); +C_ASSERT( offsetof(ControllerDigitalActionData_t, bState) == 0 ); +C_ASSERT( sizeof(ControllerDigitalActionData_t().bState) >= 1 ); +C_ASSERT( offsetof(ControllerDigitalActionData_t, bActive) == 1 ); +C_ASSERT( sizeof(ControllerDigitalActionData_t().bActive) >= 1 ); + +C_ASSERT( sizeof(ControllerMotionData_t) >= 40 ); +C_ASSERT( offsetof(ControllerMotionData_t, rotQuatX) == 0 ); +C_ASSERT( sizeof(ControllerMotionData_t().rotQuatX) >= 4 ); +C_ASSERT( offsetof(ControllerMotionData_t, rotQuatY) == 4 ); +C_ASSERT( sizeof(ControllerMotionData_t().rotQuatY) >= 4 ); +C_ASSERT( offsetof(ControllerMotionData_t, rotQuatZ) == 8 ); +C_ASSERT( sizeof(ControllerMotionData_t().rotQuatZ) >= 4 ); +C_ASSERT( offsetof(ControllerMotionData_t, rotQuatW) == 12 ); +C_ASSERT( sizeof(ControllerMotionData_t().rotQuatW) >= 4 ); +C_ASSERT( offsetof(ControllerMotionData_t, posAccelX) == 16 ); +C_ASSERT( sizeof(ControllerMotionData_t().posAccelX) >= 4 ); +C_ASSERT( offsetof(ControllerMotionData_t, posAccelY) == 20 ); +C_ASSERT( sizeof(ControllerMotionData_t().posAccelY) >= 4 ); +C_ASSERT( offsetof(ControllerMotionData_t, posAccelZ) == 24 ); +C_ASSERT( sizeof(ControllerMotionData_t().posAccelZ) >= 4 ); +C_ASSERT( offsetof(ControllerMotionData_t, rotVelX) == 28 ); +C_ASSERT( sizeof(ControllerMotionData_t().rotVelX) >= 4 ); +C_ASSERT( offsetof(ControllerMotionData_t, rotVelY) == 32 ); +C_ASSERT( sizeof(ControllerMotionData_t().rotVelY) >= 4 ); +C_ASSERT( offsetof(ControllerMotionData_t, rotVelZ) == 36 ); +C_ASSERT( sizeof(ControllerMotionData_t().rotVelZ) >= 4 ); + +C_ASSERT( sizeof(DlcInstalled_t) >= 4 ); +C_ASSERT( offsetof(DlcInstalled_t, m_nAppID) == 0 ); +C_ASSERT( sizeof(DlcInstalled_t().m_nAppID) >= 4 ); + +C_ASSERT( sizeof(DownloadClanActivityCountsResult_t) >= 1 ); +C_ASSERT( offsetof(DownloadClanActivityCountsResult_t, m_bSuccess) == 0 ); +C_ASSERT( sizeof(DownloadClanActivityCountsResult_t().m_bSuccess) >= 1 ); + +C_ASSERT( sizeof(DurationControl_t_147) >= 32 ); +C_ASSERT( offsetof(DurationControl_t_147, m_eResult) == 0 ); +C_ASSERT( sizeof(DurationControl_t_147().m_eResult) >= 4 ); +C_ASSERT( offsetof(DurationControl_t_147, m_appid) == 4 ); +C_ASSERT( sizeof(DurationControl_t_147().m_appid) >= 4 ); +C_ASSERT( offsetof(DurationControl_t_147, m_bApplicable) == 8 ); +C_ASSERT( sizeof(DurationControl_t_147().m_bApplicable) >= 1 ); +C_ASSERT( offsetof(DurationControl_t_147, m_csecsLast5h) == 12 ); +C_ASSERT( sizeof(DurationControl_t_147().m_csecsLast5h) >= 4 ); +C_ASSERT( offsetof(DurationControl_t_147, m_progress) == 16 ); +C_ASSERT( sizeof(DurationControl_t_147().m_progress) >= 4 ); +C_ASSERT( offsetof(DurationControl_t_147, m_notification) == 20 ); +C_ASSERT( sizeof(DurationControl_t_147().m_notification) >= 4 ); +C_ASSERT( offsetof(DurationControl_t_147, m_csecsToday) == 24 ); +C_ASSERT( sizeof(DurationControl_t_147().m_csecsToday) >= 4 ); +C_ASSERT( offsetof(DurationControl_t_147, m_csecsRemaining) == 28 ); +C_ASSERT( sizeof(DurationControl_t_147().m_csecsRemaining) >= 4 ); + +C_ASSERT( sizeof(DurationControl_t_145) >= 24 ); +C_ASSERT( offsetof(DurationControl_t_145, m_eResult) == 0 ); +C_ASSERT( sizeof(DurationControl_t_145().m_eResult) >= 4 ); +C_ASSERT( offsetof(DurationControl_t_145, m_appid) == 4 ); +C_ASSERT( sizeof(DurationControl_t_145().m_appid) >= 4 ); +C_ASSERT( offsetof(DurationControl_t_145, m_bApplicable) == 8 ); +C_ASSERT( sizeof(DurationControl_t_145().m_bApplicable) >= 1 ); +C_ASSERT( offsetof(DurationControl_t_145, m_csecsLast5h) == 12 ); +C_ASSERT( sizeof(DurationControl_t_145().m_csecsLast5h) >= 4 ); +C_ASSERT( offsetof(DurationControl_t_145, m_progress) == 16 ); +C_ASSERT( sizeof(DurationControl_t_145().m_progress) >= 4 ); +C_ASSERT( offsetof(DurationControl_t_145, m_notification) == 20 ); +C_ASSERT( sizeof(DurationControl_t_145().m_notification) >= 4 ); + +C_ASSERT( sizeof(EncryptedAppTicketResponse_t) >= 4 ); +C_ASSERT( offsetof(EncryptedAppTicketResponse_t, m_eResult) == 0 ); +C_ASSERT( sizeof(EncryptedAppTicketResponse_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(EquippedProfileItemsChanged_t) >= 8 ); +C_ASSERT( offsetof(EquippedProfileItemsChanged_t, m_steamID) == 0 ); +C_ASSERT( sizeof(EquippedProfileItemsChanged_t().m_steamID) >= 8 ); + +C_ASSERT( sizeof(EquippedProfileItems_t) >= 20 ); +C_ASSERT( offsetof(EquippedProfileItems_t, m_eResult) == 0 ); +C_ASSERT( sizeof(EquippedProfileItems_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(EquippedProfileItems_t, m_steamID) == 4 ); +C_ASSERT( sizeof(EquippedProfileItems_t().m_steamID) >= 8 ); +C_ASSERT( offsetof(EquippedProfileItems_t, m_bHasAnimatedAvatar) == 12 ); +C_ASSERT( sizeof(EquippedProfileItems_t().m_bHasAnimatedAvatar) >= 1 ); +C_ASSERT( offsetof(EquippedProfileItems_t, m_bHasAvatarFrame) == 13 ); +C_ASSERT( sizeof(EquippedProfileItems_t().m_bHasAvatarFrame) >= 1 ); +C_ASSERT( offsetof(EquippedProfileItems_t, m_bHasProfileModifier) == 14 ); +C_ASSERT( sizeof(EquippedProfileItems_t().m_bHasProfileModifier) >= 1 ); +C_ASSERT( offsetof(EquippedProfileItems_t, m_bHasProfileBackground) == 15 ); +C_ASSERT( sizeof(EquippedProfileItems_t().m_bHasProfileBackground) >= 1 ); +C_ASSERT( offsetof(EquippedProfileItems_t, m_bHasMiniProfileBackground) == 16 ); +C_ASSERT( sizeof(EquippedProfileItems_t().m_bHasMiniProfileBackground) >= 1 ); + +C_ASSERT( sizeof(FavoritesListAccountsUpdated_t) >= 4 ); +C_ASSERT( offsetof(FavoritesListAccountsUpdated_t, m_eResult) == 0 ); +C_ASSERT( sizeof(FavoritesListAccountsUpdated_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(FavoritesListChanged_t_128x) >= 28 ); +C_ASSERT( offsetof(FavoritesListChanged_t_128x, m_nIP) == 0 ); +C_ASSERT( sizeof(FavoritesListChanged_t_128x().m_nIP) >= 4 ); +C_ASSERT( offsetof(FavoritesListChanged_t_128x, m_nQueryPort) == 4 ); +C_ASSERT( sizeof(FavoritesListChanged_t_128x().m_nQueryPort) >= 4 ); +C_ASSERT( offsetof(FavoritesListChanged_t_128x, m_nConnPort) == 8 ); +C_ASSERT( sizeof(FavoritesListChanged_t_128x().m_nConnPort) >= 4 ); +C_ASSERT( offsetof(FavoritesListChanged_t_128x, m_nAppID) == 12 ); +C_ASSERT( sizeof(FavoritesListChanged_t_128x().m_nAppID) >= 4 ); +C_ASSERT( offsetof(FavoritesListChanged_t_128x, m_nFlags) == 16 ); +C_ASSERT( sizeof(FavoritesListChanged_t_128x().m_nFlags) >= 4 ); +C_ASSERT( offsetof(FavoritesListChanged_t_128x, m_bAdd) == 20 ); +C_ASSERT( sizeof(FavoritesListChanged_t_128x().m_bAdd) >= 1 ); +C_ASSERT( offsetof(FavoritesListChanged_t_128x, m_unAccountId) == 24 ); +C_ASSERT( sizeof(FavoritesListChanged_t_128x().m_unAccountId) >= 4 ); + +C_ASSERT( sizeof(FavoritesListChanged_t_099u) >= 24 ); +C_ASSERT( offsetof(FavoritesListChanged_t_099u, m_nIP) == 0 ); +C_ASSERT( sizeof(FavoritesListChanged_t_099u().m_nIP) >= 4 ); +C_ASSERT( offsetof(FavoritesListChanged_t_099u, m_nQueryPort) == 4 ); +C_ASSERT( sizeof(FavoritesListChanged_t_099u().m_nQueryPort) >= 4 ); +C_ASSERT( offsetof(FavoritesListChanged_t_099u, m_nConnPort) == 8 ); +C_ASSERT( sizeof(FavoritesListChanged_t_099u().m_nConnPort) >= 4 ); +C_ASSERT( offsetof(FavoritesListChanged_t_099u, m_nAppID) == 12 ); +C_ASSERT( sizeof(FavoritesListChanged_t_099u().m_nAppID) >= 4 ); +C_ASSERT( offsetof(FavoritesListChanged_t_099u, m_nFlags) == 16 ); +C_ASSERT( sizeof(FavoritesListChanged_t_099u().m_nFlags) >= 4 ); +C_ASSERT( offsetof(FavoritesListChanged_t_099u, m_bAdd) == 20 ); +C_ASSERT( sizeof(FavoritesListChanged_t_099u().m_bAdd) >= 1 ); + +C_ASSERT( sizeof(FilterTextDictionaryChanged_t) >= 4 ); +C_ASSERT( offsetof(FilterTextDictionaryChanged_t, m_eLanguage) == 0 ); +C_ASSERT( sizeof(FilterTextDictionaryChanged_t().m_eLanguage) >= 4 ); + +C_ASSERT( sizeof(FloatingGamepadTextInputDismissed_t) >= 1 ); + +C_ASSERT( sizeof(FriendGameInfo_t) >= 24 ); +C_ASSERT( offsetof(FriendGameInfo_t, m_gameID) == 0 ); +C_ASSERT( sizeof(FriendGameInfo_t().m_gameID) >= 8 ); +C_ASSERT( offsetof(FriendGameInfo_t, m_unGameIP) == 8 ); +C_ASSERT( sizeof(FriendGameInfo_t().m_unGameIP) >= 4 ); +C_ASSERT( offsetof(FriendGameInfo_t, m_usGamePort) == 12 ); +C_ASSERT( sizeof(FriendGameInfo_t().m_usGamePort) >= 2 ); +C_ASSERT( offsetof(FriendGameInfo_t, m_usQueryPort) == 14 ); +C_ASSERT( sizeof(FriendGameInfo_t().m_usQueryPort) >= 2 ); +C_ASSERT( offsetof(FriendGameInfo_t, m_steamIDLobby) == 16 ); +C_ASSERT( sizeof(FriendGameInfo_t().m_steamIDLobby) >= 8 ); + +C_ASSERT( sizeof(FriendRichPresenceUpdate_t) >= 12 ); +C_ASSERT( offsetof(FriendRichPresenceUpdate_t, m_steamIDFriend) == 0 ); +C_ASSERT( sizeof(FriendRichPresenceUpdate_t().m_steamIDFriend) >= 8 ); +C_ASSERT( offsetof(FriendRichPresenceUpdate_t, m_nAppID) == 8 ); +C_ASSERT( sizeof(FriendRichPresenceUpdate_t().m_nAppID) >= 4 ); + +C_ASSERT( sizeof(FriendSessionStateInfo_t) >= 8 ); +C_ASSERT( offsetof(FriendSessionStateInfo_t, m_uiOnlineSessionInstances) == 0 ); +C_ASSERT( sizeof(FriendSessionStateInfo_t().m_uiOnlineSessionInstances) >= 4 ); +C_ASSERT( offsetof(FriendSessionStateInfo_t, m_uiPublishedToFriendsSessionInstance) == 4 ); +C_ASSERT( sizeof(FriendSessionStateInfo_t().m_uiPublishedToFriendsSessionInstance) >= 1 ); + +C_ASSERT( sizeof(FriendsEnumerateFollowingList_t) >= 412 ); +C_ASSERT( offsetof(FriendsEnumerateFollowingList_t, m_eResult) == 0 ); +C_ASSERT( sizeof(FriendsEnumerateFollowingList_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(FriendsEnumerateFollowingList_t, m_rgSteamID) == 4 ); +C_ASSERT( sizeof(FriendsEnumerateFollowingList_t().m_rgSteamID) >= 400 ); +C_ASSERT( offsetof(FriendsEnumerateFollowingList_t, m_nResultsReturned) == 404 ); +C_ASSERT( sizeof(FriendsEnumerateFollowingList_t().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(FriendsEnumerateFollowingList_t, m_nTotalResultCount) == 408 ); +C_ASSERT( sizeof(FriendsEnumerateFollowingList_t().m_nTotalResultCount) >= 4 ); + +C_ASSERT( sizeof(FriendsGetFollowerCount_t) >= 16 ); +C_ASSERT( offsetof(FriendsGetFollowerCount_t, m_eResult) == 0 ); +C_ASSERT( sizeof(FriendsGetFollowerCount_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(FriendsGetFollowerCount_t, m_steamID) == 4 ); +C_ASSERT( sizeof(FriendsGetFollowerCount_t().m_steamID) >= 8 ); +C_ASSERT( offsetof(FriendsGetFollowerCount_t, m_nCount) == 12 ); +C_ASSERT( sizeof(FriendsGetFollowerCount_t().m_nCount) >= 4 ); + +C_ASSERT( sizeof(FriendsIsFollowing_t) >= 16 ); +C_ASSERT( offsetof(FriendsIsFollowing_t, m_eResult) == 0 ); +C_ASSERT( sizeof(FriendsIsFollowing_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(FriendsIsFollowing_t, m_steamID) == 4 ); +C_ASSERT( sizeof(FriendsIsFollowing_t().m_steamID) >= 8 ); +C_ASSERT( offsetof(FriendsIsFollowing_t, m_bIsFollowing) == 12 ); +C_ASSERT( sizeof(FriendsIsFollowing_t().m_bIsFollowing) >= 1 ); + +C_ASSERT( sizeof(GCMessageAvailable_t) >= 4 ); +C_ASSERT( offsetof(GCMessageAvailable_t, m_nMessageSize) == 0 ); +C_ASSERT( sizeof(GCMessageAvailable_t().m_nMessageSize) >= 4 ); + +C_ASSERT( sizeof(GCMessageFailed_t) >= 1 ); + +C_ASSERT( sizeof(GSClientAchievementStatus_t) >= 144 ); +C_ASSERT( offsetof(GSClientAchievementStatus_t, m_SteamID) == 0 ); +C_ASSERT( sizeof(GSClientAchievementStatus_t().m_SteamID) >= 8 ); +C_ASSERT( offsetof(GSClientAchievementStatus_t, m_pchAchievement) == 8 ); +C_ASSERT( sizeof(GSClientAchievementStatus_t().m_pchAchievement) >= 128 ); +C_ASSERT( offsetof(GSClientAchievementStatus_t, m_bUnlocked) == 136 ); +C_ASSERT( sizeof(GSClientAchievementStatus_t().m_bUnlocked) >= 1 ); + +C_ASSERT( sizeof(GSClientApprove_t_126) >= 16 ); +C_ASSERT( offsetof(GSClientApprove_t_126, m_SteamID) == 0 ); +C_ASSERT( sizeof(GSClientApprove_t_126().m_SteamID) >= 8 ); +C_ASSERT( offsetof(GSClientApprove_t_126, m_OwnerSteamID) == 8 ); +C_ASSERT( sizeof(GSClientApprove_t_126().m_OwnerSteamID) >= 8 ); + +C_ASSERT( sizeof(GSClientApprove_t_099u) >= 8 ); +C_ASSERT( offsetof(GSClientApprove_t_099u, m_SteamID) == 0 ); +C_ASSERT( sizeof(GSClientApprove_t_099u().m_SteamID) >= 8 ); + +C_ASSERT( sizeof(GSClientDeny_t) >= 140 ); +C_ASSERT( offsetof(GSClientDeny_t, m_SteamID) == 0 ); +C_ASSERT( sizeof(GSClientDeny_t().m_SteamID) >= 8 ); +C_ASSERT( offsetof(GSClientDeny_t, m_eDenyReason) == 8 ); +C_ASSERT( sizeof(GSClientDeny_t().m_eDenyReason) >= 4 ); +C_ASSERT( offsetof(GSClientDeny_t, m_rgchOptionalText) == 12 ); +C_ASSERT( sizeof(GSClientDeny_t().m_rgchOptionalText) >= 128 ); + +C_ASSERT( sizeof(GSClientGroupStatus_t) >= 18 ); +C_ASSERT( offsetof(GSClientGroupStatus_t, m_SteamIDUser) == 0 ); +C_ASSERT( sizeof(GSClientGroupStatus_t().m_SteamIDUser) >= 8 ); +C_ASSERT( offsetof(GSClientGroupStatus_t, m_SteamIDGroup) == 8 ); +C_ASSERT( sizeof(GSClientGroupStatus_t().m_SteamIDGroup) >= 8 ); +C_ASSERT( offsetof(GSClientGroupStatus_t, m_bMember) == 16 ); +C_ASSERT( sizeof(GSClientGroupStatus_t().m_bMember) >= 1 ); +C_ASSERT( offsetof(GSClientGroupStatus_t, m_bOfficer) == 17 ); +C_ASSERT( sizeof(GSClientGroupStatus_t().m_bOfficer) >= 1 ); + +C_ASSERT( sizeof(GSClientKick_t) >= 12 ); +C_ASSERT( offsetof(GSClientKick_t, m_SteamID) == 0 ); +C_ASSERT( sizeof(GSClientKick_t().m_SteamID) >= 8 ); +C_ASSERT( offsetof(GSClientKick_t, m_eDenyReason) == 8 ); +C_ASSERT( sizeof(GSClientKick_t().m_eDenyReason) >= 4 ); + +C_ASSERT( sizeof(GSGameplayStats_t) >= 16 ); +C_ASSERT( offsetof(GSGameplayStats_t, m_eResult) == 0 ); +C_ASSERT( sizeof(GSGameplayStats_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(GSGameplayStats_t, m_nRank) == 4 ); +C_ASSERT( sizeof(GSGameplayStats_t().m_nRank) >= 4 ); +C_ASSERT( offsetof(GSGameplayStats_t, m_unTotalConnects) == 8 ); +C_ASSERT( sizeof(GSGameplayStats_t().m_unTotalConnects) >= 4 ); +C_ASSERT( offsetof(GSGameplayStats_t, m_unTotalMinutesPlayed) == 12 ); +C_ASSERT( sizeof(GSGameplayStats_t().m_unTotalMinutesPlayed) >= 4 ); + +C_ASSERT( sizeof(GSPolicyResponse_t) >= 1 ); +C_ASSERT( offsetof(GSPolicyResponse_t, m_bSecure) == 0 ); +C_ASSERT( sizeof(GSPolicyResponse_t().m_bSecure) >= 1 ); + +C_ASSERT( sizeof(GSStatsReceived_t) >= 12 ); +C_ASSERT( offsetof(GSStatsReceived_t, m_eResult) == 0 ); +C_ASSERT( sizeof(GSStatsReceived_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(GSStatsReceived_t, m_steamIDUser) == 4 ); +C_ASSERT( sizeof(GSStatsReceived_t().m_steamIDUser) >= 8 ); + +C_ASSERT( sizeof(GSStatsStored_t) >= 12 ); +C_ASSERT( offsetof(GSStatsStored_t, m_eResult) == 0 ); +C_ASSERT( sizeof(GSStatsStored_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(GSStatsStored_t, m_steamIDUser) == 4 ); +C_ASSERT( sizeof(GSStatsStored_t().m_steamIDUser) >= 8 ); + +C_ASSERT( sizeof(GSStatsUnloaded_t) >= 8 ); +C_ASSERT( offsetof(GSStatsUnloaded_t, m_steamIDUser) == 0 ); +C_ASSERT( sizeof(GSStatsUnloaded_t().m_steamIDUser) >= 8 ); + +C_ASSERT( sizeof(GameConnectedChatJoin_t) >= 16 ); +C_ASSERT( offsetof(GameConnectedChatJoin_t, m_steamIDClanChat) == 0 ); +C_ASSERT( sizeof(GameConnectedChatJoin_t().m_steamIDClanChat) >= 8 ); +C_ASSERT( offsetof(GameConnectedChatJoin_t, m_steamIDUser) == 8 ); +C_ASSERT( sizeof(GameConnectedChatJoin_t().m_steamIDUser) >= 8 ); + +C_ASSERT( sizeof(GameConnectedChatLeave_t) >= 18 ); +C_ASSERT( offsetof(GameConnectedChatLeave_t, m_steamIDClanChat) == 0 ); +C_ASSERT( sizeof(GameConnectedChatLeave_t().m_steamIDClanChat) >= 8 ); +C_ASSERT( offsetof(GameConnectedChatLeave_t, m_steamIDUser) == 8 ); +C_ASSERT( sizeof(GameConnectedChatLeave_t().m_steamIDUser) >= 8 ); +C_ASSERT( offsetof(GameConnectedChatLeave_t, m_bKicked) == 16 ); +C_ASSERT( sizeof(GameConnectedChatLeave_t().m_bKicked) >= 1 ); +C_ASSERT( offsetof(GameConnectedChatLeave_t, m_bDropped) == 17 ); +C_ASSERT( sizeof(GameConnectedChatLeave_t().m_bDropped) >= 1 ); + +C_ASSERT( sizeof(GameConnectedClanChatMsg_t) >= 20 ); +C_ASSERT( offsetof(GameConnectedClanChatMsg_t, m_steamIDClanChat) == 0 ); +C_ASSERT( sizeof(GameConnectedClanChatMsg_t().m_steamIDClanChat) >= 8 ); +C_ASSERT( offsetof(GameConnectedClanChatMsg_t, m_steamIDUser) == 8 ); +C_ASSERT( sizeof(GameConnectedClanChatMsg_t().m_steamIDUser) >= 8 ); +C_ASSERT( offsetof(GameConnectedClanChatMsg_t, m_iMessageID) == 16 ); +C_ASSERT( sizeof(GameConnectedClanChatMsg_t().m_iMessageID) >= 4 ); + +C_ASSERT( sizeof(GameConnectedFriendChatMsg_t) >= 12 ); +C_ASSERT( offsetof(GameConnectedFriendChatMsg_t, m_steamIDUser) == 0 ); +C_ASSERT( sizeof(GameConnectedFriendChatMsg_t().m_steamIDUser) >= 8 ); +C_ASSERT( offsetof(GameConnectedFriendChatMsg_t, m_iMessageID) == 8 ); +C_ASSERT( sizeof(GameConnectedFriendChatMsg_t().m_iMessageID) >= 4 ); + +C_ASSERT( sizeof(GameLobbyJoinRequested_t) >= 16 ); +C_ASSERT( offsetof(GameLobbyJoinRequested_t, m_steamIDLobby) == 0 ); +C_ASSERT( sizeof(GameLobbyJoinRequested_t().m_steamIDLobby) >= 8 ); +C_ASSERT( offsetof(GameLobbyJoinRequested_t, m_steamIDFriend) == 8 ); +C_ASSERT( sizeof(GameLobbyJoinRequested_t().m_steamIDFriend) >= 8 ); + +C_ASSERT( sizeof(GameOverlayActivated_t_158) >= 12 ); +C_ASSERT( offsetof(GameOverlayActivated_t_158, m_bActive) == 0 ); +C_ASSERT( sizeof(GameOverlayActivated_t_158().m_bActive) >= 1 ); +C_ASSERT( offsetof(GameOverlayActivated_t_158, m_bUserInitiated) == 1 ); +C_ASSERT( sizeof(GameOverlayActivated_t_158().m_bUserInitiated) >= 1 ); +C_ASSERT( offsetof(GameOverlayActivated_t_158, m_nAppID) == 4 ); +C_ASSERT( sizeof(GameOverlayActivated_t_158().m_nAppID) >= 4 ); +C_ASSERT( offsetof(GameOverlayActivated_t_158, m_dwOverlayPID) == 8 ); +C_ASSERT( sizeof(GameOverlayActivated_t_158().m_dwOverlayPID) >= 4 ); + +C_ASSERT( sizeof(GameOverlayActivated_t_156) >= 8 ); +C_ASSERT( offsetof(GameOverlayActivated_t_156, m_bActive) == 0 ); +C_ASSERT( sizeof(GameOverlayActivated_t_156().m_bActive) >= 1 ); +C_ASSERT( offsetof(GameOverlayActivated_t_156, m_bUserInitiated) == 1 ); +C_ASSERT( sizeof(GameOverlayActivated_t_156().m_bUserInitiated) >= 1 ); +C_ASSERT( offsetof(GameOverlayActivated_t_156, m_nAppID) == 4 ); +C_ASSERT( sizeof(GameOverlayActivated_t_156().m_nAppID) >= 4 ); + +C_ASSERT( sizeof(GameOverlayActivated_t_099u) >= 1 ); +C_ASSERT( offsetof(GameOverlayActivated_t_099u, m_bActive) == 0 ); +C_ASSERT( sizeof(GameOverlayActivated_t_099u().m_bActive) >= 1 ); + +C_ASSERT( sizeof(GameRichPresenceJoinRequested_t) >= 264 ); +C_ASSERT( offsetof(GameRichPresenceJoinRequested_t, m_steamIDFriend) == 0 ); +C_ASSERT( sizeof(GameRichPresenceJoinRequested_t().m_steamIDFriend) >= 8 ); +C_ASSERT( offsetof(GameRichPresenceJoinRequested_t, m_rgchConnect) == 8 ); +C_ASSERT( sizeof(GameRichPresenceJoinRequested_t().m_rgchConnect) >= 256 ); + +C_ASSERT( sizeof(GameServerChangeRequested_t) >= 128 ); +C_ASSERT( offsetof(GameServerChangeRequested_t, m_rgchServer) == 0 ); +C_ASSERT( sizeof(GameServerChangeRequested_t().m_rgchServer) >= 64 ); +C_ASSERT( offsetof(GameServerChangeRequested_t, m_rgchPassword) == 64 ); +C_ASSERT( sizeof(GameServerChangeRequested_t().m_rgchPassword) >= 64 ); + +C_ASSERT( sizeof(GameStatsSessionClosed_t) >= 16 ); +C_ASSERT( offsetof(GameStatsSessionClosed_t, m_ulSessionID) == 0 ); +C_ASSERT( sizeof(GameStatsSessionClosed_t().m_ulSessionID) >= 8 ); +C_ASSERT( offsetof(GameStatsSessionClosed_t, m_eResult) == 8 ); +C_ASSERT( sizeof(GameStatsSessionClosed_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(GameStatsSessionIssued_t) >= 16 ); +C_ASSERT( offsetof(GameStatsSessionIssued_t, m_ulSessionID) == 0 ); +C_ASSERT( sizeof(GameStatsSessionIssued_t().m_ulSessionID) >= 8 ); +C_ASSERT( offsetof(GameStatsSessionIssued_t, m_eResult) == 8 ); +C_ASSERT( sizeof(GameStatsSessionIssued_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(GameStatsSessionIssued_t, m_bCollectingAny) == 12 ); +C_ASSERT( sizeof(GameStatsSessionIssued_t().m_bCollectingAny) >= 1 ); +C_ASSERT( offsetof(GameStatsSessionIssued_t, m_bCollectingDetails) == 13 ); +C_ASSERT( sizeof(GameStatsSessionIssued_t().m_bCollectingDetails) >= 1 ); + +C_ASSERT( sizeof(GameWebCallback_t) >= 256 ); +C_ASSERT( offsetof(GameWebCallback_t, m_szURL) == 0 ); +C_ASSERT( sizeof(GameWebCallback_t().m_szURL) >= 256 ); + +C_ASSERT( sizeof(GamepadTextInputDismissed_t_156) >= 12 ); +C_ASSERT( offsetof(GamepadTextInputDismissed_t_156, m_bSubmitted) == 0 ); +C_ASSERT( sizeof(GamepadTextInputDismissed_t_156().m_bSubmitted) >= 1 ); +C_ASSERT( offsetof(GamepadTextInputDismissed_t_156, m_unSubmittedText) == 4 ); +C_ASSERT( sizeof(GamepadTextInputDismissed_t_156().m_unSubmittedText) >= 4 ); +C_ASSERT( offsetof(GamepadTextInputDismissed_t_156, m_unAppID) == 8 ); +C_ASSERT( sizeof(GamepadTextInputDismissed_t_156().m_unAppID) >= 4 ); + +C_ASSERT( sizeof(GamepadTextInputDismissed_t_121) >= 8 ); +C_ASSERT( offsetof(GamepadTextInputDismissed_t_121, m_bSubmitted) == 0 ); +C_ASSERT( sizeof(GamepadTextInputDismissed_t_121().m_bSubmitted) >= 1 ); +C_ASSERT( offsetof(GamepadTextInputDismissed_t_121, m_unSubmittedText) == 4 ); +C_ASSERT( sizeof(GamepadTextInputDismissed_t_121().m_unSubmittedText) >= 4 ); + +C_ASSERT( sizeof(GetAuthSessionTicketResponse_t) >= 8 ); +C_ASSERT( offsetof(GetAuthSessionTicketResponse_t, m_hAuthTicket) == 0 ); +C_ASSERT( sizeof(GetAuthSessionTicketResponse_t().m_hAuthTicket) >= 4 ); +C_ASSERT( offsetof(GetAuthSessionTicketResponse_t, m_eResult) == 4 ); +C_ASSERT( sizeof(GetAuthSessionTicketResponse_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(GetOPFSettingsResult_t) >= 8 ); +C_ASSERT( offsetof(GetOPFSettingsResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(GetOPFSettingsResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(GetOPFSettingsResult_t, m_unVideoAppID) == 4 ); +C_ASSERT( sizeof(GetOPFSettingsResult_t().m_unVideoAppID) >= 4 ); + +C_ASSERT( sizeof(GetTicketForWebApiResponse_t) >= 2572 ); +C_ASSERT( offsetof(GetTicketForWebApiResponse_t, m_hAuthTicket) == 0 ); +C_ASSERT( sizeof(GetTicketForWebApiResponse_t().m_hAuthTicket) >= 4 ); +C_ASSERT( offsetof(GetTicketForWebApiResponse_t, m_eResult) == 4 ); +C_ASSERT( sizeof(GetTicketForWebApiResponse_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(GetTicketForWebApiResponse_t, m_cubTicket) == 8 ); +C_ASSERT( sizeof(GetTicketForWebApiResponse_t().m_cubTicket) >= 4 ); +C_ASSERT( offsetof(GetTicketForWebApiResponse_t, m_rgubTicket) == 12 ); +C_ASSERT( sizeof(GetTicketForWebApiResponse_t().m_rgubTicket) >= 2560 ); + +C_ASSERT( sizeof(GetUserItemVoteResult_t) >= 16 ); +C_ASSERT( offsetof(GetUserItemVoteResult_t, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(GetUserItemVoteResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(GetUserItemVoteResult_t, m_eResult) == 8 ); +C_ASSERT( sizeof(GetUserItemVoteResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(GetUserItemVoteResult_t, m_bVotedUp) == 12 ); +C_ASSERT( sizeof(GetUserItemVoteResult_t().m_bVotedUp) >= 1 ); +C_ASSERT( offsetof(GetUserItemVoteResult_t, m_bVotedDown) == 13 ); +C_ASSERT( sizeof(GetUserItemVoteResult_t().m_bVotedDown) >= 1 ); +C_ASSERT( offsetof(GetUserItemVoteResult_t, m_bVoteSkipped) == 14 ); +C_ASSERT( sizeof(GetUserItemVoteResult_t().m_bVoteSkipped) >= 1 ); + +C_ASSERT( sizeof(GetVideoURLResult_t) >= 264 ); +C_ASSERT( offsetof(GetVideoURLResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(GetVideoURLResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(GetVideoURLResult_t, m_unVideoAppID) == 4 ); +C_ASSERT( sizeof(GetVideoURLResult_t().m_unVideoAppID) >= 4 ); +C_ASSERT( offsetof(GetVideoURLResult_t, m_rgchURL) == 8 ); +C_ASSERT( sizeof(GetVideoURLResult_t().m_rgchURL) >= 256 ); + +C_ASSERT( sizeof(GlobalAchievementPercentagesReady_t) >= 16 ); +C_ASSERT( offsetof(GlobalAchievementPercentagesReady_t, m_nGameID) == 0 ); +C_ASSERT( sizeof(GlobalAchievementPercentagesReady_t().m_nGameID) >= 8 ); +C_ASSERT( offsetof(GlobalAchievementPercentagesReady_t, m_eResult) == 8 ); +C_ASSERT( sizeof(GlobalAchievementPercentagesReady_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(GlobalStatsReceived_t) >= 16 ); +C_ASSERT( offsetof(GlobalStatsReceived_t, m_nGameID) == 0 ); +C_ASSERT( sizeof(GlobalStatsReceived_t().m_nGameID) >= 8 ); +C_ASSERT( offsetof(GlobalStatsReceived_t, m_eResult) == 8 ); +C_ASSERT( sizeof(GlobalStatsReceived_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(HTML_BrowserReady_t) >= 4 ); +C_ASSERT( offsetof(HTML_BrowserReady_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(HTML_BrowserReady_t().unBrowserHandle) >= 4 ); + +C_ASSERT( sizeof(HTML_BrowserRestarted_t) >= 8 ); +C_ASSERT( offsetof(HTML_BrowserRestarted_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(HTML_BrowserRestarted_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(HTML_BrowserRestarted_t, unOldBrowserHandle) == 4 ); +C_ASSERT( sizeof(HTML_BrowserRestarted_t().unOldBrowserHandle) >= 4 ); + +C_ASSERT( sizeof(HTML_CanGoBackAndForward_t) >= 8 ); +C_ASSERT( offsetof(HTML_CanGoBackAndForward_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(HTML_CanGoBackAndForward_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(HTML_CanGoBackAndForward_t, bCanGoBack) == 4 ); +C_ASSERT( sizeof(HTML_CanGoBackAndForward_t().bCanGoBack) >= 1 ); +C_ASSERT( offsetof(HTML_CanGoBackAndForward_t, bCanGoForward) == 5 ); +C_ASSERT( sizeof(HTML_CanGoBackAndForward_t().bCanGoForward) >= 1 ); + +C_ASSERT( sizeof(HTML_CloseBrowser_t) >= 4 ); +C_ASSERT( offsetof(HTML_CloseBrowser_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(HTML_CloseBrowser_t().unBrowserHandle) >= 4 ); + +C_ASSERT( sizeof(HTML_HidePopup_t) >= 4 ); +C_ASSERT( offsetof(HTML_HidePopup_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(HTML_HidePopup_t().unBrowserHandle) >= 4 ); + +C_ASSERT( sizeof(HTML_HideToolTip_t) >= 4 ); +C_ASSERT( offsetof(HTML_HideToolTip_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(HTML_HideToolTip_t().unBrowserHandle) >= 4 ); + +C_ASSERT( sizeof(HTML_HorizontalScroll_t) >= 24 ); +C_ASSERT( offsetof(HTML_HorizontalScroll_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(HTML_HorizontalScroll_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(HTML_HorizontalScroll_t, unScrollMax) == 4 ); +C_ASSERT( sizeof(HTML_HorizontalScroll_t().unScrollMax) >= 4 ); +C_ASSERT( offsetof(HTML_HorizontalScroll_t, unScrollCurrent) == 8 ); +C_ASSERT( sizeof(HTML_HorizontalScroll_t().unScrollCurrent) >= 4 ); +C_ASSERT( offsetof(HTML_HorizontalScroll_t, flPageScale) == 12 ); +C_ASSERT( sizeof(HTML_HorizontalScroll_t().flPageScale) >= 4 ); +C_ASSERT( offsetof(HTML_HorizontalScroll_t, bVisible) == 16 ); +C_ASSERT( sizeof(HTML_HorizontalScroll_t().bVisible) >= 1 ); +C_ASSERT( offsetof(HTML_HorizontalScroll_t, unPageSize) == 20 ); +C_ASSERT( sizeof(HTML_HorizontalScroll_t().unPageSize) >= 4 ); + +C_ASSERT( sizeof(HTML_SearchResults_t) >= 12 ); +C_ASSERT( offsetof(HTML_SearchResults_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(HTML_SearchResults_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(HTML_SearchResults_t, unResults) == 4 ); +C_ASSERT( sizeof(HTML_SearchResults_t().unResults) >= 4 ); +C_ASSERT( offsetof(HTML_SearchResults_t, unCurrentMatch) == 8 ); +C_ASSERT( sizeof(HTML_SearchResults_t().unCurrentMatch) >= 4 ); + +C_ASSERT( sizeof(HTML_SetCursor_t) >= 8 ); +C_ASSERT( offsetof(HTML_SetCursor_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(HTML_SetCursor_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(HTML_SetCursor_t, eMouseCursor) == 4 ); +C_ASSERT( sizeof(HTML_SetCursor_t().eMouseCursor) >= 4 ); + +C_ASSERT( sizeof(HTML_ShowPopup_t) >= 4 ); +C_ASSERT( offsetof(HTML_ShowPopup_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(HTML_ShowPopup_t().unBrowserHandle) >= 4 ); + +C_ASSERT( sizeof(HTML_SizePopup_t) >= 20 ); +C_ASSERT( offsetof(HTML_SizePopup_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(HTML_SizePopup_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(HTML_SizePopup_t, unX) == 4 ); +C_ASSERT( sizeof(HTML_SizePopup_t().unX) >= 4 ); +C_ASSERT( offsetof(HTML_SizePopup_t, unY) == 8 ); +C_ASSERT( sizeof(HTML_SizePopup_t().unY) >= 4 ); +C_ASSERT( offsetof(HTML_SizePopup_t, unWide) == 12 ); +C_ASSERT( sizeof(HTML_SizePopup_t().unWide) >= 4 ); +C_ASSERT( offsetof(HTML_SizePopup_t, unTall) == 16 ); +C_ASSERT( sizeof(HTML_SizePopup_t().unTall) >= 4 ); + +C_ASSERT( sizeof(HTML_VerticalScroll_t) >= 24 ); +C_ASSERT( offsetof(HTML_VerticalScroll_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(HTML_VerticalScroll_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(HTML_VerticalScroll_t, unScrollMax) == 4 ); +C_ASSERT( sizeof(HTML_VerticalScroll_t().unScrollMax) >= 4 ); +C_ASSERT( offsetof(HTML_VerticalScroll_t, unScrollCurrent) == 8 ); +C_ASSERT( sizeof(HTML_VerticalScroll_t().unScrollCurrent) >= 4 ); +C_ASSERT( offsetof(HTML_VerticalScroll_t, flPageScale) == 12 ); +C_ASSERT( sizeof(HTML_VerticalScroll_t().flPageScale) >= 4 ); +C_ASSERT( offsetof(HTML_VerticalScroll_t, bVisible) == 16 ); +C_ASSERT( sizeof(HTML_VerticalScroll_t().bVisible) >= 1 ); +C_ASSERT( offsetof(HTML_VerticalScroll_t, unPageSize) == 20 ); +C_ASSERT( sizeof(HTML_VerticalScroll_t().unPageSize) >= 4 ); + +C_ASSERT( sizeof(IPCFailure_t) >= 1 ); +C_ASSERT( offsetof(IPCFailure_t, m_eFailureType) == 0 ); +C_ASSERT( sizeof(IPCFailure_t().m_eFailureType) >= 1 ); + +C_ASSERT( sizeof(IPCountry_t) >= 1 ); + +C_ASSERT( sizeof(InputAnalogActionData_t) >= 13 ); +C_ASSERT( offsetof(InputAnalogActionData_t, eMode) == 0 ); +C_ASSERT( sizeof(InputAnalogActionData_t().eMode) >= 4 ); +C_ASSERT( offsetof(InputAnalogActionData_t, x) == 4 ); +C_ASSERT( sizeof(InputAnalogActionData_t().x) >= 4 ); +C_ASSERT( offsetof(InputAnalogActionData_t, y) == 8 ); +C_ASSERT( sizeof(InputAnalogActionData_t().y) >= 4 ); +C_ASSERT( offsetof(InputAnalogActionData_t, bActive) == 12 ); +C_ASSERT( sizeof(InputAnalogActionData_t().bActive) >= 1 ); + +C_ASSERT( sizeof(InputDigitalActionData_t) >= 2 ); +C_ASSERT( offsetof(InputDigitalActionData_t, bState) == 0 ); +C_ASSERT( sizeof(InputDigitalActionData_t().bState) >= 1 ); +C_ASSERT( offsetof(InputDigitalActionData_t, bActive) == 1 ); +C_ASSERT( sizeof(InputDigitalActionData_t().bActive) >= 1 ); + +C_ASSERT( sizeof(InputMotionDataV2_t) >= 72 ); +C_ASSERT( offsetof(InputMotionDataV2_t, driftCorrectedQuatX) == 0 ); +C_ASSERT( sizeof(InputMotionDataV2_t().driftCorrectedQuatX) >= 4 ); +C_ASSERT( offsetof(InputMotionDataV2_t, driftCorrectedQuatY) == 4 ); +C_ASSERT( sizeof(InputMotionDataV2_t().driftCorrectedQuatY) >= 4 ); +C_ASSERT( offsetof(InputMotionDataV2_t, driftCorrectedQuatZ) == 8 ); +C_ASSERT( sizeof(InputMotionDataV2_t().driftCorrectedQuatZ) >= 4 ); +C_ASSERT( offsetof(InputMotionDataV2_t, driftCorrectedQuatW) == 12 ); +C_ASSERT( sizeof(InputMotionDataV2_t().driftCorrectedQuatW) >= 4 ); +C_ASSERT( offsetof(InputMotionDataV2_t, sensorFusionQuatX) == 16 ); +C_ASSERT( sizeof(InputMotionDataV2_t().sensorFusionQuatX) >= 4 ); +C_ASSERT( offsetof(InputMotionDataV2_t, sensorFusionQuatY) == 20 ); +C_ASSERT( sizeof(InputMotionDataV2_t().sensorFusionQuatY) >= 4 ); +C_ASSERT( offsetof(InputMotionDataV2_t, sensorFusionQuatZ) == 24 ); +C_ASSERT( sizeof(InputMotionDataV2_t().sensorFusionQuatZ) >= 4 ); +C_ASSERT( offsetof(InputMotionDataV2_t, sensorFusionQuatW) == 28 ); +C_ASSERT( sizeof(InputMotionDataV2_t().sensorFusionQuatW) >= 4 ); +C_ASSERT( offsetof(InputMotionDataV2_t, deferredSensorFusionQuatX) == 32 ); +C_ASSERT( sizeof(InputMotionDataV2_t().deferredSensorFusionQuatX) >= 4 ); +C_ASSERT( offsetof(InputMotionDataV2_t, deferredSensorFusionQuatY) == 36 ); +C_ASSERT( sizeof(InputMotionDataV2_t().deferredSensorFusionQuatY) >= 4 ); +C_ASSERT( offsetof(InputMotionDataV2_t, deferredSensorFusionQuatZ) == 40 ); +C_ASSERT( sizeof(InputMotionDataV2_t().deferredSensorFusionQuatZ) >= 4 ); +C_ASSERT( offsetof(InputMotionDataV2_t, deferredSensorFusionQuatW) == 44 ); +C_ASSERT( sizeof(InputMotionDataV2_t().deferredSensorFusionQuatW) >= 4 ); +C_ASSERT( offsetof(InputMotionDataV2_t, gravityX) == 48 ); +C_ASSERT( sizeof(InputMotionDataV2_t().gravityX) >= 4 ); +C_ASSERT( offsetof(InputMotionDataV2_t, gravityY) == 52 ); +C_ASSERT( sizeof(InputMotionDataV2_t().gravityY) >= 4 ); +C_ASSERT( offsetof(InputMotionDataV2_t, gravityZ) == 56 ); +C_ASSERT( sizeof(InputMotionDataV2_t().gravityZ) >= 4 ); +C_ASSERT( offsetof(InputMotionDataV2_t, degreesPerSecondX) == 60 ); +C_ASSERT( sizeof(InputMotionDataV2_t().degreesPerSecondX) >= 4 ); +C_ASSERT( offsetof(InputMotionDataV2_t, degreesPerSecondY) == 64 ); +C_ASSERT( sizeof(InputMotionDataV2_t().degreesPerSecondY) >= 4 ); +C_ASSERT( offsetof(InputMotionDataV2_t, degreesPerSecondZ) == 68 ); +C_ASSERT( sizeof(InputMotionDataV2_t().degreesPerSecondZ) >= 4 ); + +C_ASSERT( sizeof(InputMotionData_t) >= 40 ); +C_ASSERT( offsetof(InputMotionData_t, rotQuatX) == 0 ); +C_ASSERT( sizeof(InputMotionData_t().rotQuatX) >= 4 ); +C_ASSERT( offsetof(InputMotionData_t, rotQuatY) == 4 ); +C_ASSERT( sizeof(InputMotionData_t().rotQuatY) >= 4 ); +C_ASSERT( offsetof(InputMotionData_t, rotQuatZ) == 8 ); +C_ASSERT( sizeof(InputMotionData_t().rotQuatZ) >= 4 ); +C_ASSERT( offsetof(InputMotionData_t, rotQuatW) == 12 ); +C_ASSERT( sizeof(InputMotionData_t().rotQuatW) >= 4 ); +C_ASSERT( offsetof(InputMotionData_t, posAccelX) == 16 ); +C_ASSERT( sizeof(InputMotionData_t().posAccelX) >= 4 ); +C_ASSERT( offsetof(InputMotionData_t, posAccelY) == 20 ); +C_ASSERT( sizeof(InputMotionData_t().posAccelY) >= 4 ); +C_ASSERT( offsetof(InputMotionData_t, posAccelZ) == 24 ); +C_ASSERT( sizeof(InputMotionData_t().posAccelZ) >= 4 ); +C_ASSERT( offsetof(InputMotionData_t, rotVelX) == 28 ); +C_ASSERT( sizeof(InputMotionData_t().rotVelX) >= 4 ); +C_ASSERT( offsetof(InputMotionData_t, rotVelY) == 32 ); +C_ASSERT( sizeof(InputMotionData_t().rotVelY) >= 4 ); +C_ASSERT( offsetof(InputMotionData_t, rotVelZ) == 36 ); +C_ASSERT( sizeof(InputMotionData_t().rotVelZ) >= 4 ); + +C_ASSERT( sizeof(JoinClanChatRoomCompletionResult_t) >= 12 ); +C_ASSERT( offsetof(JoinClanChatRoomCompletionResult_t, m_steamIDClanChat) == 0 ); +C_ASSERT( sizeof(JoinClanChatRoomCompletionResult_t().m_steamIDClanChat) >= 8 ); +C_ASSERT( offsetof(JoinClanChatRoomCompletionResult_t, m_eChatRoomEnterResponse) == 8 ); +C_ASSERT( sizeof(JoinClanChatRoomCompletionResult_t().m_eChatRoomEnterResponse) >= 4 ); + +C_ASSERT( sizeof(LeaderboardFindResult_t) >= 16 ); +C_ASSERT( offsetof(LeaderboardFindResult_t, m_hSteamLeaderboard) == 0 ); +C_ASSERT( sizeof(LeaderboardFindResult_t().m_hSteamLeaderboard) >= 8 ); +C_ASSERT( offsetof(LeaderboardFindResult_t, m_bLeaderboardFound) == 8 ); +C_ASSERT( sizeof(LeaderboardFindResult_t().m_bLeaderboardFound) >= 1 ); + +C_ASSERT( sizeof(LeaderboardScoresDownloaded_t) >= 24 ); +C_ASSERT( offsetof(LeaderboardScoresDownloaded_t, m_hSteamLeaderboard) == 0 ); +C_ASSERT( sizeof(LeaderboardScoresDownloaded_t().m_hSteamLeaderboard) >= 8 ); +C_ASSERT( offsetof(LeaderboardScoresDownloaded_t, m_hSteamLeaderboardEntries) == 8 ); +C_ASSERT( sizeof(LeaderboardScoresDownloaded_t().m_hSteamLeaderboardEntries) >= 8 ); +C_ASSERT( offsetof(LeaderboardScoresDownloaded_t, m_cEntryCount) == 16 ); +C_ASSERT( sizeof(LeaderboardScoresDownloaded_t().m_cEntryCount) >= 4 ); + +C_ASSERT( sizeof(LicensesUpdated_t) >= 1 ); + +C_ASSERT( sizeof(LobbyChatMsg_t) >= 24 ); +C_ASSERT( offsetof(LobbyChatMsg_t, m_ulSteamIDLobby) == 0 ); +C_ASSERT( sizeof(LobbyChatMsg_t().m_ulSteamIDLobby) >= 8 ); +C_ASSERT( offsetof(LobbyChatMsg_t, m_ulSteamIDUser) == 8 ); +C_ASSERT( sizeof(LobbyChatMsg_t().m_ulSteamIDUser) >= 8 ); +C_ASSERT( offsetof(LobbyChatMsg_t, m_eChatEntryType) == 16 ); +C_ASSERT( sizeof(LobbyChatMsg_t().m_eChatEntryType) >= 1 ); +C_ASSERT( offsetof(LobbyChatMsg_t, m_iChatID) == 20 ); +C_ASSERT( sizeof(LobbyChatMsg_t().m_iChatID) >= 4 ); + +C_ASSERT( sizeof(LobbyChatUpdate_t) >= 32 ); +C_ASSERT( offsetof(LobbyChatUpdate_t, m_ulSteamIDLobby) == 0 ); +C_ASSERT( sizeof(LobbyChatUpdate_t().m_ulSteamIDLobby) >= 8 ); +C_ASSERT( offsetof(LobbyChatUpdate_t, m_ulSteamIDUserChanged) == 8 ); +C_ASSERT( sizeof(LobbyChatUpdate_t().m_ulSteamIDUserChanged) >= 8 ); +C_ASSERT( offsetof(LobbyChatUpdate_t, m_ulSteamIDMakingChange) == 16 ); +C_ASSERT( sizeof(LobbyChatUpdate_t().m_ulSteamIDMakingChange) >= 8 ); +C_ASSERT( offsetof(LobbyChatUpdate_t, m_rgfChatMemberStateChange) == 24 ); +C_ASSERT( sizeof(LobbyChatUpdate_t().m_rgfChatMemberStateChange) >= 4 ); + +C_ASSERT( sizeof(LobbyClosing_t) >= 8 ); +C_ASSERT( offsetof(LobbyClosing_t, m_ulSteamIDLobby) == 0 ); +C_ASSERT( sizeof(LobbyClosing_t().m_ulSteamIDLobby) >= 8 ); + +C_ASSERT( sizeof(LobbyDataUpdate_t_111x) >= 24 ); +C_ASSERT( offsetof(LobbyDataUpdate_t_111x, m_ulSteamIDLobby) == 0 ); +C_ASSERT( sizeof(LobbyDataUpdate_t_111x().m_ulSteamIDLobby) >= 8 ); +C_ASSERT( offsetof(LobbyDataUpdate_t_111x, m_ulSteamIDMember) == 8 ); +C_ASSERT( sizeof(LobbyDataUpdate_t_111x().m_ulSteamIDMember) >= 8 ); +C_ASSERT( offsetof(LobbyDataUpdate_t_111x, m_bSuccess) == 16 ); +C_ASSERT( sizeof(LobbyDataUpdate_t_111x().m_bSuccess) >= 1 ); + +C_ASSERT( sizeof(LobbyDataUpdate_t_099u) >= 16 ); +C_ASSERT( offsetof(LobbyDataUpdate_t_099u, m_ulSteamIDLobby) == 0 ); +C_ASSERT( sizeof(LobbyDataUpdate_t_099u().m_ulSteamIDLobby) >= 8 ); +C_ASSERT( offsetof(LobbyDataUpdate_t_099u, m_ulSteamIDMember) == 8 ); +C_ASSERT( sizeof(LobbyDataUpdate_t_099u().m_ulSteamIDMember) >= 8 ); + +C_ASSERT( sizeof(LobbyEnter_t) >= 24 ); +C_ASSERT( offsetof(LobbyEnter_t, m_ulSteamIDLobby) == 0 ); +C_ASSERT( sizeof(LobbyEnter_t().m_ulSteamIDLobby) >= 8 ); +C_ASSERT( offsetof(LobbyEnter_t, m_rgfChatPermissions) == 8 ); +C_ASSERT( sizeof(LobbyEnter_t().m_rgfChatPermissions) >= 4 ); +C_ASSERT( offsetof(LobbyEnter_t, m_bLocked) == 12 ); +C_ASSERT( sizeof(LobbyEnter_t().m_bLocked) >= 1 ); +C_ASSERT( offsetof(LobbyEnter_t, m_EChatRoomEnterResponse) == 16 ); +C_ASSERT( sizeof(LobbyEnter_t().m_EChatRoomEnterResponse) >= 4 ); + +C_ASSERT( sizeof(LobbyGameCreated_t) >= 24 ); +C_ASSERT( offsetof(LobbyGameCreated_t, m_ulSteamIDLobby) == 0 ); +C_ASSERT( sizeof(LobbyGameCreated_t().m_ulSteamIDLobby) >= 8 ); +C_ASSERT( offsetof(LobbyGameCreated_t, m_ulSteamIDGameServer) == 8 ); +C_ASSERT( sizeof(LobbyGameCreated_t().m_ulSteamIDGameServer) >= 8 ); +C_ASSERT( offsetof(LobbyGameCreated_t, m_unIP) == 16 ); +C_ASSERT( sizeof(LobbyGameCreated_t().m_unIP) >= 4 ); +C_ASSERT( offsetof(LobbyGameCreated_t, m_usPort) == 20 ); +C_ASSERT( sizeof(LobbyGameCreated_t().m_usPort) >= 2 ); + +C_ASSERT( sizeof(LobbyInvite_t_112x) >= 24 ); +C_ASSERT( offsetof(LobbyInvite_t_112x, m_ulSteamIDUser) == 0 ); +C_ASSERT( sizeof(LobbyInvite_t_112x().m_ulSteamIDUser) >= 8 ); +C_ASSERT( offsetof(LobbyInvite_t_112x, m_ulSteamIDLobby) == 8 ); +C_ASSERT( sizeof(LobbyInvite_t_112x().m_ulSteamIDLobby) >= 8 ); +C_ASSERT( offsetof(LobbyInvite_t_112x, m_ulGameID) == 16 ); +C_ASSERT( sizeof(LobbyInvite_t_112x().m_ulGameID) >= 8 ); + +C_ASSERT( sizeof(LobbyInvite_t_099u) >= 16 ); +C_ASSERT( offsetof(LobbyInvite_t_099u, m_ulSteamIDUser) == 0 ); +C_ASSERT( sizeof(LobbyInvite_t_099u().m_ulSteamIDUser) >= 8 ); +C_ASSERT( offsetof(LobbyInvite_t_099u, m_ulSteamIDLobby) == 8 ); +C_ASSERT( sizeof(LobbyInvite_t_099u().m_ulSteamIDLobby) >= 8 ); + +C_ASSERT( sizeof(LobbyKicked_t_106) >= 24 ); +C_ASSERT( offsetof(LobbyKicked_t_106, m_ulSteamIDLobby) == 0 ); +C_ASSERT( sizeof(LobbyKicked_t_106().m_ulSteamIDLobby) >= 8 ); +C_ASSERT( offsetof(LobbyKicked_t_106, m_ulSteamIDAdmin) == 8 ); +C_ASSERT( sizeof(LobbyKicked_t_106().m_ulSteamIDAdmin) >= 8 ); +C_ASSERT( offsetof(LobbyKicked_t_106, m_bKickedDueToDisconnect) == 16 ); +C_ASSERT( sizeof(LobbyKicked_t_106().m_bKickedDueToDisconnect) >= 1 ); + +C_ASSERT( sizeof(LobbyKicked_t_099u) >= 16 ); +C_ASSERT( offsetof(LobbyKicked_t_099u, m_ulSteamIDLobby) == 0 ); +C_ASSERT( sizeof(LobbyKicked_t_099u().m_ulSteamIDLobby) >= 8 ); +C_ASSERT( offsetof(LobbyKicked_t_099u, m_ulSteamIDAdmin) == 8 ); +C_ASSERT( sizeof(LobbyKicked_t_099u().m_ulSteamIDAdmin) >= 8 ); + +C_ASSERT( sizeof(LobbyMatchList_t) >= 4 ); +C_ASSERT( offsetof(LobbyMatchList_t, m_nLobbiesMatching) == 0 ); +C_ASSERT( sizeof(LobbyMatchList_t().m_nLobbiesMatching) >= 4 ); + +C_ASSERT( sizeof(LowBatteryPower_t) >= 1 ); +C_ASSERT( offsetof(LowBatteryPower_t, m_nMinutesBatteryLeft) == 0 ); +C_ASSERT( sizeof(LowBatteryPower_t().m_nMinutesBatteryLeft) >= 1 ); + +C_ASSERT( sizeof(MarketEligibilityResponse_t) >= 20 ); +C_ASSERT( offsetof(MarketEligibilityResponse_t, m_bAllowed) == 0 ); +C_ASSERT( sizeof(MarketEligibilityResponse_t().m_bAllowed) >= 1 ); +C_ASSERT( offsetof(MarketEligibilityResponse_t, m_eNotAllowedReason) == 4 ); +C_ASSERT( sizeof(MarketEligibilityResponse_t().m_eNotAllowedReason) >= 4 ); +C_ASSERT( offsetof(MarketEligibilityResponse_t, m_rtAllowedAtTime) == 8 ); +C_ASSERT( sizeof(MarketEligibilityResponse_t().m_rtAllowedAtTime) >= 4 ); +C_ASSERT( offsetof(MarketEligibilityResponse_t, m_cdaySteamGuardRequiredDays) == 12 ); +C_ASSERT( sizeof(MarketEligibilityResponse_t().m_cdaySteamGuardRequiredDays) >= 4 ); +C_ASSERT( offsetof(MarketEligibilityResponse_t, m_cdayNewDeviceCooldown) == 16 ); +C_ASSERT( sizeof(MarketEligibilityResponse_t().m_cdayNewDeviceCooldown) >= 4 ); + +C_ASSERT( sizeof(MatchMakingKeyValuePair_t) >= 512 ); +C_ASSERT( offsetof(MatchMakingKeyValuePair_t, m_szKey) == 0 ); +C_ASSERT( sizeof(MatchMakingKeyValuePair_t().m_szKey) >= 256 ); +C_ASSERT( offsetof(MatchMakingKeyValuePair_t, m_szValue) == 256 ); +C_ASSERT( sizeof(MatchMakingKeyValuePair_t().m_szValue) >= 256 ); + +C_ASSERT( sizeof(MusicPlayerRemoteToFront_t) >= 1 ); + +C_ASSERT( sizeof(MusicPlayerRemoteWillActivate_t) >= 1 ); + +C_ASSERT( sizeof(MusicPlayerRemoteWillDeactivate_t) >= 1 ); + +C_ASSERT( sizeof(MusicPlayerSelectsPlaylistEntry_t) >= 4 ); +C_ASSERT( offsetof(MusicPlayerSelectsPlaylistEntry_t, nID) == 0 ); +C_ASSERT( sizeof(MusicPlayerSelectsPlaylistEntry_t().nID) >= 4 ); + +C_ASSERT( sizeof(MusicPlayerSelectsQueueEntry_t) >= 4 ); +C_ASSERT( offsetof(MusicPlayerSelectsQueueEntry_t, nID) == 0 ); +C_ASSERT( sizeof(MusicPlayerSelectsQueueEntry_t().nID) >= 4 ); + +C_ASSERT( sizeof(MusicPlayerWantsLooped_t) >= 1 ); +C_ASSERT( offsetof(MusicPlayerWantsLooped_t, m_bLooped) == 0 ); +C_ASSERT( sizeof(MusicPlayerWantsLooped_t().m_bLooped) >= 1 ); + +C_ASSERT( sizeof(MusicPlayerWantsPause_t) >= 1 ); + +C_ASSERT( sizeof(MusicPlayerWantsPlayNext_t) >= 1 ); + +C_ASSERT( sizeof(MusicPlayerWantsPlayPrevious_t) >= 1 ); + +C_ASSERT( sizeof(MusicPlayerWantsPlay_t) >= 1 ); + +C_ASSERT( sizeof(MusicPlayerWantsPlayingRepeatStatus_t) >= 4 ); +C_ASSERT( offsetof(MusicPlayerWantsPlayingRepeatStatus_t, m_nPlayingRepeatStatus) == 0 ); +C_ASSERT( sizeof(MusicPlayerWantsPlayingRepeatStatus_t().m_nPlayingRepeatStatus) >= 4 ); + +C_ASSERT( sizeof(MusicPlayerWantsShuffled_t) >= 1 ); +C_ASSERT( offsetof(MusicPlayerWantsShuffled_t, m_bShuffled) == 0 ); +C_ASSERT( sizeof(MusicPlayerWantsShuffled_t().m_bShuffled) >= 1 ); + +C_ASSERT( sizeof(MusicPlayerWantsVolume_t) >= 4 ); +C_ASSERT( offsetof(MusicPlayerWantsVolume_t, m_flNewVolume) == 0 ); +C_ASSERT( sizeof(MusicPlayerWantsVolume_t().m_flNewVolume) >= 4 ); + +C_ASSERT( sizeof(MusicPlayerWillQuit_t) >= 1 ); + +C_ASSERT( sizeof(NameHistoryResponse_t) >= 8 ); +C_ASSERT( offsetof(NameHistoryResponse_t, m_cSuccessfulLookups) == 0 ); +C_ASSERT( sizeof(NameHistoryResponse_t().m_cSuccessfulLookups) >= 4 ); +C_ASSERT( offsetof(NameHistoryResponse_t, m_cFailedLookups) == 4 ); +C_ASSERT( sizeof(NameHistoryResponse_t().m_cFailedLookups) >= 4 ); + +C_ASSERT( sizeof(NewLaunchQueryParameters_t) >= 1 ); + +C_ASSERT( sizeof(NewUrlLaunchParameters_t) >= 1 ); + +C_ASSERT( sizeof(NumberOfCurrentPlayers_t) >= 8 ); +C_ASSERT( offsetof(NumberOfCurrentPlayers_t, m_bSuccess) == 0 ); +C_ASSERT( sizeof(NumberOfCurrentPlayers_t().m_bSuccess) >= 1 ); +C_ASSERT( offsetof(NumberOfCurrentPlayers_t, m_cPlayers) == 4 ); +C_ASSERT( sizeof(NumberOfCurrentPlayers_t().m_cPlayers) >= 4 ); + +C_ASSERT( sizeof(OverlayBrowserProtocolNavigation_t) >= 1024 ); +C_ASSERT( offsetof(OverlayBrowserProtocolNavigation_t, rgchURI) == 0 ); +C_ASSERT( sizeof(OverlayBrowserProtocolNavigation_t().rgchURI) >= 1024 ); + +C_ASSERT( sizeof(P2PSessionConnectFail_t) >= 9 ); +C_ASSERT( offsetof(P2PSessionConnectFail_t, m_steamIDRemote) == 0 ); +C_ASSERT( sizeof(P2PSessionConnectFail_t().m_steamIDRemote) >= 8 ); +C_ASSERT( offsetof(P2PSessionConnectFail_t, m_eP2PSessionError) == 8 ); +C_ASSERT( sizeof(P2PSessionConnectFail_t().m_eP2PSessionError) >= 1 ); + +C_ASSERT( sizeof(P2PSessionRequest_t) >= 8 ); +C_ASSERT( offsetof(P2PSessionRequest_t, m_steamIDRemote) == 0 ); +C_ASSERT( sizeof(P2PSessionRequest_t().m_steamIDRemote) >= 8 ); + +C_ASSERT( sizeof(P2PSessionState_t) >= 20 ); +C_ASSERT( offsetof(P2PSessionState_t, m_bConnectionActive) == 0 ); +C_ASSERT( sizeof(P2PSessionState_t().m_bConnectionActive) >= 1 ); +C_ASSERT( offsetof(P2PSessionState_t, m_bConnecting) == 1 ); +C_ASSERT( sizeof(P2PSessionState_t().m_bConnecting) >= 1 ); +C_ASSERT( offsetof(P2PSessionState_t, m_eP2PSessionError) == 2 ); +C_ASSERT( sizeof(P2PSessionState_t().m_eP2PSessionError) >= 1 ); +C_ASSERT( offsetof(P2PSessionState_t, m_bUsingRelay) == 3 ); +C_ASSERT( sizeof(P2PSessionState_t().m_bUsingRelay) >= 1 ); +C_ASSERT( offsetof(P2PSessionState_t, m_nBytesQueuedForSend) == 4 ); +C_ASSERT( sizeof(P2PSessionState_t().m_nBytesQueuedForSend) >= 4 ); +C_ASSERT( offsetof(P2PSessionState_t, m_nPacketsQueuedForSend) == 8 ); +C_ASSERT( sizeof(P2PSessionState_t().m_nPacketsQueuedForSend) >= 4 ); +C_ASSERT( offsetof(P2PSessionState_t, m_nRemoteIP) == 12 ); +C_ASSERT( sizeof(P2PSessionState_t().m_nRemoteIP) >= 4 ); +C_ASSERT( offsetof(P2PSessionState_t, m_nRemotePort) == 16 ); +C_ASSERT( sizeof(P2PSessionState_t().m_nRemotePort) >= 2 ); + +C_ASSERT( sizeof(PSNGameBootInviteResult_t) >= 9 ); +C_ASSERT( offsetof(PSNGameBootInviteResult_t, m_bGameBootInviteExists) == 0 ); +C_ASSERT( sizeof(PSNGameBootInviteResult_t().m_bGameBootInviteExists) >= 1 ); +C_ASSERT( offsetof(PSNGameBootInviteResult_t, m_steamIDLobby) == 1 ); +C_ASSERT( sizeof(PSNGameBootInviteResult_t().m_steamIDLobby) >= 8 ); + +C_ASSERT( sizeof(PersonaStateChange_t) >= 16 ); +C_ASSERT( offsetof(PersonaStateChange_t, m_ulSteamID) == 0 ); +C_ASSERT( sizeof(PersonaStateChange_t().m_ulSteamID) >= 8 ); +C_ASSERT( offsetof(PersonaStateChange_t, m_nChangeFlags) == 8 ); +C_ASSERT( sizeof(PersonaStateChange_t().m_nChangeFlags) >= 4 ); + +C_ASSERT( sizeof(PlaybackStatusHasChanged_t) >= 1 ); + +C_ASSERT( sizeof(RegisterActivationCodeResponse_t) >= 8 ); +C_ASSERT( offsetof(RegisterActivationCodeResponse_t, m_eResult) == 0 ); +C_ASSERT( sizeof(RegisterActivationCodeResponse_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(RegisterActivationCodeResponse_t, m_unPackageRegistered) == 4 ); +C_ASSERT( sizeof(RegisterActivationCodeResponse_t().m_unPackageRegistered) >= 4 ); + +C_ASSERT( sizeof(RemoteStorageAppSyncStatusCheck_t) >= 8 ); +C_ASSERT( offsetof(RemoteStorageAppSyncStatusCheck_t, m_nAppID) == 0 ); +C_ASSERT( sizeof(RemoteStorageAppSyncStatusCheck_t().m_nAppID) >= 4 ); +C_ASSERT( offsetof(RemoteStorageAppSyncStatusCheck_t, m_eResult) == 4 ); +C_ASSERT( sizeof(RemoteStorageAppSyncStatusCheck_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(RemoteStorageAppSyncedClient_t) >= 12 ); +C_ASSERT( offsetof(RemoteStorageAppSyncedClient_t, m_nAppID) == 0 ); +C_ASSERT( sizeof(RemoteStorageAppSyncedClient_t().m_nAppID) >= 4 ); +C_ASSERT( offsetof(RemoteStorageAppSyncedClient_t, m_eResult) == 4 ); +C_ASSERT( sizeof(RemoteStorageAppSyncedClient_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(RemoteStorageAppSyncedClient_t, m_unNumDownloads) == 8 ); +C_ASSERT( sizeof(RemoteStorageAppSyncedClient_t().m_unNumDownloads) >= 4 ); + +C_ASSERT( sizeof(RemoteStorageAppSyncedServer_t) >= 12 ); +C_ASSERT( offsetof(RemoteStorageAppSyncedServer_t, m_nAppID) == 0 ); +C_ASSERT( sizeof(RemoteStorageAppSyncedServer_t().m_nAppID) >= 4 ); +C_ASSERT( offsetof(RemoteStorageAppSyncedServer_t, m_eResult) == 4 ); +C_ASSERT( sizeof(RemoteStorageAppSyncedServer_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(RemoteStorageAppSyncedServer_t, m_unNumUploads) == 8 ); +C_ASSERT( sizeof(RemoteStorageAppSyncedServer_t().m_unNumUploads) >= 4 ); + +C_ASSERT( sizeof(RemoteStorageConflictResolution_t) >= 8 ); +C_ASSERT( offsetof(RemoteStorageConflictResolution_t, m_nAppID) == 0 ); +C_ASSERT( sizeof(RemoteStorageConflictResolution_t().m_nAppID) >= 4 ); +C_ASSERT( offsetof(RemoteStorageConflictResolution_t, m_eResult) == 4 ); +C_ASSERT( sizeof(RemoteStorageConflictResolution_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(RemoteStorageEnumeratePublishedFilesByUserActionResult_t) >= 616 ); +C_ASSERT( offsetof(RemoteStorageEnumeratePublishedFilesByUserActionResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(RemoteStorageEnumeratePublishedFilesByUserActionResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(RemoteStorageEnumeratePublishedFilesByUserActionResult_t, m_eAction) == 4 ); +C_ASSERT( sizeof(RemoteStorageEnumeratePublishedFilesByUserActionResult_t().m_eAction) >= 4 ); +C_ASSERT( offsetof(RemoteStorageEnumeratePublishedFilesByUserActionResult_t, m_nResultsReturned) == 8 ); +C_ASSERT( sizeof(RemoteStorageEnumeratePublishedFilesByUserActionResult_t().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(RemoteStorageEnumeratePublishedFilesByUserActionResult_t, m_nTotalResultCount) == 12 ); +C_ASSERT( sizeof(RemoteStorageEnumeratePublishedFilesByUserActionResult_t().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(RemoteStorageEnumeratePublishedFilesByUserActionResult_t, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(RemoteStorageEnumeratePublishedFilesByUserActionResult_t().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(RemoteStorageEnumeratePublishedFilesByUserActionResult_t, m_rgRTimeUpdated) == 416 ); +C_ASSERT( sizeof(RemoteStorageEnumeratePublishedFilesByUserActionResult_t().m_rgRTimeUpdated) >= 200 ); + +C_ASSERT( sizeof(RemoteStorageFileReadAsyncComplete_t) >= 24 ); +C_ASSERT( offsetof(RemoteStorageFileReadAsyncComplete_t, m_hFileReadAsync) == 0 ); +C_ASSERT( sizeof(RemoteStorageFileReadAsyncComplete_t().m_hFileReadAsync) >= 8 ); +C_ASSERT( offsetof(RemoteStorageFileReadAsyncComplete_t, m_eResult) == 8 ); +C_ASSERT( sizeof(RemoteStorageFileReadAsyncComplete_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(RemoteStorageFileReadAsyncComplete_t, m_nOffset) == 12 ); +C_ASSERT( sizeof(RemoteStorageFileReadAsyncComplete_t().m_nOffset) >= 4 ); +C_ASSERT( offsetof(RemoteStorageFileReadAsyncComplete_t, m_cubRead) == 16 ); +C_ASSERT( sizeof(RemoteStorageFileReadAsyncComplete_t().m_cubRead) >= 4 ); + +C_ASSERT( sizeof(RemoteStorageFileWriteAsyncComplete_t) >= 4 ); +C_ASSERT( offsetof(RemoteStorageFileWriteAsyncComplete_t, m_eResult) == 0 ); +C_ASSERT( sizeof(RemoteStorageFileWriteAsyncComplete_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(RemoteStorageLocalFileChange_t) >= 1 ); + +C_ASSERT( sizeof(RemoteStoragePublishFileProgress_t) >= 16 ); +C_ASSERT( offsetof(RemoteStoragePublishFileProgress_t, m_dPercentFile) == 0 ); +C_ASSERT( sizeof(RemoteStoragePublishFileProgress_t().m_dPercentFile) >= 8 ); +C_ASSERT( offsetof(RemoteStoragePublishFileProgress_t, m_bPreview) == 8 ); +C_ASSERT( sizeof(RemoteStoragePublishFileProgress_t().m_bPreview) >= 1 ); + +C_ASSERT( sizeof(RemoteStoragePublishedFileDeleted_t) >= 16 ); +C_ASSERT( offsetof(RemoteStoragePublishedFileDeleted_t, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(RemoteStoragePublishedFileDeleted_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(RemoteStoragePublishedFileDeleted_t, m_nAppID) == 8 ); +C_ASSERT( sizeof(RemoteStoragePublishedFileDeleted_t().m_nAppID) >= 4 ); + +C_ASSERT( sizeof(RemoteStoragePublishedFileSubscribed_t) >= 16 ); +C_ASSERT( offsetof(RemoteStoragePublishedFileSubscribed_t, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(RemoteStoragePublishedFileSubscribed_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(RemoteStoragePublishedFileSubscribed_t, m_nAppID) == 8 ); +C_ASSERT( sizeof(RemoteStoragePublishedFileSubscribed_t().m_nAppID) >= 4 ); + +C_ASSERT( sizeof(RemoteStoragePublishedFileUnsubscribed_t) >= 16 ); +C_ASSERT( offsetof(RemoteStoragePublishedFileUnsubscribed_t, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(RemoteStoragePublishedFileUnsubscribed_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(RemoteStoragePublishedFileUnsubscribed_t, m_nAppID) == 8 ); +C_ASSERT( sizeof(RemoteStoragePublishedFileUnsubscribed_t().m_nAppID) >= 4 ); + +C_ASSERT( sizeof(RequestFriendsLobbiesResponse_t) >= 24 ); +C_ASSERT( offsetof(RequestFriendsLobbiesResponse_t, m_ulSteamIDFriend) == 0 ); +C_ASSERT( sizeof(RequestFriendsLobbiesResponse_t().m_ulSteamIDFriend) >= 8 ); +C_ASSERT( offsetof(RequestFriendsLobbiesResponse_t, m_ulSteamIDLobby) == 8 ); +C_ASSERT( sizeof(RequestFriendsLobbiesResponse_t().m_ulSteamIDLobby) >= 8 ); +C_ASSERT( offsetof(RequestFriendsLobbiesResponse_t, m_cResultIndex) == 16 ); +C_ASSERT( sizeof(RequestFriendsLobbiesResponse_t().m_cResultIndex) >= 4 ); +C_ASSERT( offsetof(RequestFriendsLobbiesResponse_t, m_cResultsTotal) == 20 ); +C_ASSERT( sizeof(RequestFriendsLobbiesResponse_t().m_cResultsTotal) >= 4 ); + +C_ASSERT( sizeof(ReservationNotificationCallback_t) >= 16 ); +C_ASSERT( offsetof(ReservationNotificationCallback_t, m_ulBeaconID) == 0 ); +C_ASSERT( sizeof(ReservationNotificationCallback_t().m_ulBeaconID) >= 8 ); +C_ASSERT( offsetof(ReservationNotificationCallback_t, m_steamIDJoiner) == 8 ); +C_ASSERT( sizeof(ReservationNotificationCallback_t().m_steamIDJoiner) >= 8 ); + +C_ASSERT( sizeof(ScreenshotReady_t) >= 8 ); +C_ASSERT( offsetof(ScreenshotReady_t, m_hLocal) == 0 ); +C_ASSERT( sizeof(ScreenshotReady_t().m_hLocal) >= 4 ); +C_ASSERT( offsetof(ScreenshotReady_t, m_eResult) == 4 ); +C_ASSERT( sizeof(ScreenshotReady_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(ScreenshotRequested_t) >= 1 ); + +C_ASSERT( sizeof(SearchForGameProgressCallback_t) >= 40 ); +C_ASSERT( offsetof(SearchForGameProgressCallback_t, m_ullSearchID) == 0 ); +C_ASSERT( sizeof(SearchForGameProgressCallback_t().m_ullSearchID) >= 8 ); +C_ASSERT( offsetof(SearchForGameProgressCallback_t, m_eResult) == 8 ); +C_ASSERT( sizeof(SearchForGameProgressCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(SearchForGameProgressCallback_t, m_lobbyID) == 12 ); +C_ASSERT( sizeof(SearchForGameProgressCallback_t().m_lobbyID) >= 8 ); +C_ASSERT( offsetof(SearchForGameProgressCallback_t, m_steamIDEndedSearch) == 20 ); +C_ASSERT( sizeof(SearchForGameProgressCallback_t().m_steamIDEndedSearch) >= 8 ); +C_ASSERT( offsetof(SearchForGameProgressCallback_t, m_nSecondsRemainingEstimate) == 28 ); +C_ASSERT( sizeof(SearchForGameProgressCallback_t().m_nSecondsRemainingEstimate) >= 4 ); +C_ASSERT( offsetof(SearchForGameProgressCallback_t, m_cPlayersSearching) == 32 ); +C_ASSERT( sizeof(SearchForGameProgressCallback_t().m_cPlayersSearching) >= 4 ); + +C_ASSERT( sizeof(SearchForGameResultCallback_t) >= 32 ); +C_ASSERT( offsetof(SearchForGameResultCallback_t, m_ullSearchID) == 0 ); +C_ASSERT( sizeof(SearchForGameResultCallback_t().m_ullSearchID) >= 8 ); +C_ASSERT( offsetof(SearchForGameResultCallback_t, m_eResult) == 8 ); +C_ASSERT( sizeof(SearchForGameResultCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(SearchForGameResultCallback_t, m_nCountPlayersInGame) == 12 ); +C_ASSERT( sizeof(SearchForGameResultCallback_t().m_nCountPlayersInGame) >= 4 ); +C_ASSERT( offsetof(SearchForGameResultCallback_t, m_nCountAcceptedGame) == 16 ); +C_ASSERT( sizeof(SearchForGameResultCallback_t().m_nCountAcceptedGame) >= 4 ); +C_ASSERT( offsetof(SearchForGameResultCallback_t, m_steamIDHost) == 20 ); +C_ASSERT( sizeof(SearchForGameResultCallback_t().m_steamIDHost) >= 8 ); +C_ASSERT( offsetof(SearchForGameResultCallback_t, m_bFinalCallback) == 28 ); +C_ASSERT( sizeof(SearchForGameResultCallback_t().m_bFinalCallback) >= 1 ); + +C_ASSERT( sizeof(SetPersonaNameResponse_t) >= 8 ); +C_ASSERT( offsetof(SetPersonaNameResponse_t, m_bSuccess) == 0 ); +C_ASSERT( sizeof(SetPersonaNameResponse_t().m_bSuccess) >= 1 ); +C_ASSERT( offsetof(SetPersonaNameResponse_t, m_bLocalSuccess) == 1 ); +C_ASSERT( sizeof(SetPersonaNameResponse_t().m_bLocalSuccess) >= 1 ); +C_ASSERT( offsetof(SetPersonaNameResponse_t, m_result) == 4 ); +C_ASSERT( sizeof(SetPersonaNameResponse_t().m_result) >= 4 ); + +C_ASSERT( sizeof(SetUserItemVoteResult_t) >= 16 ); +C_ASSERT( offsetof(SetUserItemVoteResult_t, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(SetUserItemVoteResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(SetUserItemVoteResult_t, m_eResult) == 8 ); +C_ASSERT( sizeof(SetUserItemVoteResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(SetUserItemVoteResult_t, m_bVoteUp) == 12 ); +C_ASSERT( sizeof(SetUserItemVoteResult_t().m_bVoteUp) >= 1 ); + +C_ASSERT( sizeof(SocketStatusCallback_t) >= 20 ); +C_ASSERT( offsetof(SocketStatusCallback_t, m_hSocket) == 0 ); +C_ASSERT( sizeof(SocketStatusCallback_t().m_hSocket) >= 4 ); +C_ASSERT( offsetof(SocketStatusCallback_t, m_hListenSocket) == 4 ); +C_ASSERT( sizeof(SocketStatusCallback_t().m_hListenSocket) >= 4 ); +C_ASSERT( offsetof(SocketStatusCallback_t, m_steamIDRemote) == 8 ); +C_ASSERT( sizeof(SocketStatusCallback_t().m_steamIDRemote) >= 8 ); +C_ASSERT( offsetof(SocketStatusCallback_t, m_eSNetSocketState) == 16 ); +C_ASSERT( sizeof(SocketStatusCallback_t().m_eSNetSocketState) >= 4 ); + +C_ASSERT( sizeof(StartPlaytimeTrackingResult_t) >= 4 ); +C_ASSERT( offsetof(StartPlaytimeTrackingResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(StartPlaytimeTrackingResult_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(SteamAPICallCompleted_t_137) >= 16 ); +C_ASSERT( offsetof(SteamAPICallCompleted_t_137, m_hAsyncCall) == 0 ); +C_ASSERT( sizeof(SteamAPICallCompleted_t_137().m_hAsyncCall) >= 8 ); +C_ASSERT( offsetof(SteamAPICallCompleted_t_137, m_iCallback) == 8 ); +C_ASSERT( sizeof(SteamAPICallCompleted_t_137().m_iCallback) >= 4 ); +C_ASSERT( offsetof(SteamAPICallCompleted_t_137, m_cubParam) == 12 ); +C_ASSERT( sizeof(SteamAPICallCompleted_t_137().m_cubParam) >= 4 ); + +C_ASSERT( sizeof(SteamAPICallCompleted_t_102x) >= 8 ); +C_ASSERT( offsetof(SteamAPICallCompleted_t_102x, m_hAsyncCall) == 0 ); +C_ASSERT( sizeof(SteamAPICallCompleted_t_102x().m_hAsyncCall) >= 8 ); + +C_ASSERT( sizeof(SteamAppInstalled_t_152) >= 8 ); +C_ASSERT( offsetof(SteamAppInstalled_t_152, m_nAppID) == 0 ); +C_ASSERT( sizeof(SteamAppInstalled_t_152().m_nAppID) >= 4 ); +C_ASSERT( offsetof(SteamAppInstalled_t_152, m_iInstallFolderIndex) == 4 ); +C_ASSERT( sizeof(SteamAppInstalled_t_152().m_iInstallFolderIndex) >= 4 ); + +C_ASSERT( sizeof(SteamAppInstalled_t_128x) >= 4 ); +C_ASSERT( offsetof(SteamAppInstalled_t_128x, m_nAppID) == 0 ); +C_ASSERT( sizeof(SteamAppInstalled_t_128x().m_nAppID) >= 4 ); + +C_ASSERT( sizeof(SteamAppUninstalled_t_152) >= 8 ); +C_ASSERT( offsetof(SteamAppUninstalled_t_152, m_nAppID) == 0 ); +C_ASSERT( sizeof(SteamAppUninstalled_t_152().m_nAppID) >= 4 ); +C_ASSERT( offsetof(SteamAppUninstalled_t_152, m_iInstallFolderIndex) == 4 ); +C_ASSERT( sizeof(SteamAppUninstalled_t_152().m_iInstallFolderIndex) >= 4 ); + +C_ASSERT( sizeof(SteamAppUninstalled_t_128x) >= 4 ); +C_ASSERT( offsetof(SteamAppUninstalled_t_128x, m_nAppID) == 0 ); +C_ASSERT( sizeof(SteamAppUninstalled_t_128x().m_nAppID) >= 4 ); + +C_ASSERT( sizeof(SteamCallback_t) >= 1 ); + +C_ASSERT( sizeof(SteamControllerState001_t) >= 20 ); +C_ASSERT( offsetof(SteamControllerState001_t, unPacketNum) == 0 ); +C_ASSERT( sizeof(SteamControllerState001_t().unPacketNum) >= 4 ); +C_ASSERT( offsetof(SteamControllerState001_t, ulButtons) == 4 ); +C_ASSERT( sizeof(SteamControllerState001_t().ulButtons) >= 8 ); +C_ASSERT( offsetof(SteamControllerState001_t, sLeftPadX) == 12 ); +C_ASSERT( sizeof(SteamControllerState001_t().sLeftPadX) >= 2 ); +C_ASSERT( offsetof(SteamControllerState001_t, sLeftPadY) == 14 ); +C_ASSERT( sizeof(SteamControllerState001_t().sLeftPadY) >= 2 ); +C_ASSERT( offsetof(SteamControllerState001_t, sRightPadX) == 16 ); +C_ASSERT( sizeof(SteamControllerState001_t().sRightPadX) >= 2 ); +C_ASSERT( offsetof(SteamControllerState001_t, sRightPadY) == 18 ); +C_ASSERT( sizeof(SteamControllerState001_t().sRightPadY) >= 2 ); + +C_ASSERT( sizeof(SteamControllerState_t) >= 20 ); +C_ASSERT( offsetof(SteamControllerState_t, unPacketNum) == 0 ); +C_ASSERT( sizeof(SteamControllerState_t().unPacketNum) >= 4 ); +C_ASSERT( offsetof(SteamControllerState_t, ulButtons) == 4 ); +C_ASSERT( sizeof(SteamControllerState_t().ulButtons) >= 8 ); +C_ASSERT( offsetof(SteamControllerState_t, sLeftPadX) == 12 ); +C_ASSERT( sizeof(SteamControllerState_t().sLeftPadX) >= 2 ); +C_ASSERT( offsetof(SteamControllerState_t, sLeftPadY) == 14 ); +C_ASSERT( sizeof(SteamControllerState_t().sLeftPadY) >= 2 ); +C_ASSERT( offsetof(SteamControllerState_t, sRightPadX) == 16 ); +C_ASSERT( sizeof(SteamControllerState_t().sRightPadX) >= 2 ); +C_ASSERT( offsetof(SteamControllerState_t, sRightPadY) == 18 ); +C_ASSERT( sizeof(SteamControllerState_t().sRightPadY) >= 2 ); + +C_ASSERT( sizeof(SteamInputActionEvent_t) >= 33 ); +C_ASSERT( offsetof(SteamInputActionEvent_t, controllerHandle) == 0 ); +C_ASSERT( sizeof(SteamInputActionEvent_t().controllerHandle) >= 8 ); +C_ASSERT( offsetof(SteamInputActionEvent_t, eEventType) == 8 ); +C_ASSERT( sizeof(SteamInputActionEvent_t().eEventType) >= 4 ); +C_ASSERT( offsetof(SteamInputActionEvent_t, x) == 12 ); +C_ASSERT( sizeof(SteamInputActionEvent_t().x) >= 21 ); + +C_ASSERT( sizeof(SteamInputDeviceConnected_t) >= 8 ); +C_ASSERT( offsetof(SteamInputDeviceConnected_t, m_ulConnectedDeviceHandle) == 0 ); +C_ASSERT( sizeof(SteamInputDeviceConnected_t().m_ulConnectedDeviceHandle) >= 8 ); + +C_ASSERT( sizeof(SteamInputDeviceDisconnected_t) >= 8 ); +C_ASSERT( offsetof(SteamInputDeviceDisconnected_t, m_ulDisconnectedDeviceHandle) == 0 ); +C_ASSERT( sizeof(SteamInputDeviceDisconnected_t().m_ulDisconnectedDeviceHandle) >= 8 ); + +C_ASSERT( sizeof(SteamInventoryDefinitionUpdate_t) >= 1 ); + +C_ASSERT( sizeof(SteamInventoryEligiblePromoItemDefIDs_t) >= 20 ); +C_ASSERT( offsetof(SteamInventoryEligiblePromoItemDefIDs_t, m_result) == 0 ); +C_ASSERT( sizeof(SteamInventoryEligiblePromoItemDefIDs_t().m_result) >= 4 ); +C_ASSERT( offsetof(SteamInventoryEligiblePromoItemDefIDs_t, m_steamID) == 4 ); +C_ASSERT( sizeof(SteamInventoryEligiblePromoItemDefIDs_t().m_steamID) >= 8 ); +C_ASSERT( offsetof(SteamInventoryEligiblePromoItemDefIDs_t, m_numEligiblePromoItemDefs) == 12 ); +C_ASSERT( sizeof(SteamInventoryEligiblePromoItemDefIDs_t().m_numEligiblePromoItemDefs) >= 4 ); +C_ASSERT( offsetof(SteamInventoryEligiblePromoItemDefIDs_t, m_bCachedData) == 16 ); +C_ASSERT( sizeof(SteamInventoryEligiblePromoItemDefIDs_t().m_bCachedData) >= 1 ); + +C_ASSERT( sizeof(SteamInventoryFullUpdate_t) >= 4 ); +C_ASSERT( offsetof(SteamInventoryFullUpdate_t, m_handle) == 0 ); +C_ASSERT( sizeof(SteamInventoryFullUpdate_t().m_handle) >= 4 ); + +C_ASSERT( sizeof(SteamInventoryRequestPricesResult_t) >= 8 ); +C_ASSERT( offsetof(SteamInventoryRequestPricesResult_t, m_result) == 0 ); +C_ASSERT( sizeof(SteamInventoryRequestPricesResult_t().m_result) >= 4 ); +C_ASSERT( offsetof(SteamInventoryRequestPricesResult_t, m_rgchCurrency) == 4 ); +C_ASSERT( sizeof(SteamInventoryRequestPricesResult_t().m_rgchCurrency) >= 4 ); + +C_ASSERT( sizeof(SteamInventoryResultReady_t) >= 8 ); +C_ASSERT( offsetof(SteamInventoryResultReady_t, m_handle) == 0 ); +C_ASSERT( sizeof(SteamInventoryResultReady_t().m_handle) >= 4 ); +C_ASSERT( offsetof(SteamInventoryResultReady_t, m_result) == 4 ); +C_ASSERT( sizeof(SteamInventoryResultReady_t().m_result) >= 4 ); + +C_ASSERT( sizeof(SteamItemDetails_t) >= 16 ); +C_ASSERT( offsetof(SteamItemDetails_t, m_itemId) == 0 ); +C_ASSERT( sizeof(SteamItemDetails_t().m_itemId) >= 8 ); +C_ASSERT( offsetof(SteamItemDetails_t, m_iDefinition) == 8 ); +C_ASSERT( sizeof(SteamItemDetails_t().m_iDefinition) >= 4 ); +C_ASSERT( offsetof(SteamItemDetails_t, m_unQuantity) == 12 ); +C_ASSERT( sizeof(SteamItemDetails_t().m_unQuantity) >= 2 ); +C_ASSERT( offsetof(SteamItemDetails_t, m_unFlags) == 14 ); +C_ASSERT( sizeof(SteamItemDetails_t().m_unFlags) >= 2 ); + +C_ASSERT( sizeof(SteamNetAuthenticationStatus_t) >= 260 ); +C_ASSERT( offsetof(SteamNetAuthenticationStatus_t, m_eAvail) == 0 ); +C_ASSERT( sizeof(SteamNetAuthenticationStatus_t().m_eAvail) >= 4 ); +C_ASSERT( offsetof(SteamNetAuthenticationStatus_t, m_debugMsg) == 4 ); +C_ASSERT( sizeof(SteamNetAuthenticationStatus_t().m_debugMsg) >= 256 ); + +C_ASSERT( sizeof(SteamNetConnectionRealTimeLaneStatus_t) >= 64 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeLaneStatus_t, m_cbPendingUnreliable) == 0 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeLaneStatus_t().m_cbPendingUnreliable) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeLaneStatus_t, m_cbPendingReliable) == 4 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeLaneStatus_t().m_cbPendingReliable) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeLaneStatus_t, m_cbSentUnackedReliable) == 8 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeLaneStatus_t().m_cbSentUnackedReliable) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeLaneStatus_t, _reservePad1) == 12 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeLaneStatus_t()._reservePad1) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeLaneStatus_t, m_usecQueueTime) == 16 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeLaneStatus_t().m_usecQueueTime) >= 8 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeLaneStatus_t, reserved) == 24 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeLaneStatus_t().reserved) >= 40 ); + +C_ASSERT( sizeof(SteamNetConnectionRealTimeStatus_t) >= 120 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeStatus_t, m_eState) == 0 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeStatus_t().m_eState) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeStatus_t, m_nPing) == 4 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeStatus_t().m_nPing) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeStatus_t, m_flConnectionQualityLocal) == 8 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeStatus_t().m_flConnectionQualityLocal) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeStatus_t, m_flConnectionQualityRemote) == 12 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeStatus_t().m_flConnectionQualityRemote) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeStatus_t, m_flOutPacketsPerSec) == 16 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeStatus_t().m_flOutPacketsPerSec) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeStatus_t, m_flOutBytesPerSec) == 20 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeStatus_t().m_flOutBytesPerSec) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeStatus_t, m_flInPacketsPerSec) == 24 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeStatus_t().m_flInPacketsPerSec) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeStatus_t, m_flInBytesPerSec) == 28 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeStatus_t().m_flInBytesPerSec) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeStatus_t, m_nSendRateBytesPerSecond) == 32 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeStatus_t().m_nSendRateBytesPerSecond) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeStatus_t, m_cbPendingUnreliable) == 36 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeStatus_t().m_cbPendingUnreliable) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeStatus_t, m_cbPendingReliable) == 40 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeStatus_t().m_cbPendingReliable) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeStatus_t, m_cbSentUnackedReliable) == 44 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeStatus_t().m_cbSentUnackedReliable) >= 4 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeStatus_t, m_usecQueueTime) == 48 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeStatus_t().m_usecQueueTime) >= 8 ); +C_ASSERT( offsetof(SteamNetConnectionRealTimeStatus_t, reserved) == 56 ); +C_ASSERT( sizeof(SteamNetConnectionRealTimeStatus_t().reserved) >= 64 ); + +C_ASSERT( sizeof(SteamNetworkPingLocation_t) >= 512 ); +C_ASSERT( offsetof(SteamNetworkPingLocation_t, m_data) == 0 ); +C_ASSERT( sizeof(SteamNetworkPingLocation_t().m_data) >= 512 ); + +C_ASSERT( sizeof(SteamNetworkingConfigValue_t) >= 16 ); +C_ASSERT( offsetof(SteamNetworkingConfigValue_t, m_eValue) == 0 ); +C_ASSERT( sizeof(SteamNetworkingConfigValue_t().m_eValue) >= 4 ); +C_ASSERT( offsetof(SteamNetworkingConfigValue_t, m_eDataType) == 4 ); +C_ASSERT( sizeof(SteamNetworkingConfigValue_t().m_eDataType) >= 4 ); +C_ASSERT( offsetof(SteamNetworkingConfigValue_t, m_val) == 8 ); +C_ASSERT( sizeof(SteamNetworkingConfigValue_t().m_val) >= 8 ); + +C_ASSERT( sizeof(SteamNetworkingFakeIPResult_t) >= 160 ); +C_ASSERT( offsetof(SteamNetworkingFakeIPResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(SteamNetworkingFakeIPResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(SteamNetworkingFakeIPResult_t, m_identity) == 4 ); +C_ASSERT( sizeof(SteamNetworkingFakeIPResult_t().m_identity) >= 136 ); +C_ASSERT( offsetof(SteamNetworkingFakeIPResult_t, m_unIP) == 140 ); +C_ASSERT( sizeof(SteamNetworkingFakeIPResult_t().m_unIP) >= 4 ); +C_ASSERT( offsetof(SteamNetworkingFakeIPResult_t, m_unPorts) == 144 ); +C_ASSERT( sizeof(SteamNetworkingFakeIPResult_t().m_unPorts) >= 16 ); + +C_ASSERT( sizeof(SteamNetworkingMessagesSessionFailed_t_153a) >= 696 ); +C_ASSERT( offsetof(SteamNetworkingMessagesSessionFailed_t_153a, m_info) == 0 ); +C_ASSERT( sizeof(SteamNetworkingMessagesSessionFailed_t_153a().m_info) >= 696 ); + +C_ASSERT( sizeof(SteamNetworkingMessagesSessionFailed_t_150) >= 696 ); +C_ASSERT( offsetof(SteamNetworkingMessagesSessionFailed_t_150, m_info) == 0 ); +C_ASSERT( sizeof(SteamNetworkingMessagesSessionFailed_t_150().m_info) >= 696 ); + +C_ASSERT( sizeof(SteamNetworkingMessagesSessionFailed_t_151) >= 568 ); +C_ASSERT( offsetof(SteamNetworkingMessagesSessionFailed_t_151, m_info) == 0 ); +C_ASSERT( sizeof(SteamNetworkingMessagesSessionFailed_t_151().m_info) >= 568 ); + +C_ASSERT( sizeof(SteamNetworkingMessagesSessionRequest_t_150) >= 136 ); +C_ASSERT( offsetof(SteamNetworkingMessagesSessionRequest_t_150, m_identityRemote) == 0 ); +C_ASSERT( sizeof(SteamNetworkingMessagesSessionRequest_t_150().m_identityRemote) >= 136 ); + +C_ASSERT( sizeof(SteamNetworkingMessagesSessionRequest_t_151) >= 8 ); +C_ASSERT( offsetof(SteamNetworkingMessagesSessionRequest_t_151, m_identityRemote) == 0 ); +C_ASSERT( sizeof(SteamNetworkingMessagesSessionRequest_t_151().m_identityRemote) >= 8 ); + +C_ASSERT( sizeof(SteamNetworkingPOPIDRender) >= 8 ); +C_ASSERT( offsetof(SteamNetworkingPOPIDRender, buf) == 0 ); +C_ASSERT( sizeof(SteamNetworkingPOPIDRender().buf) >= 8 ); + +C_ASSERT( sizeof(SteamNetworkingQuickConnectionStatus) >= 120 ); +C_ASSERT( offsetof(SteamNetworkingQuickConnectionStatus, m_eState) == 0 ); +C_ASSERT( sizeof(SteamNetworkingQuickConnectionStatus().m_eState) >= 4 ); +C_ASSERT( offsetof(SteamNetworkingQuickConnectionStatus, m_nPing) == 4 ); +C_ASSERT( sizeof(SteamNetworkingQuickConnectionStatus().m_nPing) >= 4 ); +C_ASSERT( offsetof(SteamNetworkingQuickConnectionStatus, m_flConnectionQualityLocal) == 8 ); +C_ASSERT( sizeof(SteamNetworkingQuickConnectionStatus().m_flConnectionQualityLocal) >= 4 ); +C_ASSERT( offsetof(SteamNetworkingQuickConnectionStatus, m_flConnectionQualityRemote) == 12 ); +C_ASSERT( sizeof(SteamNetworkingQuickConnectionStatus().m_flConnectionQualityRemote) >= 4 ); +C_ASSERT( offsetof(SteamNetworkingQuickConnectionStatus, m_flOutPacketsPerSec) == 16 ); +C_ASSERT( sizeof(SteamNetworkingQuickConnectionStatus().m_flOutPacketsPerSec) >= 4 ); +C_ASSERT( offsetof(SteamNetworkingQuickConnectionStatus, m_flOutBytesPerSec) == 20 ); +C_ASSERT( sizeof(SteamNetworkingQuickConnectionStatus().m_flOutBytesPerSec) >= 4 ); +C_ASSERT( offsetof(SteamNetworkingQuickConnectionStatus, m_flInPacketsPerSec) == 24 ); +C_ASSERT( sizeof(SteamNetworkingQuickConnectionStatus().m_flInPacketsPerSec) >= 4 ); +C_ASSERT( offsetof(SteamNetworkingQuickConnectionStatus, m_flInBytesPerSec) == 28 ); +C_ASSERT( sizeof(SteamNetworkingQuickConnectionStatus().m_flInBytesPerSec) >= 4 ); +C_ASSERT( offsetof(SteamNetworkingQuickConnectionStatus, m_nSendRateBytesPerSecond) == 32 ); +C_ASSERT( sizeof(SteamNetworkingQuickConnectionStatus().m_nSendRateBytesPerSecond) >= 4 ); +C_ASSERT( offsetof(SteamNetworkingQuickConnectionStatus, m_cbPendingUnreliable) == 36 ); +C_ASSERT( sizeof(SteamNetworkingQuickConnectionStatus().m_cbPendingUnreliable) >= 4 ); +C_ASSERT( offsetof(SteamNetworkingQuickConnectionStatus, m_cbPendingReliable) == 40 ); +C_ASSERT( sizeof(SteamNetworkingQuickConnectionStatus().m_cbPendingReliable) >= 4 ); +C_ASSERT( offsetof(SteamNetworkingQuickConnectionStatus, m_cbSentUnackedReliable) == 44 ); +C_ASSERT( sizeof(SteamNetworkingQuickConnectionStatus().m_cbSentUnackedReliable) >= 4 ); +C_ASSERT( offsetof(SteamNetworkingQuickConnectionStatus, m_usecQueueTime) == 48 ); +C_ASSERT( sizeof(SteamNetworkingQuickConnectionStatus().m_usecQueueTime) >= 8 ); +C_ASSERT( offsetof(SteamNetworkingQuickConnectionStatus, reserved) == 56 ); +C_ASSERT( sizeof(SteamNetworkingQuickConnectionStatus().reserved) >= 64 ); + +C_ASSERT( sizeof(SteamParentalSettingsChanged_t) >= 1 ); + +C_ASSERT( sizeof(SteamRelayNetworkStatus_t) >= 272 ); +C_ASSERT( offsetof(SteamRelayNetworkStatus_t, m_eAvail) == 0 ); +C_ASSERT( sizeof(SteamRelayNetworkStatus_t().m_eAvail) >= 4 ); +C_ASSERT( offsetof(SteamRelayNetworkStatus_t, m_bPingMeasurementInProgress) == 4 ); +C_ASSERT( sizeof(SteamRelayNetworkStatus_t().m_bPingMeasurementInProgress) >= 4 ); +C_ASSERT( offsetof(SteamRelayNetworkStatus_t, m_eAvailNetworkConfig) == 8 ); +C_ASSERT( sizeof(SteamRelayNetworkStatus_t().m_eAvailNetworkConfig) >= 4 ); +C_ASSERT( offsetof(SteamRelayNetworkStatus_t, m_eAvailAnyRelay) == 12 ); +C_ASSERT( sizeof(SteamRelayNetworkStatus_t().m_eAvailAnyRelay) >= 4 ); +C_ASSERT( offsetof(SteamRelayNetworkStatus_t, m_debugMsg) == 16 ); +C_ASSERT( sizeof(SteamRelayNetworkStatus_t().m_debugMsg) >= 256 ); + +C_ASSERT( sizeof(SteamRemotePlaySessionConnected_t) >= 4 ); +C_ASSERT( offsetof(SteamRemotePlaySessionConnected_t, m_unSessionID) == 0 ); +C_ASSERT( sizeof(SteamRemotePlaySessionConnected_t().m_unSessionID) >= 4 ); + +C_ASSERT( sizeof(SteamRemotePlaySessionDisconnected_t) >= 4 ); +C_ASSERT( offsetof(SteamRemotePlaySessionDisconnected_t, m_unSessionID) == 0 ); +C_ASSERT( sizeof(SteamRemotePlaySessionDisconnected_t().m_unSessionID) >= 4 ); + +C_ASSERT( sizeof(SteamRemotePlayTogetherGuestInvite_t) >= 1024 ); +C_ASSERT( offsetof(SteamRemotePlayTogetherGuestInvite_t, m_szConnectURL) == 0 ); +C_ASSERT( sizeof(SteamRemotePlayTogetherGuestInvite_t().m_szConnectURL) >= 1024 ); + +C_ASSERT( sizeof(SteamServerConnectFailure_t_135) >= 8 ); +C_ASSERT( offsetof(SteamServerConnectFailure_t_135, m_eResult) == 0 ); +C_ASSERT( sizeof(SteamServerConnectFailure_t_135().m_eResult) >= 4 ); +C_ASSERT( offsetof(SteamServerConnectFailure_t_135, m_bStillRetrying) == 4 ); +C_ASSERT( sizeof(SteamServerConnectFailure_t_135().m_bStillRetrying) >= 1 ); + +C_ASSERT( sizeof(SteamServerConnectFailure_t_099u) >= 4 ); +C_ASSERT( offsetof(SteamServerConnectFailure_t_099u, m_eResult) == 0 ); +C_ASSERT( sizeof(SteamServerConnectFailure_t_099u().m_eResult) >= 4 ); + +C_ASSERT( sizeof(SteamServersConnected_t) >= 1 ); + +C_ASSERT( sizeof(SteamServersDisconnected_t) >= 4 ); +C_ASSERT( offsetof(SteamServersDisconnected_t, m_eResult) == 0 ); +C_ASSERT( sizeof(SteamServersDisconnected_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(SteamShutdown_t) >= 1 ); + +C_ASSERT( sizeof(SteamUGCQueryCompleted_t_143) >= 280 ); +C_ASSERT( offsetof(SteamUGCQueryCompleted_t_143, m_handle) == 0 ); +C_ASSERT( sizeof(SteamUGCQueryCompleted_t_143().m_handle) >= 8 ); +C_ASSERT( offsetof(SteamUGCQueryCompleted_t_143, m_eResult) == 8 ); +C_ASSERT( sizeof(SteamUGCQueryCompleted_t_143().m_eResult) >= 4 ); +C_ASSERT( offsetof(SteamUGCQueryCompleted_t_143, m_unNumResultsReturned) == 12 ); +C_ASSERT( sizeof(SteamUGCQueryCompleted_t_143().m_unNumResultsReturned) >= 4 ); +C_ASSERT( offsetof(SteamUGCQueryCompleted_t_143, m_unTotalMatchingResults) == 16 ); +C_ASSERT( sizeof(SteamUGCQueryCompleted_t_143().m_unTotalMatchingResults) >= 4 ); +C_ASSERT( offsetof(SteamUGCQueryCompleted_t_143, m_bCachedData) == 20 ); +C_ASSERT( sizeof(SteamUGCQueryCompleted_t_143().m_bCachedData) >= 1 ); +C_ASSERT( offsetof(SteamUGCQueryCompleted_t_143, m_rgchNextCursor) == 21 ); +C_ASSERT( sizeof(SteamUGCQueryCompleted_t_143().m_rgchNextCursor) >= 256 ); + +C_ASSERT( sizeof(SteamUGCQueryCompleted_t_128x) >= 24 ); +C_ASSERT( offsetof(SteamUGCQueryCompleted_t_128x, m_handle) == 0 ); +C_ASSERT( sizeof(SteamUGCQueryCompleted_t_128x().m_handle) >= 8 ); +C_ASSERT( offsetof(SteamUGCQueryCompleted_t_128x, m_eResult) == 8 ); +C_ASSERT( sizeof(SteamUGCQueryCompleted_t_128x().m_eResult) >= 4 ); +C_ASSERT( offsetof(SteamUGCQueryCompleted_t_128x, m_unNumResultsReturned) == 12 ); +C_ASSERT( sizeof(SteamUGCQueryCompleted_t_128x().m_unNumResultsReturned) >= 4 ); +C_ASSERT( offsetof(SteamUGCQueryCompleted_t_128x, m_unTotalMatchingResults) == 16 ); +C_ASSERT( sizeof(SteamUGCQueryCompleted_t_128x().m_unTotalMatchingResults) >= 4 ); +C_ASSERT( offsetof(SteamUGCQueryCompleted_t_128x, m_bCachedData) == 20 ); +C_ASSERT( sizeof(SteamUGCQueryCompleted_t_128x().m_bCachedData) >= 1 ); + +C_ASSERT( sizeof(SteamUGCQueryCompleted_t_126) >= 24 ); +C_ASSERT( offsetof(SteamUGCQueryCompleted_t_126, m_handle) == 0 ); +C_ASSERT( sizeof(SteamUGCQueryCompleted_t_126().m_handle) >= 8 ); +C_ASSERT( offsetof(SteamUGCQueryCompleted_t_126, m_eResult) == 8 ); +C_ASSERT( sizeof(SteamUGCQueryCompleted_t_126().m_eResult) >= 4 ); +C_ASSERT( offsetof(SteamUGCQueryCompleted_t_126, m_unNumResultsReturned) == 12 ); +C_ASSERT( sizeof(SteamUGCQueryCompleted_t_126().m_unNumResultsReturned) >= 4 ); +C_ASSERT( offsetof(SteamUGCQueryCompleted_t_126, m_unTotalMatchingResults) == 16 ); +C_ASSERT( sizeof(SteamUGCQueryCompleted_t_126().m_unTotalMatchingResults) >= 4 ); + +C_ASSERT( sizeof(SteamUnifiedMessagesSendMethodResult_t) >= 24 ); +C_ASSERT( offsetof(SteamUnifiedMessagesSendMethodResult_t, m_hHandle) == 0 ); +C_ASSERT( sizeof(SteamUnifiedMessagesSendMethodResult_t().m_hHandle) >= 8 ); +C_ASSERT( offsetof(SteamUnifiedMessagesSendMethodResult_t, m_unContext) == 8 ); +C_ASSERT( sizeof(SteamUnifiedMessagesSendMethodResult_t().m_unContext) >= 8 ); +C_ASSERT( offsetof(SteamUnifiedMessagesSendMethodResult_t, m_eResult) == 16 ); +C_ASSERT( sizeof(SteamUnifiedMessagesSendMethodResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(SteamUnifiedMessagesSendMethodResult_t, m_unResponseSize) == 20 ); +C_ASSERT( sizeof(SteamUnifiedMessagesSendMethodResult_t().m_unResponseSize) >= 4 ); + +C_ASSERT( sizeof(StopPlaytimeTrackingResult_t) >= 4 ); +C_ASSERT( offsetof(StopPlaytimeTrackingResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(StopPlaytimeTrackingResult_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(StoreAuthURLResponse_t) >= 512 ); +C_ASSERT( offsetof(StoreAuthURLResponse_t, m_szURL) == 0 ); +C_ASSERT( sizeof(StoreAuthURLResponse_t().m_szURL) >= 512 ); + +C_ASSERT( sizeof(SubmitItemUpdateResult_t_141) >= 16 ); +C_ASSERT( offsetof(SubmitItemUpdateResult_t_141, m_eResult) == 0 ); +C_ASSERT( sizeof(SubmitItemUpdateResult_t_141().m_eResult) >= 4 ); +C_ASSERT( offsetof(SubmitItemUpdateResult_t_141, m_bUserNeedsToAcceptWorkshopLegalAgreement) == 4 ); +C_ASSERT( sizeof(SubmitItemUpdateResult_t_141().m_bUserNeedsToAcceptWorkshopLegalAgreement) >= 1 ); +C_ASSERT( offsetof(SubmitItemUpdateResult_t_141, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(SubmitItemUpdateResult_t_141().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(SubmitItemUpdateResult_t_130) >= 8 ); +C_ASSERT( offsetof(SubmitItemUpdateResult_t_130, m_eResult) == 0 ); +C_ASSERT( sizeof(SubmitItemUpdateResult_t_130().m_eResult) >= 4 ); +C_ASSERT( offsetof(SubmitItemUpdateResult_t_130, m_bUserNeedsToAcceptWorkshopLegalAgreement) == 4 ); +C_ASSERT( sizeof(SubmitItemUpdateResult_t_130().m_bUserNeedsToAcceptWorkshopLegalAgreement) >= 1 ); + +C_ASSERT( sizeof(TimedTrialStatus_t) >= 16 ); +C_ASSERT( offsetof(TimedTrialStatus_t, m_unAppID) == 0 ); +C_ASSERT( sizeof(TimedTrialStatus_t().m_unAppID) >= 4 ); +C_ASSERT( offsetof(TimedTrialStatus_t, m_bIsOffline) == 4 ); +C_ASSERT( sizeof(TimedTrialStatus_t().m_bIsOffline) >= 1 ); +C_ASSERT( offsetof(TimedTrialStatus_t, m_unSecondsAllowed) == 8 ); +C_ASSERT( sizeof(TimedTrialStatus_t().m_unSecondsAllowed) >= 4 ); +C_ASSERT( offsetof(TimedTrialStatus_t, m_unSecondsPlayed) == 12 ); +C_ASSERT( sizeof(TimedTrialStatus_t().m_unSecondsPlayed) >= 4 ); + +C_ASSERT( sizeof(UnreadChatMessagesChanged_t) >= 1 ); + +C_ASSERT( sizeof(UserAchievementIconFetched_t) >= 144 ); +C_ASSERT( offsetof(UserAchievementIconFetched_t, m_nGameID) == 0 ); +C_ASSERT( sizeof(UserAchievementIconFetched_t().m_nGameID) >= 8 ); +C_ASSERT( offsetof(UserAchievementIconFetched_t, m_rgchAchievementName) == 8 ); +C_ASSERT( sizeof(UserAchievementIconFetched_t().m_rgchAchievementName) >= 128 ); +C_ASSERT( offsetof(UserAchievementIconFetched_t, m_bAchieved) == 136 ); +C_ASSERT( sizeof(UserAchievementIconFetched_t().m_bAchieved) >= 1 ); +C_ASSERT( offsetof(UserAchievementIconFetched_t, m_nIconHandle) == 140 ); +C_ASSERT( sizeof(UserAchievementIconFetched_t().m_nIconHandle) >= 4 ); + +C_ASSERT( sizeof(UserAchievementStored_t) >= 152 ); +C_ASSERT( offsetof(UserAchievementStored_t, m_nGameID) == 0 ); +C_ASSERT( sizeof(UserAchievementStored_t().m_nGameID) >= 8 ); +C_ASSERT( offsetof(UserAchievementStored_t, m_bGroupAchievement) == 8 ); +C_ASSERT( sizeof(UserAchievementStored_t().m_bGroupAchievement) >= 1 ); +C_ASSERT( offsetof(UserAchievementStored_t, m_rgchAchievementName) == 9 ); +C_ASSERT( sizeof(UserAchievementStored_t().m_rgchAchievementName) >= 128 ); +C_ASSERT( offsetof(UserAchievementStored_t, m_nCurProgress) == 140 ); +C_ASSERT( sizeof(UserAchievementStored_t().m_nCurProgress) >= 4 ); +C_ASSERT( offsetof(UserAchievementStored_t, m_nMaxProgress) == 144 ); +C_ASSERT( sizeof(UserAchievementStored_t().m_nMaxProgress) >= 4 ); + +C_ASSERT( sizeof(UserFavoriteItemsListChanged_t) >= 16 ); +C_ASSERT( offsetof(UserFavoriteItemsListChanged_t, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(UserFavoriteItemsListChanged_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(UserFavoriteItemsListChanged_t, m_eResult) == 8 ); +C_ASSERT( sizeof(UserFavoriteItemsListChanged_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(UserFavoriteItemsListChanged_t, m_bWasAddRequest) == 12 ); +C_ASSERT( sizeof(UserFavoriteItemsListChanged_t().m_bWasAddRequest) >= 1 ); + +C_ASSERT( sizeof(UserStatsReceived_t_102x) >= 24 ); +C_ASSERT( offsetof(UserStatsReceived_t_102x, m_nGameID) == 0 ); +C_ASSERT( sizeof(UserStatsReceived_t_102x().m_nGameID) >= 8 ); +C_ASSERT( offsetof(UserStatsReceived_t_102x, m_eResult) == 8 ); +C_ASSERT( sizeof(UserStatsReceived_t_102x().m_eResult) >= 4 ); +C_ASSERT( offsetof(UserStatsReceived_t_102x, m_steamIDUser) == 12 ); +C_ASSERT( sizeof(UserStatsReceived_t_102x().m_steamIDUser) >= 8 ); + +C_ASSERT( sizeof(UserStatsReceived_t_099u) >= 16 ); +C_ASSERT( offsetof(UserStatsReceived_t_099u, m_nGameID) == 0 ); +C_ASSERT( sizeof(UserStatsReceived_t_099u().m_nGameID) >= 8 ); +C_ASSERT( offsetof(UserStatsReceived_t_099u, m_eResult) == 8 ); +C_ASSERT( sizeof(UserStatsReceived_t_099u().m_eResult) >= 4 ); + +C_ASSERT( sizeof(UserStatsStored_t) >= 16 ); +C_ASSERT( offsetof(UserStatsStored_t, m_nGameID) == 0 ); +C_ASSERT( sizeof(UserStatsStored_t().m_nGameID) >= 8 ); +C_ASSERT( offsetof(UserStatsStored_t, m_eResult) == 8 ); +C_ASSERT( sizeof(UserStatsStored_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(UserStatsUnloaded_t) >= 8 ); +C_ASSERT( offsetof(UserStatsUnloaded_t, m_steamIDUser) == 0 ); +C_ASSERT( sizeof(UserStatsUnloaded_t().m_steamIDUser) >= 8 ); + +C_ASSERT( sizeof(UserSubscribedItemsListChanged_t) >= 4 ); +C_ASSERT( offsetof(UserSubscribedItemsListChanged_t, m_nAppID) == 0 ); +C_ASSERT( sizeof(UserSubscribedItemsListChanged_t().m_nAppID) >= 4 ); + +C_ASSERT( sizeof(ValidateAuthTicketResponse_t_126) >= 20 ); +C_ASSERT( offsetof(ValidateAuthTicketResponse_t_126, m_SteamID) == 0 ); +C_ASSERT( sizeof(ValidateAuthTicketResponse_t_126().m_SteamID) >= 8 ); +C_ASSERT( offsetof(ValidateAuthTicketResponse_t_126, m_eAuthSessionResponse) == 8 ); +C_ASSERT( sizeof(ValidateAuthTicketResponse_t_126().m_eAuthSessionResponse) >= 4 ); +C_ASSERT( offsetof(ValidateAuthTicketResponse_t_126, m_OwnerSteamID) == 12 ); +C_ASSERT( sizeof(ValidateAuthTicketResponse_t_126().m_OwnerSteamID) >= 8 ); + +C_ASSERT( sizeof(ValidateAuthTicketResponse_t_104) >= 12 ); +C_ASSERT( offsetof(ValidateAuthTicketResponse_t_104, m_SteamID) == 0 ); +C_ASSERT( sizeof(ValidateAuthTicketResponse_t_104().m_SteamID) >= 8 ); +C_ASSERT( offsetof(ValidateAuthTicketResponse_t_104, m_eAuthSessionResponse) == 8 ); +C_ASSERT( sizeof(ValidateAuthTicketResponse_t_104().m_eAuthSessionResponse) >= 4 ); + +C_ASSERT( sizeof(VolumeHasChanged_t) >= 4 ); +C_ASSERT( offsetof(VolumeHasChanged_t, m_flNewVolume) == 0 ); +C_ASSERT( sizeof(VolumeHasChanged_t().m_flNewVolume) >= 4 ); + +C_ASSERT( sizeof(WorkshopEULAStatus_t) >= 20 ); +C_ASSERT( offsetof(WorkshopEULAStatus_t, m_eResult) == 0 ); +C_ASSERT( sizeof(WorkshopEULAStatus_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(WorkshopEULAStatus_t, m_nAppID) == 4 ); +C_ASSERT( sizeof(WorkshopEULAStatus_t().m_nAppID) >= 4 ); +C_ASSERT( offsetof(WorkshopEULAStatus_t, m_unVersion) == 8 ); +C_ASSERT( sizeof(WorkshopEULAStatus_t().m_unVersion) >= 4 ); +C_ASSERT( offsetof(WorkshopEULAStatus_t, m_rtAction) == 12 ); +C_ASSERT( sizeof(WorkshopEULAStatus_t().m_rtAction) >= 4 ); +C_ASSERT( offsetof(WorkshopEULAStatus_t, m_bAccepted) == 16 ); +C_ASSERT( sizeof(WorkshopEULAStatus_t().m_bAccepted) >= 1 ); +C_ASSERT( offsetof(WorkshopEULAStatus_t, m_bNeedsAction) == 17 ); +C_ASSERT( sizeof(WorkshopEULAStatus_t().m_bNeedsAction) >= 1 ); + +C_ASSERT( sizeof(gameserveritem_t_105) >= 372 ); +C_ASSERT( offsetof(gameserveritem_t_105, m_NetAdr) == 0 ); +C_ASSERT( sizeof(gameserveritem_t_105().m_NetAdr) >= 8 ); +C_ASSERT( offsetof(gameserveritem_t_105, m_nPing) == 8 ); +C_ASSERT( sizeof(gameserveritem_t_105().m_nPing) >= 4 ); +C_ASSERT( offsetof(gameserveritem_t_105, m_bHadSuccessfulResponse) == 12 ); +C_ASSERT( sizeof(gameserveritem_t_105().m_bHadSuccessfulResponse) >= 1 ); +C_ASSERT( offsetof(gameserveritem_t_105, m_bDoNotRefresh) == 13 ); +C_ASSERT( sizeof(gameserveritem_t_105().m_bDoNotRefresh) >= 1 ); +C_ASSERT( offsetof(gameserveritem_t_105, m_szGameDir) == 14 ); +C_ASSERT( sizeof(gameserveritem_t_105().m_szGameDir) >= 32 ); +C_ASSERT( offsetof(gameserveritem_t_105, m_szMap) == 46 ); +C_ASSERT( sizeof(gameserveritem_t_105().m_szMap) >= 32 ); +C_ASSERT( offsetof(gameserveritem_t_105, m_szGameDescription) == 78 ); +C_ASSERT( sizeof(gameserveritem_t_105().m_szGameDescription) >= 64 ); +C_ASSERT( offsetof(gameserveritem_t_105, m_nAppID) == 144 ); +C_ASSERT( sizeof(gameserveritem_t_105().m_nAppID) >= 4 ); +C_ASSERT( offsetof(gameserveritem_t_105, m_nPlayers) == 148 ); +C_ASSERT( sizeof(gameserveritem_t_105().m_nPlayers) >= 4 ); +C_ASSERT( offsetof(gameserveritem_t_105, m_nMaxPlayers) == 152 ); +C_ASSERT( sizeof(gameserveritem_t_105().m_nMaxPlayers) >= 4 ); +C_ASSERT( offsetof(gameserveritem_t_105, m_nBotPlayers) == 156 ); +C_ASSERT( sizeof(gameserveritem_t_105().m_nBotPlayers) >= 4 ); +C_ASSERT( offsetof(gameserveritem_t_105, m_bPassword) == 160 ); +C_ASSERT( sizeof(gameserveritem_t_105().m_bPassword) >= 1 ); +C_ASSERT( offsetof(gameserveritem_t_105, m_bSecure) == 161 ); +C_ASSERT( sizeof(gameserveritem_t_105().m_bSecure) >= 1 ); +C_ASSERT( offsetof(gameserveritem_t_105, m_ulTimeLastPlayed) == 164 ); +C_ASSERT( sizeof(gameserveritem_t_105().m_ulTimeLastPlayed) >= 4 ); +C_ASSERT( offsetof(gameserveritem_t_105, m_nServerVersion) == 168 ); +C_ASSERT( sizeof(gameserveritem_t_105().m_nServerVersion) >= 4 ); +C_ASSERT( offsetof(gameserveritem_t_105, m_szServerName) == 172 ); +C_ASSERT( sizeof(gameserveritem_t_105().m_szServerName) >= 64 ); +C_ASSERT( offsetof(gameserveritem_t_105, m_szGameTags) == 236 ); +C_ASSERT( sizeof(gameserveritem_t_105().m_szGameTags) >= 128 ); +C_ASSERT( offsetof(gameserveritem_t_105, m_steamID) == 364 ); +C_ASSERT( sizeof(gameserveritem_t_105().m_steamID) >= 8 ); + +C_ASSERT( sizeof(gameserveritem_t_099u) >= 364 ); +C_ASSERT( offsetof(gameserveritem_t_099u, m_NetAdr) == 0 ); +C_ASSERT( sizeof(gameserveritem_t_099u().m_NetAdr) >= 8 ); +C_ASSERT( offsetof(gameserveritem_t_099u, m_nPing) == 8 ); +C_ASSERT( sizeof(gameserveritem_t_099u().m_nPing) >= 4 ); +C_ASSERT( offsetof(gameserveritem_t_099u, m_bHadSuccessfulResponse) == 12 ); +C_ASSERT( sizeof(gameserveritem_t_099u().m_bHadSuccessfulResponse) >= 1 ); +C_ASSERT( offsetof(gameserveritem_t_099u, m_bDoNotRefresh) == 13 ); +C_ASSERT( sizeof(gameserveritem_t_099u().m_bDoNotRefresh) >= 1 ); +C_ASSERT( offsetof(gameserveritem_t_099u, m_szGameDir) == 14 ); +C_ASSERT( sizeof(gameserveritem_t_099u().m_szGameDir) >= 32 ); +C_ASSERT( offsetof(gameserveritem_t_099u, m_szMap) == 46 ); +C_ASSERT( sizeof(gameserveritem_t_099u().m_szMap) >= 32 ); +C_ASSERT( offsetof(gameserveritem_t_099u, m_szGameDescription) == 78 ); +C_ASSERT( sizeof(gameserveritem_t_099u().m_szGameDescription) >= 64 ); +C_ASSERT( offsetof(gameserveritem_t_099u, m_nAppID) == 144 ); +C_ASSERT( sizeof(gameserveritem_t_099u().m_nAppID) >= 4 ); +C_ASSERT( offsetof(gameserveritem_t_099u, m_nPlayers) == 148 ); +C_ASSERT( sizeof(gameserveritem_t_099u().m_nPlayers) >= 4 ); +C_ASSERT( offsetof(gameserveritem_t_099u, m_nMaxPlayers) == 152 ); +C_ASSERT( sizeof(gameserveritem_t_099u().m_nMaxPlayers) >= 4 ); +C_ASSERT( offsetof(gameserveritem_t_099u, m_nBotPlayers) == 156 ); +C_ASSERT( sizeof(gameserveritem_t_099u().m_nBotPlayers) >= 4 ); +C_ASSERT( offsetof(gameserveritem_t_099u, m_bPassword) == 160 ); +C_ASSERT( sizeof(gameserveritem_t_099u().m_bPassword) >= 1 ); +C_ASSERT( offsetof(gameserveritem_t_099u, m_bSecure) == 161 ); +C_ASSERT( sizeof(gameserveritem_t_099u().m_bSecure) >= 1 ); +C_ASSERT( offsetof(gameserveritem_t_099u, m_ulTimeLastPlayed) == 164 ); +C_ASSERT( sizeof(gameserveritem_t_099u().m_ulTimeLastPlayed) >= 4 ); +C_ASSERT( offsetof(gameserveritem_t_099u, m_nServerVersion) == 168 ); +C_ASSERT( sizeof(gameserveritem_t_099u().m_nServerVersion) >= 4 ); +C_ASSERT( offsetof(gameserveritem_t_099u, m_szServerName) == 172 ); +C_ASSERT( sizeof(gameserveritem_t_099u().m_szServerName) >= 64 ); +C_ASSERT( offsetof(gameserveritem_t_099u, m_szGameTags) == 236 ); +C_ASSERT( sizeof(gameserveritem_t_099u().m_szGameTags) >= 128 ); + +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x) >= 9776 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_eResult) == 8 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_eFileType) == 12 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_eFileType) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_ulSteamIDOwner) == 8160 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_rtimeCreated) == 8168 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_rtimeUpdated) == 8172 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_rtimeAddedToUserList) == 8176 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_rtimeAddedToUserList) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_eVisibility) == 8180 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_bBanned) == 8184 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_bAcceptedForUse) == 8185 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_bAcceptedForUse) >= 1 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_bTagsTruncated) == 8186 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_rgchTags) == 8187 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_hFile) == 9216 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_hFile) >= 8 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_hPreviewFile) == 9224 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_pchFileName) == 9232 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_nFileSize) == 9492 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_nPreviewFileSize) == 9496 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_rgchURL) == 9500 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_unVotesUp) == 9756 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_unVotesUp) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_unVotesDown) == 9760 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_unVotesDown) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_flScore) == 9764 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_flScore) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_128x, m_unNumChildren) == 9768 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_128x().m_unNumChildren) >= 4 ); + +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x) >= 9764 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_eResult) == 8 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_eFileType) == 12 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_eFileType) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_ulSteamIDOwner) == 8156 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_rtimeCreated) == 8164 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_rtimeUpdated) == 8168 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_rtimeAddedToUserList) == 8172 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_rtimeAddedToUserList) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_eVisibility) == 8176 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_bBanned) == 8180 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_bAcceptedForUse) == 8181 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_bAcceptedForUse) >= 1 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_bTagsTruncated) == 8182 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_rgchTags) == 8183 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_hFile) == 9208 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_hFile) >= 8 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_hPreviewFile) == 9216 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_pchFileName) == 9224 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_nFileSize) == 9484 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_nPreviewFileSize) == 9488 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_rgchURL) == 9492 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_unVotesUp) == 9748 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_unVotesUp) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_unVotesDown) == 9752 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_unVotesDown) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_flScore) == 9756 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_flScore) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_128x, m_unNumChildren) == 9760 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_128x().m_unNumChildren) >= 4 ); + +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x) >= 9776 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_eResult) == 8 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_eFileType) == 12 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_eFileType) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_ulSteamIDOwner) == 8160 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_rtimeCreated) == 8168 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_rtimeUpdated) == 8172 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_rtimeAddedToUserList) == 8176 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_rtimeAddedToUserList) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_eVisibility) == 8180 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_bBanned) == 8184 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_bAcceptedForUse) == 8185 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_bAcceptedForUse) >= 1 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_bTagsTruncated) == 8186 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_rgchTags) == 8187 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_hFile) == 9216 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_hFile) >= 8 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_hPreviewFile) == 9224 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_pchFileName) == 9232 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_nFileSize) == 9492 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_nPreviewFileSize) == 9496 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_rgchURL) == 9500 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_unVotesUp) == 9756 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_unVotesUp) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_unVotesDown) == 9760 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_unVotesDown) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_flScore) == 9764 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_flScore) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_128x, m_unNumChildren) == 9768 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_128x().m_unNumChildren) >= 4 ); + +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x) >= 9764 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_eResult) == 8 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_eFileType) == 12 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_eFileType) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_ulSteamIDOwner) == 8156 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_rtimeCreated) == 8164 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_rtimeUpdated) == 8168 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_rtimeAddedToUserList) == 8172 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_rtimeAddedToUserList) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_eVisibility) == 8176 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_bBanned) == 8180 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_bAcceptedForUse) == 8181 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_bAcceptedForUse) >= 1 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_bTagsTruncated) == 8182 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_rgchTags) == 8183 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_hFile) == 9208 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_hFile) >= 8 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_hPreviewFile) == 9216 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_pchFileName) == 9224 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_nFileSize) == 9484 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_nPreviewFileSize) == 9488 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_rgchURL) == 9492 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_unVotesUp) == 9748 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_unVotesUp) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_unVotesDown) == 9752 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_unVotesDown) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_flScore) == 9756 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_flScore) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_128x, m_unNumChildren) == 9760 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_128x().m_unNumChildren) >= 4 ); + +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126) >= 9768 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_eResult) == 8 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_eFileType) == 12 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_eFileType) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_ulSteamIDOwner) == 8160 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_rtimeCreated) == 8168 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_rtimeUpdated) == 8172 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_rtimeAddedToUserList) == 8176 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_rtimeAddedToUserList) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_eVisibility) == 8180 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_bBanned) == 8184 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_bAcceptedForUse) == 8185 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_bAcceptedForUse) >= 1 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_bTagsTruncated) == 8186 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_rgchTags) == 8187 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_hFile) == 9216 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_hFile) >= 8 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_hPreviewFile) == 9224 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_pchFileName) == 9232 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_nFileSize) == 9492 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_nPreviewFileSize) == 9496 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_rgchURL) == 9500 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_unVotesUp) == 9756 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_unVotesUp) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_unVotesDown) == 9760 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_unVotesDown) >= 4 ); +C_ASSERT( offsetof(w64_SteamUGCDetails_t_126, m_flScore) == 9764 ); +C_ASSERT( sizeof(w64_SteamUGCDetails_t_126().m_flScore) >= 4 ); + +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126) >= 9760 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_eResult) == 8 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_eFileType) == 12 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_eFileType) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_ulSteamIDOwner) == 8156 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_rtimeCreated) == 8164 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_rtimeUpdated) == 8168 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_rtimeAddedToUserList) == 8172 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_rtimeAddedToUserList) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_eVisibility) == 8176 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_bBanned) == 8180 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_bAcceptedForUse) == 8181 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_bAcceptedForUse) >= 1 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_bTagsTruncated) == 8182 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_rgchTags) == 8183 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_hFile) == 9208 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_hFile) >= 8 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_hPreviewFile) == 9216 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_pchFileName) == 9224 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_nFileSize) == 9484 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_nPreviewFileSize) == 9488 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_rgchURL) == 9492 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_unVotesUp) == 9748 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_unVotesUp) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_unVotesDown) == 9752 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_unVotesDown) >= 4 ); +C_ASSERT( offsetof(u64_SteamUGCDetails_t_126, m_flScore) == 9756 ); +C_ASSERT( sizeof(u64_SteamUGCDetails_t_126().m_flScore) >= 4 ); + +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126) >= 9768 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_eResult) == 8 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_eFileType) == 12 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_eFileType) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_ulSteamIDOwner) == 8160 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_rtimeCreated) == 8168 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_rtimeUpdated) == 8172 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_rtimeAddedToUserList) == 8176 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_rtimeAddedToUserList) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_eVisibility) == 8180 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_bBanned) == 8184 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_bAcceptedForUse) == 8185 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_bAcceptedForUse) >= 1 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_bTagsTruncated) == 8186 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_rgchTags) == 8187 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_hFile) == 9216 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_hFile) >= 8 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_hPreviewFile) == 9224 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_pchFileName) == 9232 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_nFileSize) == 9492 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_nPreviewFileSize) == 9496 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_rgchURL) == 9500 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_unVotesUp) == 9756 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_unVotesUp) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_unVotesDown) == 9760 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_unVotesDown) >= 4 ); +C_ASSERT( offsetof(w32_SteamUGCDetails_t_126, m_flScore) == 9764 ); +C_ASSERT( sizeof(w32_SteamUGCDetails_t_126().m_flScore) >= 4 ); + +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126) >= 9760 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_eResult) == 8 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_eFileType) == 12 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_eFileType) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_ulSteamIDOwner) == 8156 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_rtimeCreated) == 8164 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_rtimeUpdated) == 8168 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_rtimeAddedToUserList) == 8172 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_rtimeAddedToUserList) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_eVisibility) == 8176 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_bBanned) == 8180 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_bAcceptedForUse) == 8181 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_bAcceptedForUse) >= 1 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_bTagsTruncated) == 8182 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_rgchTags) == 8183 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_hFile) == 9208 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_hFile) >= 8 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_hPreviewFile) == 9216 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_pchFileName) == 9224 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_nFileSize) == 9484 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_nPreviewFileSize) == 9488 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_rgchURL) == 9492 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_unVotesUp) == 9748 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_unVotesUp) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_unVotesDown) == 9752 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_unVotesDown) >= 4 ); +C_ASSERT( offsetof(u32_SteamUGCDetails_t_126, m_flScore) == 9756 ); +C_ASSERT( sizeof(u32_SteamUGCDetails_t_126().m_flScore) >= 4 ); + +C_ASSERT( sizeof(w64_AddAppDependencyResult_t) >= 24 ); +C_ASSERT( offsetof(w64_AddAppDependencyResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_AddAppDependencyResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_AddAppDependencyResult_t, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_AddAppDependencyResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_AddAppDependencyResult_t, m_nAppID) == 16 ); +C_ASSERT( sizeof(w64_AddAppDependencyResult_t().m_nAppID) >= 4 ); + +C_ASSERT( sizeof(u64_AddAppDependencyResult_t) >= 16 ); +C_ASSERT( offsetof(u64_AddAppDependencyResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_AddAppDependencyResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_AddAppDependencyResult_t, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_AddAppDependencyResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_AddAppDependencyResult_t, m_nAppID) == 12 ); +C_ASSERT( sizeof(u64_AddAppDependencyResult_t().m_nAppID) >= 4 ); + +C_ASSERT( sizeof(w32_AddAppDependencyResult_t) >= 24 ); +C_ASSERT( offsetof(w32_AddAppDependencyResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_AddAppDependencyResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_AddAppDependencyResult_t, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_AddAppDependencyResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_AddAppDependencyResult_t, m_nAppID) == 16 ); +C_ASSERT( sizeof(w32_AddAppDependencyResult_t().m_nAppID) >= 4 ); + +C_ASSERT( sizeof(u32_AddAppDependencyResult_t) >= 16 ); +C_ASSERT( offsetof(u32_AddAppDependencyResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_AddAppDependencyResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_AddAppDependencyResult_t, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_AddAppDependencyResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_AddAppDependencyResult_t, m_nAppID) == 12 ); +C_ASSERT( sizeof(u32_AddAppDependencyResult_t().m_nAppID) >= 4 ); + +C_ASSERT( sizeof(w64_AddUGCDependencyResult_t) >= 24 ); +C_ASSERT( offsetof(w64_AddUGCDependencyResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_AddUGCDependencyResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_AddUGCDependencyResult_t, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_AddUGCDependencyResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_AddUGCDependencyResult_t, m_nChildPublishedFileId) == 16 ); +C_ASSERT( sizeof(w64_AddUGCDependencyResult_t().m_nChildPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u64_AddUGCDependencyResult_t) >= 20 ); +C_ASSERT( offsetof(u64_AddUGCDependencyResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_AddUGCDependencyResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_AddUGCDependencyResult_t, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_AddUGCDependencyResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_AddUGCDependencyResult_t, m_nChildPublishedFileId) == 12 ); +C_ASSERT( sizeof(u64_AddUGCDependencyResult_t().m_nChildPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w32_AddUGCDependencyResult_t) >= 24 ); +C_ASSERT( offsetof(w32_AddUGCDependencyResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_AddUGCDependencyResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_AddUGCDependencyResult_t, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_AddUGCDependencyResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_AddUGCDependencyResult_t, m_nChildPublishedFileId) == 16 ); +C_ASSERT( sizeof(w32_AddUGCDependencyResult_t().m_nChildPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u32_AddUGCDependencyResult_t) >= 20 ); +C_ASSERT( offsetof(u32_AddUGCDependencyResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_AddUGCDependencyResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_AddUGCDependencyResult_t, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_AddUGCDependencyResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_AddUGCDependencyResult_t, m_nChildPublishedFileId) == 12 ); +C_ASSERT( sizeof(u32_AddUGCDependencyResult_t().m_nChildPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w64_CSteamAPIContext_143) >= 184 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamClient) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamUser) == 8 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamUser) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamFriends) == 16 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamFriends) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamUtils) == 24 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamUtils) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamMatchmaking) == 32 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamMatchmaking) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamGameSearch) == 40 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamGameSearch) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamUserStats) == 48 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamUserStats) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamApps) == 56 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamApps) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamMatchmakingServers) == 64 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamMatchmakingServers) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamNetworking) == 72 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamNetworking) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamRemoteStorage) == 80 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamRemoteStorage) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamScreenshots) == 88 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamScreenshots) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamHTTP) == 96 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamHTTP) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pController) == 104 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pController) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamUGC) == 112 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamUGC) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamAppList) == 120 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamAppList) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamMusic) == 128 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamMusic) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamMusicRemote) == 136 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamMusicRemote) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamHTMLSurface) == 144 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamHTMLSurface) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamInventory) == 152 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamInventory) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamVideo) == 160 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamVideo) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamParentalSettings) == 168 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamParentalSettings) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_143, m_pSteamInput) == 176 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_143().m_pSteamInput) >= 8 ); + +C_ASSERT( sizeof(u64_CSteamAPIContext_143) >= 184 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamClient) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamUser) == 8 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamUser) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamFriends) == 16 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamFriends) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamUtils) == 24 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamUtils) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamMatchmaking) == 32 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamMatchmaking) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamGameSearch) == 40 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamGameSearch) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamUserStats) == 48 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamUserStats) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamApps) == 56 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamApps) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamMatchmakingServers) == 64 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamMatchmakingServers) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamNetworking) == 72 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamNetworking) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamRemoteStorage) == 80 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamRemoteStorage) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamScreenshots) == 88 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamScreenshots) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamHTTP) == 96 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamHTTP) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pController) == 104 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pController) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamUGC) == 112 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamUGC) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamAppList) == 120 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamAppList) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamMusic) == 128 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamMusic) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamMusicRemote) == 136 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamMusicRemote) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamHTMLSurface) == 144 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamHTMLSurface) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamInventory) == 152 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamInventory) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamVideo) == 160 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamVideo) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamParentalSettings) == 168 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamParentalSettings) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_143, m_pSteamInput) == 176 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_143().m_pSteamInput) >= 8 ); + +C_ASSERT( sizeof(w32_CSteamAPIContext_143) >= 92 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamClient) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamUser) == 4 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamUser) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamFriends) == 8 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamFriends) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamUtils) == 12 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamUtils) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamMatchmaking) == 16 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamMatchmaking) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamGameSearch) == 20 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamGameSearch) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamUserStats) == 24 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamUserStats) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamApps) == 28 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamApps) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamMatchmakingServers) == 32 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamMatchmakingServers) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamNetworking) == 36 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamNetworking) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamRemoteStorage) == 40 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamRemoteStorage) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamScreenshots) == 44 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamScreenshots) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamHTTP) == 48 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamHTTP) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pController) == 52 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pController) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamUGC) == 56 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamUGC) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamAppList) == 60 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamAppList) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamMusic) == 64 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamMusic) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamMusicRemote) == 68 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamMusicRemote) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamHTMLSurface) == 72 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamHTMLSurface) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamInventory) == 76 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamInventory) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamVideo) == 80 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamVideo) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamParentalSettings) == 84 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamParentalSettings) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_143, m_pSteamInput) == 88 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_143().m_pSteamInput) >= 4 ); + +C_ASSERT( sizeof(u32_CSteamAPIContext_143) >= 92 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamClient) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamUser) == 4 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamUser) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamFriends) == 8 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamFriends) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamUtils) == 12 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamUtils) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamMatchmaking) == 16 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamMatchmaking) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamGameSearch) == 20 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamGameSearch) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamUserStats) == 24 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamUserStats) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamApps) == 28 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamApps) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamMatchmakingServers) == 32 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamMatchmakingServers) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamNetworking) == 36 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamNetworking) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamRemoteStorage) == 40 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamRemoteStorage) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamScreenshots) == 44 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamScreenshots) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamHTTP) == 48 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamHTTP) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pController) == 52 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pController) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamUGC) == 56 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamUGC) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamAppList) == 60 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamAppList) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamMusic) == 64 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamMusic) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamMusicRemote) == 68 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamMusicRemote) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamHTMLSurface) == 72 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamHTMLSurface) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamInventory) == 76 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamInventory) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamVideo) == 80 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamVideo) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamParentalSettings) == 84 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamParentalSettings) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_143, m_pSteamInput) == 88 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_143().m_pSteamInput) >= 4 ); + +C_ASSERT( sizeof(w64_CSteamAPIContext_145) >= 192 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamClient) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamUser) == 8 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamUser) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamFriends) == 16 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamFriends) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamUtils) == 24 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamUtils) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamMatchmaking) == 32 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamMatchmaking) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamGameSearch) == 40 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamGameSearch) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamUserStats) == 48 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamUserStats) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamApps) == 56 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamApps) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamMatchmakingServers) == 64 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamMatchmakingServers) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamNetworking) == 72 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamNetworking) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamRemoteStorage) == 80 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamRemoteStorage) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamScreenshots) == 88 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamScreenshots) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamHTTP) == 96 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamHTTP) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pController) == 104 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pController) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamUGC) == 112 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamUGC) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamAppList) == 120 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamAppList) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamMusic) == 128 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamMusic) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamMusicRemote) == 136 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamMusicRemote) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamHTMLSurface) == 144 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamHTMLSurface) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamInventory) == 152 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamInventory) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamVideo) == 160 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamVideo) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamTV) == 168 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamTV) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamParentalSettings) == 176 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamParentalSettings) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_145, m_pSteamInput) == 184 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_145().m_pSteamInput) >= 8 ); + +C_ASSERT( sizeof(u64_CSteamAPIContext_145) >= 192 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamClient) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamUser) == 8 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamUser) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamFriends) == 16 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamFriends) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamUtils) == 24 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamUtils) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamMatchmaking) == 32 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamMatchmaking) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamGameSearch) == 40 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamGameSearch) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamUserStats) == 48 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamUserStats) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamApps) == 56 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamApps) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamMatchmakingServers) == 64 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamMatchmakingServers) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamNetworking) == 72 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamNetworking) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamRemoteStorage) == 80 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamRemoteStorage) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamScreenshots) == 88 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamScreenshots) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamHTTP) == 96 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamHTTP) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pController) == 104 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pController) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamUGC) == 112 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamUGC) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamAppList) == 120 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamAppList) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamMusic) == 128 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamMusic) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamMusicRemote) == 136 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamMusicRemote) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamHTMLSurface) == 144 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamHTMLSurface) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamInventory) == 152 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamInventory) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamVideo) == 160 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamVideo) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamTV) == 168 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamTV) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamParentalSettings) == 176 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamParentalSettings) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_145, m_pSteamInput) == 184 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_145().m_pSteamInput) >= 8 ); + +C_ASSERT( sizeof(w32_CSteamAPIContext_145) >= 96 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamClient) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamUser) == 4 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamUser) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamFriends) == 8 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamFriends) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamUtils) == 12 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamUtils) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamMatchmaking) == 16 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamMatchmaking) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamGameSearch) == 20 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamGameSearch) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamUserStats) == 24 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamUserStats) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamApps) == 28 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamApps) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamMatchmakingServers) == 32 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamMatchmakingServers) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamNetworking) == 36 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamNetworking) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamRemoteStorage) == 40 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamRemoteStorage) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamScreenshots) == 44 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamScreenshots) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamHTTP) == 48 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamHTTP) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pController) == 52 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pController) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamUGC) == 56 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamUGC) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamAppList) == 60 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamAppList) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamMusic) == 64 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamMusic) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamMusicRemote) == 68 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamMusicRemote) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamHTMLSurface) == 72 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamHTMLSurface) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamInventory) == 76 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamInventory) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamVideo) == 80 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamVideo) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamTV) == 84 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamTV) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamParentalSettings) == 88 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamParentalSettings) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_145, m_pSteamInput) == 92 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_145().m_pSteamInput) >= 4 ); + +C_ASSERT( sizeof(u32_CSteamAPIContext_145) >= 96 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamClient) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamUser) == 4 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamUser) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamFriends) == 8 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamFriends) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamUtils) == 12 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamUtils) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamMatchmaking) == 16 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamMatchmaking) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamGameSearch) == 20 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamGameSearch) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamUserStats) == 24 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamUserStats) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamApps) == 28 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamApps) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamMatchmakingServers) == 32 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamMatchmakingServers) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamNetworking) == 36 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamNetworking) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamRemoteStorage) == 40 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamRemoteStorage) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamScreenshots) == 44 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamScreenshots) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamHTTP) == 48 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamHTTP) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pController) == 52 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pController) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamUGC) == 56 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamUGC) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamAppList) == 60 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamAppList) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamMusic) == 64 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamMusic) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamMusicRemote) == 68 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamMusicRemote) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamHTMLSurface) == 72 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamHTMLSurface) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamInventory) == 76 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamInventory) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamVideo) == 80 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamVideo) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamTV) == 84 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamTV) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamParentalSettings) == 88 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamParentalSettings) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_145, m_pSteamInput) == 92 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_145().m_pSteamInput) >= 4 ); + +C_ASSERT( sizeof(w64_CSteamAPIContext_137) >= 168 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamClient) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamUser) == 8 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamUser) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamFriends) == 16 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamFriends) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamUtils) == 24 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamUtils) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamMatchmaking) == 32 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamMatchmaking) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamUserStats) == 40 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamUserStats) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamApps) == 48 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamApps) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamMatchmakingServers) == 56 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamMatchmakingServers) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamNetworking) == 64 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamNetworking) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamRemoteStorage) == 72 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamRemoteStorage) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamScreenshots) == 80 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamScreenshots) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamHTTP) == 88 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamHTTP) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pController) == 96 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pController) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamUGC) == 104 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamUGC) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamAppList) == 112 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamAppList) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamMusic) == 120 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamMusic) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamMusicRemote) == 128 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamMusicRemote) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamHTMLSurface) == 136 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamHTMLSurface) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamInventory) == 144 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamInventory) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamVideo) == 152 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamVideo) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_137, m_pSteamParentalSettings) == 160 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_137().m_pSteamParentalSettings) >= 8 ); + +C_ASSERT( sizeof(u64_CSteamAPIContext_137) >= 168 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamClient) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamUser) == 8 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamUser) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamFriends) == 16 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamFriends) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamUtils) == 24 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamUtils) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamMatchmaking) == 32 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamMatchmaking) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamUserStats) == 40 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamUserStats) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamApps) == 48 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamApps) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamMatchmakingServers) == 56 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamMatchmakingServers) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamNetworking) == 64 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamNetworking) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamRemoteStorage) == 72 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamRemoteStorage) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamScreenshots) == 80 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamScreenshots) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamHTTP) == 88 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamHTTP) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pController) == 96 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pController) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamUGC) == 104 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamUGC) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamAppList) == 112 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamAppList) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamMusic) == 120 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamMusic) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamMusicRemote) == 128 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamMusicRemote) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamHTMLSurface) == 136 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamHTMLSurface) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamInventory) == 144 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamInventory) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamVideo) == 152 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamVideo) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_137, m_pSteamParentalSettings) == 160 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_137().m_pSteamParentalSettings) >= 8 ); + +C_ASSERT( sizeof(w32_CSteamAPIContext_137) >= 84 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamClient) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamUser) == 4 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamUser) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamFriends) == 8 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamFriends) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamUtils) == 12 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamUtils) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamMatchmaking) == 16 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamMatchmaking) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamUserStats) == 20 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamUserStats) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamApps) == 24 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamApps) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamMatchmakingServers) == 28 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamMatchmakingServers) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamNetworking) == 32 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamNetworking) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamRemoteStorage) == 36 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamRemoteStorage) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamScreenshots) == 40 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamScreenshots) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamHTTP) == 44 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamHTTP) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pController) == 48 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pController) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamUGC) == 52 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamUGC) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamAppList) == 56 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamAppList) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamMusic) == 60 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamMusic) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamMusicRemote) == 64 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamMusicRemote) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamHTMLSurface) == 68 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamHTMLSurface) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamInventory) == 72 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamInventory) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamVideo) == 76 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamVideo) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_137, m_pSteamParentalSettings) == 80 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_137().m_pSteamParentalSettings) >= 4 ); + +C_ASSERT( sizeof(u32_CSteamAPIContext_137) >= 84 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamClient) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamUser) == 4 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamUser) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamFriends) == 8 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamFriends) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamUtils) == 12 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamUtils) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamMatchmaking) == 16 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamMatchmaking) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamUserStats) == 20 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamUserStats) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamApps) == 24 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamApps) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamMatchmakingServers) == 28 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamMatchmakingServers) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamNetworking) == 32 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamNetworking) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamRemoteStorage) == 36 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamRemoteStorage) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamScreenshots) == 40 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamScreenshots) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamHTTP) == 44 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamHTTP) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pController) == 48 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pController) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamUGC) == 52 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamUGC) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamAppList) == 56 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamAppList) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamMusic) == 60 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamMusic) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamMusicRemote) == 64 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamMusicRemote) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamHTMLSurface) == 68 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamHTMLSurface) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamInventory) == 72 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamInventory) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamVideo) == 76 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamVideo) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_137, m_pSteamParentalSettings) == 80 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_137().m_pSteamParentalSettings) >= 4 ); + +C_ASSERT( sizeof(w64_CSteamAPIContext_141) >= 176 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamClient) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamUser) == 8 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamUser) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamFriends) == 16 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamFriends) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamUtils) == 24 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamUtils) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamMatchmaking) == 32 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamMatchmaking) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamUserStats) == 40 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamUserStats) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamApps) == 48 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamApps) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamMatchmakingServers) == 56 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamMatchmakingServers) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamNetworking) == 64 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamNetworking) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamRemoteStorage) == 72 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamRemoteStorage) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamScreenshots) == 80 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamScreenshots) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamHTTP) == 88 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamHTTP) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamUnifiedMessages) == 96 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamUnifiedMessages) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pController) == 104 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pController) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamUGC) == 112 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamUGC) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamAppList) == 120 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamAppList) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamMusic) == 128 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamMusic) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamMusicRemote) == 136 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamMusicRemote) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamHTMLSurface) == 144 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamHTMLSurface) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamInventory) == 152 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamInventory) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamVideo) == 160 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamVideo) >= 8 ); +C_ASSERT( offsetof(w64_CSteamAPIContext_141, m_pSteamParentalSettings) == 168 ); +C_ASSERT( sizeof(w64_CSteamAPIContext_141().m_pSteamParentalSettings) >= 8 ); + +C_ASSERT( sizeof(u64_CSteamAPIContext_141) >= 176 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamClient) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamUser) == 8 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamUser) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamFriends) == 16 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamFriends) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamUtils) == 24 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamUtils) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamMatchmaking) == 32 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamMatchmaking) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamUserStats) == 40 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamUserStats) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamApps) == 48 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamApps) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamMatchmakingServers) == 56 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamMatchmakingServers) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamNetworking) == 64 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamNetworking) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamRemoteStorage) == 72 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamRemoteStorage) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamScreenshots) == 80 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamScreenshots) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamHTTP) == 88 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamHTTP) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamUnifiedMessages) == 96 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamUnifiedMessages) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pController) == 104 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pController) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamUGC) == 112 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamUGC) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamAppList) == 120 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamAppList) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamMusic) == 128 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamMusic) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamMusicRemote) == 136 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamMusicRemote) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamHTMLSurface) == 144 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamHTMLSurface) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamInventory) == 152 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamInventory) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamVideo) == 160 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamVideo) >= 8 ); +C_ASSERT( offsetof(u64_CSteamAPIContext_141, m_pSteamParentalSettings) == 168 ); +C_ASSERT( sizeof(u64_CSteamAPIContext_141().m_pSteamParentalSettings) >= 8 ); + +C_ASSERT( sizeof(w32_CSteamAPIContext_141) >= 88 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamClient) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamUser) == 4 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamUser) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamFriends) == 8 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamFriends) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamUtils) == 12 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamUtils) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamMatchmaking) == 16 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamMatchmaking) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamUserStats) == 20 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamUserStats) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamApps) == 24 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamApps) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamMatchmakingServers) == 28 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamMatchmakingServers) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamNetworking) == 32 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamNetworking) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamRemoteStorage) == 36 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamRemoteStorage) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamScreenshots) == 40 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamScreenshots) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamHTTP) == 44 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamHTTP) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamUnifiedMessages) == 48 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamUnifiedMessages) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pController) == 52 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pController) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamUGC) == 56 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamUGC) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamAppList) == 60 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamAppList) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamMusic) == 64 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamMusic) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamMusicRemote) == 68 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamMusicRemote) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamHTMLSurface) == 72 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamHTMLSurface) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamInventory) == 76 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamInventory) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamVideo) == 80 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamVideo) >= 4 ); +C_ASSERT( offsetof(w32_CSteamAPIContext_141, m_pSteamParentalSettings) == 84 ); +C_ASSERT( sizeof(w32_CSteamAPIContext_141().m_pSteamParentalSettings) >= 4 ); + +C_ASSERT( sizeof(u32_CSteamAPIContext_141) >= 88 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamClient) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamUser) == 4 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamUser) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamFriends) == 8 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamFriends) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamUtils) == 12 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamUtils) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamMatchmaking) == 16 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamMatchmaking) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamUserStats) == 20 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamUserStats) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamApps) == 24 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamApps) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamMatchmakingServers) == 28 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamMatchmakingServers) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamNetworking) == 32 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamNetworking) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamRemoteStorage) == 36 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamRemoteStorage) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamScreenshots) == 40 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamScreenshots) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamHTTP) == 44 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamHTTP) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamUnifiedMessages) == 48 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamUnifiedMessages) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pController) == 52 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pController) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamUGC) == 56 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamUGC) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamAppList) == 60 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamAppList) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamMusic) == 64 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamMusic) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamMusicRemote) == 68 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamMusicRemote) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamHTMLSurface) == 72 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamHTMLSurface) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamInventory) == 76 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamInventory) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamVideo) == 80 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamVideo) >= 4 ); +C_ASSERT( offsetof(u32_CSteamAPIContext_141, m_pSteamParentalSettings) == 84 ); +C_ASSERT( sizeof(u32_CSteamAPIContext_141().m_pSteamParentalSettings) >= 4 ); + +C_ASSERT( sizeof(w64_CSteamGameServerAPIContext_152) >= 64 ); +C_ASSERT( offsetof(w64_CSteamGameServerAPIContext_152, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(w64_CSteamGameServerAPIContext_152().m_pSteamClient) >= 8 ); +C_ASSERT( offsetof(w64_CSteamGameServerAPIContext_152, m_pSteamGameServer) == 8 ); +C_ASSERT( sizeof(w64_CSteamGameServerAPIContext_152().m_pSteamGameServer) >= 8 ); +C_ASSERT( offsetof(w64_CSteamGameServerAPIContext_152, m_pSteamGameServerUtils) == 16 ); +C_ASSERT( sizeof(w64_CSteamGameServerAPIContext_152().m_pSteamGameServerUtils) >= 8 ); +C_ASSERT( offsetof(w64_CSteamGameServerAPIContext_152, m_pSteamGameServerNetworking) == 24 ); +C_ASSERT( sizeof(w64_CSteamGameServerAPIContext_152().m_pSteamGameServerNetworking) >= 8 ); +C_ASSERT( offsetof(w64_CSteamGameServerAPIContext_152, m_pSteamGameServerStats) == 32 ); +C_ASSERT( sizeof(w64_CSteamGameServerAPIContext_152().m_pSteamGameServerStats) >= 8 ); +C_ASSERT( offsetof(w64_CSteamGameServerAPIContext_152, m_pSteamHTTP) == 40 ); +C_ASSERT( sizeof(w64_CSteamGameServerAPIContext_152().m_pSteamHTTP) >= 8 ); +C_ASSERT( offsetof(w64_CSteamGameServerAPIContext_152, m_pSteamInventory) == 48 ); +C_ASSERT( sizeof(w64_CSteamGameServerAPIContext_152().m_pSteamInventory) >= 8 ); +C_ASSERT( offsetof(w64_CSteamGameServerAPIContext_152, m_pSteamUGC) == 56 ); +C_ASSERT( sizeof(w64_CSteamGameServerAPIContext_152().m_pSteamUGC) >= 8 ); + +C_ASSERT( sizeof(u64_CSteamGameServerAPIContext_152) >= 64 ); +C_ASSERT( offsetof(u64_CSteamGameServerAPIContext_152, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(u64_CSteamGameServerAPIContext_152().m_pSteamClient) >= 8 ); +C_ASSERT( offsetof(u64_CSteamGameServerAPIContext_152, m_pSteamGameServer) == 8 ); +C_ASSERT( sizeof(u64_CSteamGameServerAPIContext_152().m_pSteamGameServer) >= 8 ); +C_ASSERT( offsetof(u64_CSteamGameServerAPIContext_152, m_pSteamGameServerUtils) == 16 ); +C_ASSERT( sizeof(u64_CSteamGameServerAPIContext_152().m_pSteamGameServerUtils) >= 8 ); +C_ASSERT( offsetof(u64_CSteamGameServerAPIContext_152, m_pSteamGameServerNetworking) == 24 ); +C_ASSERT( sizeof(u64_CSteamGameServerAPIContext_152().m_pSteamGameServerNetworking) >= 8 ); +C_ASSERT( offsetof(u64_CSteamGameServerAPIContext_152, m_pSteamGameServerStats) == 32 ); +C_ASSERT( sizeof(u64_CSteamGameServerAPIContext_152().m_pSteamGameServerStats) >= 8 ); +C_ASSERT( offsetof(u64_CSteamGameServerAPIContext_152, m_pSteamHTTP) == 40 ); +C_ASSERT( sizeof(u64_CSteamGameServerAPIContext_152().m_pSteamHTTP) >= 8 ); +C_ASSERT( offsetof(u64_CSteamGameServerAPIContext_152, m_pSteamInventory) == 48 ); +C_ASSERT( sizeof(u64_CSteamGameServerAPIContext_152().m_pSteamInventory) >= 8 ); +C_ASSERT( offsetof(u64_CSteamGameServerAPIContext_152, m_pSteamUGC) == 56 ); +C_ASSERT( sizeof(u64_CSteamGameServerAPIContext_152().m_pSteamUGC) >= 8 ); + +C_ASSERT( sizeof(w32_CSteamGameServerAPIContext_152) >= 32 ); +C_ASSERT( offsetof(w32_CSteamGameServerAPIContext_152, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(w32_CSteamGameServerAPIContext_152().m_pSteamClient) >= 4 ); +C_ASSERT( offsetof(w32_CSteamGameServerAPIContext_152, m_pSteamGameServer) == 4 ); +C_ASSERT( sizeof(w32_CSteamGameServerAPIContext_152().m_pSteamGameServer) >= 4 ); +C_ASSERT( offsetof(w32_CSteamGameServerAPIContext_152, m_pSteamGameServerUtils) == 8 ); +C_ASSERT( sizeof(w32_CSteamGameServerAPIContext_152().m_pSteamGameServerUtils) >= 4 ); +C_ASSERT( offsetof(w32_CSteamGameServerAPIContext_152, m_pSteamGameServerNetworking) == 12 ); +C_ASSERT( sizeof(w32_CSteamGameServerAPIContext_152().m_pSteamGameServerNetworking) >= 4 ); +C_ASSERT( offsetof(w32_CSteamGameServerAPIContext_152, m_pSteamGameServerStats) == 16 ); +C_ASSERT( sizeof(w32_CSteamGameServerAPIContext_152().m_pSteamGameServerStats) >= 4 ); +C_ASSERT( offsetof(w32_CSteamGameServerAPIContext_152, m_pSteamHTTP) == 20 ); +C_ASSERT( sizeof(w32_CSteamGameServerAPIContext_152().m_pSteamHTTP) >= 4 ); +C_ASSERT( offsetof(w32_CSteamGameServerAPIContext_152, m_pSteamInventory) == 24 ); +C_ASSERT( sizeof(w32_CSteamGameServerAPIContext_152().m_pSteamInventory) >= 4 ); +C_ASSERT( offsetof(w32_CSteamGameServerAPIContext_152, m_pSteamUGC) == 28 ); +C_ASSERT( sizeof(w32_CSteamGameServerAPIContext_152().m_pSteamUGC) >= 4 ); + +C_ASSERT( sizeof(u32_CSteamGameServerAPIContext_152) >= 32 ); +C_ASSERT( offsetof(u32_CSteamGameServerAPIContext_152, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(u32_CSteamGameServerAPIContext_152().m_pSteamClient) >= 4 ); +C_ASSERT( offsetof(u32_CSteamGameServerAPIContext_152, m_pSteamGameServer) == 4 ); +C_ASSERT( sizeof(u32_CSteamGameServerAPIContext_152().m_pSteamGameServer) >= 4 ); +C_ASSERT( offsetof(u32_CSteamGameServerAPIContext_152, m_pSteamGameServerUtils) == 8 ); +C_ASSERT( sizeof(u32_CSteamGameServerAPIContext_152().m_pSteamGameServerUtils) >= 4 ); +C_ASSERT( offsetof(u32_CSteamGameServerAPIContext_152, m_pSteamGameServerNetworking) == 12 ); +C_ASSERT( sizeof(u32_CSteamGameServerAPIContext_152().m_pSteamGameServerNetworking) >= 4 ); +C_ASSERT( offsetof(u32_CSteamGameServerAPIContext_152, m_pSteamGameServerStats) == 16 ); +C_ASSERT( sizeof(u32_CSteamGameServerAPIContext_152().m_pSteamGameServerStats) >= 4 ); +C_ASSERT( offsetof(u32_CSteamGameServerAPIContext_152, m_pSteamHTTP) == 20 ); +C_ASSERT( sizeof(u32_CSteamGameServerAPIContext_152().m_pSteamHTTP) >= 4 ); +C_ASSERT( offsetof(u32_CSteamGameServerAPIContext_152, m_pSteamInventory) == 24 ); +C_ASSERT( sizeof(u32_CSteamGameServerAPIContext_152().m_pSteamInventory) >= 4 ); +C_ASSERT( offsetof(u32_CSteamGameServerAPIContext_152, m_pSteamUGC) == 28 ); +C_ASSERT( sizeof(u32_CSteamGameServerAPIContext_152().m_pSteamUGC) >= 4 ); + +C_ASSERT( sizeof(w64_CSteamGameServerAPIContext_143) >= 72 ); +C_ASSERT( offsetof(w64_CSteamGameServerAPIContext_143, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(w64_CSteamGameServerAPIContext_143().m_pSteamClient) >= 8 ); +C_ASSERT( offsetof(w64_CSteamGameServerAPIContext_143, m_pSteamGameServer) == 8 ); +C_ASSERT( sizeof(w64_CSteamGameServerAPIContext_143().m_pSteamGameServer) >= 8 ); +C_ASSERT( offsetof(w64_CSteamGameServerAPIContext_143, m_pSteamGameServerUtils) == 16 ); +C_ASSERT( sizeof(w64_CSteamGameServerAPIContext_143().m_pSteamGameServerUtils) >= 8 ); +C_ASSERT( offsetof(w64_CSteamGameServerAPIContext_143, m_pSteamGameServerNetworking) == 24 ); +C_ASSERT( sizeof(w64_CSteamGameServerAPIContext_143().m_pSteamGameServerNetworking) >= 8 ); +C_ASSERT( offsetof(w64_CSteamGameServerAPIContext_143, m_pSteamGameServerStats) == 32 ); +C_ASSERT( sizeof(w64_CSteamGameServerAPIContext_143().m_pSteamGameServerStats) >= 8 ); +C_ASSERT( offsetof(w64_CSteamGameServerAPIContext_143, m_pSteamHTTP) == 40 ); +C_ASSERT( sizeof(w64_CSteamGameServerAPIContext_143().m_pSteamHTTP) >= 8 ); +C_ASSERT( offsetof(w64_CSteamGameServerAPIContext_143, m_pSteamInventory) == 48 ); +C_ASSERT( sizeof(w64_CSteamGameServerAPIContext_143().m_pSteamInventory) >= 8 ); +C_ASSERT( offsetof(w64_CSteamGameServerAPIContext_143, m_pSteamUGC) == 56 ); +C_ASSERT( sizeof(w64_CSteamGameServerAPIContext_143().m_pSteamUGC) >= 8 ); +C_ASSERT( offsetof(w64_CSteamGameServerAPIContext_143, m_pSteamApps) == 64 ); +C_ASSERT( sizeof(w64_CSteamGameServerAPIContext_143().m_pSteamApps) >= 8 ); + +C_ASSERT( sizeof(u64_CSteamGameServerAPIContext_143) >= 72 ); +C_ASSERT( offsetof(u64_CSteamGameServerAPIContext_143, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(u64_CSteamGameServerAPIContext_143().m_pSteamClient) >= 8 ); +C_ASSERT( offsetof(u64_CSteamGameServerAPIContext_143, m_pSteamGameServer) == 8 ); +C_ASSERT( sizeof(u64_CSteamGameServerAPIContext_143().m_pSteamGameServer) >= 8 ); +C_ASSERT( offsetof(u64_CSteamGameServerAPIContext_143, m_pSteamGameServerUtils) == 16 ); +C_ASSERT( sizeof(u64_CSteamGameServerAPIContext_143().m_pSteamGameServerUtils) >= 8 ); +C_ASSERT( offsetof(u64_CSteamGameServerAPIContext_143, m_pSteamGameServerNetworking) == 24 ); +C_ASSERT( sizeof(u64_CSteamGameServerAPIContext_143().m_pSteamGameServerNetworking) >= 8 ); +C_ASSERT( offsetof(u64_CSteamGameServerAPIContext_143, m_pSteamGameServerStats) == 32 ); +C_ASSERT( sizeof(u64_CSteamGameServerAPIContext_143().m_pSteamGameServerStats) >= 8 ); +C_ASSERT( offsetof(u64_CSteamGameServerAPIContext_143, m_pSteamHTTP) == 40 ); +C_ASSERT( sizeof(u64_CSteamGameServerAPIContext_143().m_pSteamHTTP) >= 8 ); +C_ASSERT( offsetof(u64_CSteamGameServerAPIContext_143, m_pSteamInventory) == 48 ); +C_ASSERT( sizeof(u64_CSteamGameServerAPIContext_143().m_pSteamInventory) >= 8 ); +C_ASSERT( offsetof(u64_CSteamGameServerAPIContext_143, m_pSteamUGC) == 56 ); +C_ASSERT( sizeof(u64_CSteamGameServerAPIContext_143().m_pSteamUGC) >= 8 ); +C_ASSERT( offsetof(u64_CSteamGameServerAPIContext_143, m_pSteamApps) == 64 ); +C_ASSERT( sizeof(u64_CSteamGameServerAPIContext_143().m_pSteamApps) >= 8 ); + +C_ASSERT( sizeof(w32_CSteamGameServerAPIContext_143) >= 36 ); +C_ASSERT( offsetof(w32_CSteamGameServerAPIContext_143, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(w32_CSteamGameServerAPIContext_143().m_pSteamClient) >= 4 ); +C_ASSERT( offsetof(w32_CSteamGameServerAPIContext_143, m_pSteamGameServer) == 4 ); +C_ASSERT( sizeof(w32_CSteamGameServerAPIContext_143().m_pSteamGameServer) >= 4 ); +C_ASSERT( offsetof(w32_CSteamGameServerAPIContext_143, m_pSteamGameServerUtils) == 8 ); +C_ASSERT( sizeof(w32_CSteamGameServerAPIContext_143().m_pSteamGameServerUtils) >= 4 ); +C_ASSERT( offsetof(w32_CSteamGameServerAPIContext_143, m_pSteamGameServerNetworking) == 12 ); +C_ASSERT( sizeof(w32_CSteamGameServerAPIContext_143().m_pSteamGameServerNetworking) >= 4 ); +C_ASSERT( offsetof(w32_CSteamGameServerAPIContext_143, m_pSteamGameServerStats) == 16 ); +C_ASSERT( sizeof(w32_CSteamGameServerAPIContext_143().m_pSteamGameServerStats) >= 4 ); +C_ASSERT( offsetof(w32_CSteamGameServerAPIContext_143, m_pSteamHTTP) == 20 ); +C_ASSERT( sizeof(w32_CSteamGameServerAPIContext_143().m_pSteamHTTP) >= 4 ); +C_ASSERT( offsetof(w32_CSteamGameServerAPIContext_143, m_pSteamInventory) == 24 ); +C_ASSERT( sizeof(w32_CSteamGameServerAPIContext_143().m_pSteamInventory) >= 4 ); +C_ASSERT( offsetof(w32_CSteamGameServerAPIContext_143, m_pSteamUGC) == 28 ); +C_ASSERT( sizeof(w32_CSteamGameServerAPIContext_143().m_pSteamUGC) >= 4 ); +C_ASSERT( offsetof(w32_CSteamGameServerAPIContext_143, m_pSteamApps) == 32 ); +C_ASSERT( sizeof(w32_CSteamGameServerAPIContext_143().m_pSteamApps) >= 4 ); + +C_ASSERT( sizeof(u32_CSteamGameServerAPIContext_143) >= 36 ); +C_ASSERT( offsetof(u32_CSteamGameServerAPIContext_143, m_pSteamClient) == 0 ); +C_ASSERT( sizeof(u32_CSteamGameServerAPIContext_143().m_pSteamClient) >= 4 ); +C_ASSERT( offsetof(u32_CSteamGameServerAPIContext_143, m_pSteamGameServer) == 4 ); +C_ASSERT( sizeof(u32_CSteamGameServerAPIContext_143().m_pSteamGameServer) >= 4 ); +C_ASSERT( offsetof(u32_CSteamGameServerAPIContext_143, m_pSteamGameServerUtils) == 8 ); +C_ASSERT( sizeof(u32_CSteamGameServerAPIContext_143().m_pSteamGameServerUtils) >= 4 ); +C_ASSERT( offsetof(u32_CSteamGameServerAPIContext_143, m_pSteamGameServerNetworking) == 12 ); +C_ASSERT( sizeof(u32_CSteamGameServerAPIContext_143().m_pSteamGameServerNetworking) >= 4 ); +C_ASSERT( offsetof(u32_CSteamGameServerAPIContext_143, m_pSteamGameServerStats) == 16 ); +C_ASSERT( sizeof(u32_CSteamGameServerAPIContext_143().m_pSteamGameServerStats) >= 4 ); +C_ASSERT( offsetof(u32_CSteamGameServerAPIContext_143, m_pSteamHTTP) == 20 ); +C_ASSERT( sizeof(u32_CSteamGameServerAPIContext_143().m_pSteamHTTP) >= 4 ); +C_ASSERT( offsetof(u32_CSteamGameServerAPIContext_143, m_pSteamInventory) == 24 ); +C_ASSERT( sizeof(u32_CSteamGameServerAPIContext_143().m_pSteamInventory) >= 4 ); +C_ASSERT( offsetof(u32_CSteamGameServerAPIContext_143, m_pSteamUGC) == 28 ); +C_ASSERT( sizeof(u32_CSteamGameServerAPIContext_143().m_pSteamUGC) >= 4 ); +C_ASSERT( offsetof(u32_CSteamGameServerAPIContext_143, m_pSteamApps) == 32 ); +C_ASSERT( sizeof(u32_CSteamGameServerAPIContext_143().m_pSteamApps) >= 4 ); + +C_ASSERT( sizeof(w64_CallbackMsg_t) >= 24 ); +C_ASSERT( offsetof(w64_CallbackMsg_t, m_hSteamUser) == 0 ); +C_ASSERT( sizeof(w64_CallbackMsg_t().m_hSteamUser) >= 4 ); +C_ASSERT( offsetof(w64_CallbackMsg_t, m_iCallback) == 4 ); +C_ASSERT( sizeof(w64_CallbackMsg_t().m_iCallback) >= 4 ); +C_ASSERT( offsetof(w64_CallbackMsg_t, m_pubParam) == 8 ); +C_ASSERT( sizeof(w64_CallbackMsg_t().m_pubParam) >= 8 ); +C_ASSERT( offsetof(w64_CallbackMsg_t, m_cubParam) == 16 ); +C_ASSERT( sizeof(w64_CallbackMsg_t().m_cubParam) >= 4 ); + +C_ASSERT( sizeof(u64_CallbackMsg_t) >= 20 ); +C_ASSERT( offsetof(u64_CallbackMsg_t, m_hSteamUser) == 0 ); +C_ASSERT( sizeof(u64_CallbackMsg_t().m_hSteamUser) >= 4 ); +C_ASSERT( offsetof(u64_CallbackMsg_t, m_iCallback) == 4 ); +C_ASSERT( sizeof(u64_CallbackMsg_t().m_iCallback) >= 4 ); +C_ASSERT( offsetof(u64_CallbackMsg_t, m_pubParam) == 8 ); +C_ASSERT( sizeof(u64_CallbackMsg_t().m_pubParam) >= 8 ); +C_ASSERT( offsetof(u64_CallbackMsg_t, m_cubParam) == 16 ); +C_ASSERT( sizeof(u64_CallbackMsg_t().m_cubParam) >= 4 ); + +C_ASSERT( sizeof(w32_CallbackMsg_t) >= 16 ); +C_ASSERT( offsetof(w32_CallbackMsg_t, m_hSteamUser) == 0 ); +C_ASSERT( sizeof(w32_CallbackMsg_t().m_hSteamUser) >= 4 ); +C_ASSERT( offsetof(w32_CallbackMsg_t, m_iCallback) == 4 ); +C_ASSERT( sizeof(w32_CallbackMsg_t().m_iCallback) >= 4 ); +C_ASSERT( offsetof(w32_CallbackMsg_t, m_pubParam) == 8 ); +C_ASSERT( sizeof(w32_CallbackMsg_t().m_pubParam) >= 4 ); +C_ASSERT( offsetof(w32_CallbackMsg_t, m_cubParam) == 12 ); +C_ASSERT( sizeof(w32_CallbackMsg_t().m_cubParam) >= 4 ); + +C_ASSERT( sizeof(u32_CallbackMsg_t) >= 16 ); +C_ASSERT( offsetof(u32_CallbackMsg_t, m_hSteamUser) == 0 ); +C_ASSERT( sizeof(u32_CallbackMsg_t().m_hSteamUser) >= 4 ); +C_ASSERT( offsetof(u32_CallbackMsg_t, m_iCallback) == 4 ); +C_ASSERT( sizeof(u32_CallbackMsg_t().m_iCallback) >= 4 ); +C_ASSERT( offsetof(u32_CallbackMsg_t, m_pubParam) == 8 ); +C_ASSERT( sizeof(u32_CallbackMsg_t().m_pubParam) >= 4 ); +C_ASSERT( offsetof(u32_CallbackMsg_t, m_cubParam) == 12 ); +C_ASSERT( sizeof(u32_CallbackMsg_t().m_cubParam) >= 4 ); + +C_ASSERT( sizeof(w64_CreateBeaconCallback_t) >= 16 ); +C_ASSERT( offsetof(w64_CreateBeaconCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_CreateBeaconCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_CreateBeaconCallback_t, m_ulBeaconID) == 8 ); +C_ASSERT( sizeof(w64_CreateBeaconCallback_t().m_ulBeaconID) >= 8 ); + +C_ASSERT( sizeof(u64_CreateBeaconCallback_t) >= 12 ); +C_ASSERT( offsetof(u64_CreateBeaconCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_CreateBeaconCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_CreateBeaconCallback_t, m_ulBeaconID) == 4 ); +C_ASSERT( sizeof(u64_CreateBeaconCallback_t().m_ulBeaconID) >= 8 ); + +C_ASSERT( sizeof(w32_CreateBeaconCallback_t) >= 16 ); +C_ASSERT( offsetof(w32_CreateBeaconCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_CreateBeaconCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_CreateBeaconCallback_t, m_ulBeaconID) == 8 ); +C_ASSERT( sizeof(w32_CreateBeaconCallback_t().m_ulBeaconID) >= 8 ); + +C_ASSERT( sizeof(u32_CreateBeaconCallback_t) >= 12 ); +C_ASSERT( offsetof(u32_CreateBeaconCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_CreateBeaconCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_CreateBeaconCallback_t, m_ulBeaconID) == 4 ); +C_ASSERT( sizeof(u32_CreateBeaconCallback_t().m_ulBeaconID) >= 8 ); + +C_ASSERT( sizeof(w64_CreateItemResult_t) >= 24 ); +C_ASSERT( offsetof(w64_CreateItemResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_CreateItemResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_CreateItemResult_t, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_CreateItemResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_CreateItemResult_t, m_bUserNeedsToAcceptWorkshopLegalAgreement) == 16 ); +C_ASSERT( sizeof(w64_CreateItemResult_t().m_bUserNeedsToAcceptWorkshopLegalAgreement) >= 1 ); + +C_ASSERT( sizeof(u64_CreateItemResult_t) >= 16 ); +C_ASSERT( offsetof(u64_CreateItemResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_CreateItemResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_CreateItemResult_t, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_CreateItemResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_CreateItemResult_t, m_bUserNeedsToAcceptWorkshopLegalAgreement) == 12 ); +C_ASSERT( sizeof(u64_CreateItemResult_t().m_bUserNeedsToAcceptWorkshopLegalAgreement) >= 1 ); + +C_ASSERT( sizeof(w32_CreateItemResult_t) >= 24 ); +C_ASSERT( offsetof(w32_CreateItemResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_CreateItemResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_CreateItemResult_t, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_CreateItemResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_CreateItemResult_t, m_bUserNeedsToAcceptWorkshopLegalAgreement) == 16 ); +C_ASSERT( sizeof(w32_CreateItemResult_t().m_bUserNeedsToAcceptWorkshopLegalAgreement) >= 1 ); + +C_ASSERT( sizeof(u32_CreateItemResult_t) >= 16 ); +C_ASSERT( offsetof(u32_CreateItemResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_CreateItemResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_CreateItemResult_t, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_CreateItemResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_CreateItemResult_t, m_bUserNeedsToAcceptWorkshopLegalAgreement) == 12 ); +C_ASSERT( sizeof(u32_CreateItemResult_t().m_bUserNeedsToAcceptWorkshopLegalAgreement) >= 1 ); + +C_ASSERT( sizeof(w64_DeleteItemResult_t) >= 16 ); +C_ASSERT( offsetof(w64_DeleteItemResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_DeleteItemResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_DeleteItemResult_t, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_DeleteItemResult_t().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u64_DeleteItemResult_t) >= 12 ); +C_ASSERT( offsetof(u64_DeleteItemResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_DeleteItemResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_DeleteItemResult_t, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_DeleteItemResult_t().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w32_DeleteItemResult_t) >= 16 ); +C_ASSERT( offsetof(w32_DeleteItemResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_DeleteItemResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_DeleteItemResult_t, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_DeleteItemResult_t().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u32_DeleteItemResult_t) >= 12 ); +C_ASSERT( offsetof(u32_DeleteItemResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_DeleteItemResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_DeleteItemResult_t, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_DeleteItemResult_t().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w64_DownloadItemResult_t) >= 24 ); +C_ASSERT( offsetof(w64_DownloadItemResult_t, m_unAppID) == 0 ); +C_ASSERT( sizeof(w64_DownloadItemResult_t().m_unAppID) >= 4 ); +C_ASSERT( offsetof(w64_DownloadItemResult_t, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_DownloadItemResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_DownloadItemResult_t, m_eResult) == 16 ); +C_ASSERT( sizeof(w64_DownloadItemResult_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(u64_DownloadItemResult_t) >= 16 ); +C_ASSERT( offsetof(u64_DownloadItemResult_t, m_unAppID) == 0 ); +C_ASSERT( sizeof(u64_DownloadItemResult_t().m_unAppID) >= 4 ); +C_ASSERT( offsetof(u64_DownloadItemResult_t, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_DownloadItemResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_DownloadItemResult_t, m_eResult) == 12 ); +C_ASSERT( sizeof(u64_DownloadItemResult_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(w32_DownloadItemResult_t) >= 24 ); +C_ASSERT( offsetof(w32_DownloadItemResult_t, m_unAppID) == 0 ); +C_ASSERT( sizeof(w32_DownloadItemResult_t().m_unAppID) >= 4 ); +C_ASSERT( offsetof(w32_DownloadItemResult_t, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_DownloadItemResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_DownloadItemResult_t, m_eResult) == 16 ); +C_ASSERT( sizeof(w32_DownloadItemResult_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(u32_DownloadItemResult_t) >= 16 ); +C_ASSERT( offsetof(u32_DownloadItemResult_t, m_unAppID) == 0 ); +C_ASSERT( sizeof(u32_DownloadItemResult_t().m_unAppID) >= 4 ); +C_ASSERT( offsetof(u32_DownloadItemResult_t, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_DownloadItemResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_DownloadItemResult_t, m_eResult) == 12 ); +C_ASSERT( sizeof(u32_DownloadItemResult_t().m_eResult) >= 4 ); + +C_ASSERT( sizeof(w64_EndGameResultCallback_t) >= 16 ); +C_ASSERT( offsetof(w64_EndGameResultCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_EndGameResultCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_EndGameResultCallback_t, ullUniqueGameID) == 8 ); +C_ASSERT( sizeof(w64_EndGameResultCallback_t().ullUniqueGameID) >= 8 ); + +C_ASSERT( sizeof(u64_EndGameResultCallback_t) >= 12 ); +C_ASSERT( offsetof(u64_EndGameResultCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_EndGameResultCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_EndGameResultCallback_t, ullUniqueGameID) == 4 ); +C_ASSERT( sizeof(u64_EndGameResultCallback_t().ullUniqueGameID) >= 8 ); + +C_ASSERT( sizeof(w32_EndGameResultCallback_t) >= 16 ); +C_ASSERT( offsetof(w32_EndGameResultCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_EndGameResultCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_EndGameResultCallback_t, ullUniqueGameID) == 8 ); +C_ASSERT( sizeof(w32_EndGameResultCallback_t().ullUniqueGameID) >= 8 ); + +C_ASSERT( sizeof(u32_EndGameResultCallback_t) >= 12 ); +C_ASSERT( offsetof(u32_EndGameResultCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_EndGameResultCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_EndGameResultCallback_t, ullUniqueGameID) == 4 ); +C_ASSERT( sizeof(u32_EndGameResultCallback_t().ullUniqueGameID) >= 8 ); + +C_ASSERT( sizeof(w64_FileDetailsResult_t) >= 40 ); +C_ASSERT( offsetof(w64_FileDetailsResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_FileDetailsResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_FileDetailsResult_t, m_ulFileSize) == 8 ); +C_ASSERT( sizeof(w64_FileDetailsResult_t().m_ulFileSize) >= 8 ); +C_ASSERT( offsetof(w64_FileDetailsResult_t, m_FileSHA) == 16 ); +C_ASSERT( sizeof(w64_FileDetailsResult_t().m_FileSHA) >= 20 ); +C_ASSERT( offsetof(w64_FileDetailsResult_t, m_unFlags) == 36 ); +C_ASSERT( sizeof(w64_FileDetailsResult_t().m_unFlags) >= 4 ); + +C_ASSERT( sizeof(u64_FileDetailsResult_t) >= 36 ); +C_ASSERT( offsetof(u64_FileDetailsResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_FileDetailsResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_FileDetailsResult_t, m_ulFileSize) == 4 ); +C_ASSERT( sizeof(u64_FileDetailsResult_t().m_ulFileSize) >= 8 ); +C_ASSERT( offsetof(u64_FileDetailsResult_t, m_FileSHA) == 12 ); +C_ASSERT( sizeof(u64_FileDetailsResult_t().m_FileSHA) >= 20 ); +C_ASSERT( offsetof(u64_FileDetailsResult_t, m_unFlags) == 32 ); +C_ASSERT( sizeof(u64_FileDetailsResult_t().m_unFlags) >= 4 ); + +C_ASSERT( sizeof(w32_FileDetailsResult_t) >= 40 ); +C_ASSERT( offsetof(w32_FileDetailsResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_FileDetailsResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_FileDetailsResult_t, m_ulFileSize) == 8 ); +C_ASSERT( sizeof(w32_FileDetailsResult_t().m_ulFileSize) >= 8 ); +C_ASSERT( offsetof(w32_FileDetailsResult_t, m_FileSHA) == 16 ); +C_ASSERT( sizeof(w32_FileDetailsResult_t().m_FileSHA) >= 20 ); +C_ASSERT( offsetof(w32_FileDetailsResult_t, m_unFlags) == 36 ); +C_ASSERT( sizeof(w32_FileDetailsResult_t().m_unFlags) >= 4 ); + +C_ASSERT( sizeof(u32_FileDetailsResult_t) >= 36 ); +C_ASSERT( offsetof(u32_FileDetailsResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_FileDetailsResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_FileDetailsResult_t, m_ulFileSize) == 4 ); +C_ASSERT( sizeof(u32_FileDetailsResult_t().m_ulFileSize) >= 8 ); +C_ASSERT( offsetof(u32_FileDetailsResult_t, m_FileSHA) == 12 ); +C_ASSERT( sizeof(u32_FileDetailsResult_t().m_FileSHA) >= 20 ); +C_ASSERT( offsetof(u32_FileDetailsResult_t, m_unFlags) == 32 ); +C_ASSERT( sizeof(u32_FileDetailsResult_t().m_unFlags) >= 4 ); + +C_ASSERT( sizeof(w64_GSReputation_t_123) >= 40 ); +C_ASSERT( offsetof(w64_GSReputation_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_GSReputation_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_GSReputation_t_123, m_unReputationScore) == 4 ); +C_ASSERT( sizeof(w64_GSReputation_t_123().m_unReputationScore) >= 4 ); +C_ASSERT( offsetof(w64_GSReputation_t_123, m_bBanned) == 8 ); +C_ASSERT( sizeof(w64_GSReputation_t_123().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w64_GSReputation_t_123, m_unBannedIP) == 12 ); +C_ASSERT( sizeof(w64_GSReputation_t_123().m_unBannedIP) >= 4 ); +C_ASSERT( offsetof(w64_GSReputation_t_123, m_usBannedPort) == 16 ); +C_ASSERT( sizeof(w64_GSReputation_t_123().m_usBannedPort) >= 2 ); +C_ASSERT( offsetof(w64_GSReputation_t_123, m_ulBannedGameID) == 24 ); +C_ASSERT( sizeof(w64_GSReputation_t_123().m_ulBannedGameID) >= 8 ); +C_ASSERT( offsetof(w64_GSReputation_t_123, m_unBanExpires) == 32 ); +C_ASSERT( sizeof(w64_GSReputation_t_123().m_unBanExpires) >= 4 ); + +C_ASSERT( sizeof(u64_GSReputation_t_123) >= 32 ); +C_ASSERT( offsetof(u64_GSReputation_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_GSReputation_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_GSReputation_t_123, m_unReputationScore) == 4 ); +C_ASSERT( sizeof(u64_GSReputation_t_123().m_unReputationScore) >= 4 ); +C_ASSERT( offsetof(u64_GSReputation_t_123, m_bBanned) == 8 ); +C_ASSERT( sizeof(u64_GSReputation_t_123().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u64_GSReputation_t_123, m_unBannedIP) == 12 ); +C_ASSERT( sizeof(u64_GSReputation_t_123().m_unBannedIP) >= 4 ); +C_ASSERT( offsetof(u64_GSReputation_t_123, m_usBannedPort) == 16 ); +C_ASSERT( sizeof(u64_GSReputation_t_123().m_usBannedPort) >= 2 ); +C_ASSERT( offsetof(u64_GSReputation_t_123, m_ulBannedGameID) == 20 ); +C_ASSERT( sizeof(u64_GSReputation_t_123().m_ulBannedGameID) >= 8 ); +C_ASSERT( offsetof(u64_GSReputation_t_123, m_unBanExpires) == 28 ); +C_ASSERT( sizeof(u64_GSReputation_t_123().m_unBanExpires) >= 4 ); + +C_ASSERT( sizeof(w32_GSReputation_t_123) >= 40 ); +C_ASSERT( offsetof(w32_GSReputation_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_GSReputation_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_GSReputation_t_123, m_unReputationScore) == 4 ); +C_ASSERT( sizeof(w32_GSReputation_t_123().m_unReputationScore) >= 4 ); +C_ASSERT( offsetof(w32_GSReputation_t_123, m_bBanned) == 8 ); +C_ASSERT( sizeof(w32_GSReputation_t_123().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w32_GSReputation_t_123, m_unBannedIP) == 12 ); +C_ASSERT( sizeof(w32_GSReputation_t_123().m_unBannedIP) >= 4 ); +C_ASSERT( offsetof(w32_GSReputation_t_123, m_usBannedPort) == 16 ); +C_ASSERT( sizeof(w32_GSReputation_t_123().m_usBannedPort) >= 2 ); +C_ASSERT( offsetof(w32_GSReputation_t_123, m_ulBannedGameID) == 24 ); +C_ASSERT( sizeof(w32_GSReputation_t_123().m_ulBannedGameID) >= 8 ); +C_ASSERT( offsetof(w32_GSReputation_t_123, m_unBanExpires) == 32 ); +C_ASSERT( sizeof(w32_GSReputation_t_123().m_unBanExpires) >= 4 ); + +C_ASSERT( sizeof(u32_GSReputation_t_123) >= 32 ); +C_ASSERT( offsetof(u32_GSReputation_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_GSReputation_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_GSReputation_t_123, m_unReputationScore) == 4 ); +C_ASSERT( sizeof(u32_GSReputation_t_123().m_unReputationScore) >= 4 ); +C_ASSERT( offsetof(u32_GSReputation_t_123, m_bBanned) == 8 ); +C_ASSERT( sizeof(u32_GSReputation_t_123().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u32_GSReputation_t_123, m_unBannedIP) == 12 ); +C_ASSERT( sizeof(u32_GSReputation_t_123().m_unBannedIP) >= 4 ); +C_ASSERT( offsetof(u32_GSReputation_t_123, m_usBannedPort) == 16 ); +C_ASSERT( sizeof(u32_GSReputation_t_123().m_usBannedPort) >= 2 ); +C_ASSERT( offsetof(u32_GSReputation_t_123, m_ulBannedGameID) == 20 ); +C_ASSERT( sizeof(u32_GSReputation_t_123().m_ulBannedGameID) >= 8 ); +C_ASSERT( offsetof(u32_GSReputation_t_123, m_unBanExpires) == 28 ); +C_ASSERT( sizeof(u32_GSReputation_t_123().m_unBanExpires) >= 4 ); + +C_ASSERT( sizeof(w64_GSReputation_t_108) >= 40 ); +C_ASSERT( offsetof(w64_GSReputation_t_108, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_GSReputation_t_108().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_GSReputation_t_108, m_unReputationScore) == 4 ); +C_ASSERT( sizeof(w64_GSReputation_t_108().m_unReputationScore) >= 4 ); +C_ASSERT( offsetof(w64_GSReputation_t_108, m_bBanned) == 8 ); +C_ASSERT( sizeof(w64_GSReputation_t_108().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w64_GSReputation_t_108, m_unBannedIP) == 12 ); +C_ASSERT( sizeof(w64_GSReputation_t_108().m_unBannedIP) >= 4 ); +C_ASSERT( offsetof(w64_GSReputation_t_108, m_usBannedPort) == 16 ); +C_ASSERT( sizeof(w64_GSReputation_t_108().m_usBannedPort) >= 2 ); +C_ASSERT( offsetof(w64_GSReputation_t_108, m_ulBannedGameID) == 24 ); +C_ASSERT( sizeof(w64_GSReputation_t_108().m_ulBannedGameID) >= 8 ); +C_ASSERT( offsetof(w64_GSReputation_t_108, m_unBanExpires) == 32 ); +C_ASSERT( sizeof(w64_GSReputation_t_108().m_unBanExpires) >= 4 ); + +C_ASSERT( sizeof(u64_GSReputation_t_108) >= 40 ); +C_ASSERT( offsetof(u64_GSReputation_t_108, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_GSReputation_t_108().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_GSReputation_t_108, m_unReputationScore) == 4 ); +C_ASSERT( sizeof(u64_GSReputation_t_108().m_unReputationScore) >= 4 ); +C_ASSERT( offsetof(u64_GSReputation_t_108, m_bBanned) == 8 ); +C_ASSERT( sizeof(u64_GSReputation_t_108().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u64_GSReputation_t_108, m_unBannedIP) == 12 ); +C_ASSERT( sizeof(u64_GSReputation_t_108().m_unBannedIP) >= 4 ); +C_ASSERT( offsetof(u64_GSReputation_t_108, m_usBannedPort) == 16 ); +C_ASSERT( sizeof(u64_GSReputation_t_108().m_usBannedPort) >= 2 ); +C_ASSERT( offsetof(u64_GSReputation_t_108, m_ulBannedGameID) == 24 ); +C_ASSERT( sizeof(u64_GSReputation_t_108().m_ulBannedGameID) >= 8 ); +C_ASSERT( offsetof(u64_GSReputation_t_108, m_unBanExpires) == 32 ); +C_ASSERT( sizeof(u64_GSReputation_t_108().m_unBanExpires) >= 4 ); + +C_ASSERT( sizeof(w32_GSReputation_t_108) >= 40 ); +C_ASSERT( offsetof(w32_GSReputation_t_108, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_GSReputation_t_108().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_GSReputation_t_108, m_unReputationScore) == 4 ); +C_ASSERT( sizeof(w32_GSReputation_t_108().m_unReputationScore) >= 4 ); +C_ASSERT( offsetof(w32_GSReputation_t_108, m_bBanned) == 8 ); +C_ASSERT( sizeof(w32_GSReputation_t_108().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w32_GSReputation_t_108, m_unBannedIP) == 12 ); +C_ASSERT( sizeof(w32_GSReputation_t_108().m_unBannedIP) >= 4 ); +C_ASSERT( offsetof(w32_GSReputation_t_108, m_usBannedPort) == 16 ); +C_ASSERT( sizeof(w32_GSReputation_t_108().m_usBannedPort) >= 2 ); +C_ASSERT( offsetof(w32_GSReputation_t_108, m_ulBannedGameID) == 24 ); +C_ASSERT( sizeof(w32_GSReputation_t_108().m_ulBannedGameID) >= 8 ); +C_ASSERT( offsetof(w32_GSReputation_t_108, m_unBanExpires) == 32 ); +C_ASSERT( sizeof(w32_GSReputation_t_108().m_unBanExpires) >= 4 ); + +C_ASSERT( sizeof(u32_GSReputation_t_108) >= 32 ); +C_ASSERT( offsetof(u32_GSReputation_t_108, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_GSReputation_t_108().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_GSReputation_t_108, m_unReputationScore) == 4 ); +C_ASSERT( sizeof(u32_GSReputation_t_108().m_unReputationScore) >= 4 ); +C_ASSERT( offsetof(u32_GSReputation_t_108, m_bBanned) == 8 ); +C_ASSERT( sizeof(u32_GSReputation_t_108().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u32_GSReputation_t_108, m_unBannedIP) == 12 ); +C_ASSERT( sizeof(u32_GSReputation_t_108().m_unBannedIP) >= 4 ); +C_ASSERT( offsetof(u32_GSReputation_t_108, m_usBannedPort) == 16 ); +C_ASSERT( sizeof(u32_GSReputation_t_108().m_usBannedPort) >= 2 ); +C_ASSERT( offsetof(u32_GSReputation_t_108, m_ulBannedGameID) == 20 ); +C_ASSERT( sizeof(u32_GSReputation_t_108().m_ulBannedGameID) >= 8 ); +C_ASSERT( offsetof(u32_GSReputation_t_108, m_unBanExpires) == 28 ); +C_ASSERT( sizeof(u32_GSReputation_t_108().m_unBanExpires) >= 4 ); + +C_ASSERT( sizeof(w64_GetAppDependenciesResult_t) >= 152 ); +C_ASSERT( offsetof(w64_GetAppDependenciesResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_GetAppDependenciesResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_GetAppDependenciesResult_t, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_GetAppDependenciesResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_GetAppDependenciesResult_t, m_rgAppIDs) == 16 ); +C_ASSERT( sizeof(w64_GetAppDependenciesResult_t().m_rgAppIDs) >= 128 ); +C_ASSERT( offsetof(w64_GetAppDependenciesResult_t, m_nNumAppDependencies) == 144 ); +C_ASSERT( sizeof(w64_GetAppDependenciesResult_t().m_nNumAppDependencies) >= 4 ); +C_ASSERT( offsetof(w64_GetAppDependenciesResult_t, m_nTotalNumAppDependencies) == 148 ); +C_ASSERT( sizeof(w64_GetAppDependenciesResult_t().m_nTotalNumAppDependencies) >= 4 ); + +C_ASSERT( sizeof(u64_GetAppDependenciesResult_t) >= 148 ); +C_ASSERT( offsetof(u64_GetAppDependenciesResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_GetAppDependenciesResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_GetAppDependenciesResult_t, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_GetAppDependenciesResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_GetAppDependenciesResult_t, m_rgAppIDs) == 12 ); +C_ASSERT( sizeof(u64_GetAppDependenciesResult_t().m_rgAppIDs) >= 128 ); +C_ASSERT( offsetof(u64_GetAppDependenciesResult_t, m_nNumAppDependencies) == 140 ); +C_ASSERT( sizeof(u64_GetAppDependenciesResult_t().m_nNumAppDependencies) >= 4 ); +C_ASSERT( offsetof(u64_GetAppDependenciesResult_t, m_nTotalNumAppDependencies) == 144 ); +C_ASSERT( sizeof(u64_GetAppDependenciesResult_t().m_nTotalNumAppDependencies) >= 4 ); + +C_ASSERT( sizeof(w32_GetAppDependenciesResult_t) >= 152 ); +C_ASSERT( offsetof(w32_GetAppDependenciesResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_GetAppDependenciesResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_GetAppDependenciesResult_t, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_GetAppDependenciesResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_GetAppDependenciesResult_t, m_rgAppIDs) == 16 ); +C_ASSERT( sizeof(w32_GetAppDependenciesResult_t().m_rgAppIDs) >= 128 ); +C_ASSERT( offsetof(w32_GetAppDependenciesResult_t, m_nNumAppDependencies) == 144 ); +C_ASSERT( sizeof(w32_GetAppDependenciesResult_t().m_nNumAppDependencies) >= 4 ); +C_ASSERT( offsetof(w32_GetAppDependenciesResult_t, m_nTotalNumAppDependencies) == 148 ); +C_ASSERT( sizeof(w32_GetAppDependenciesResult_t().m_nTotalNumAppDependencies) >= 4 ); + +C_ASSERT( sizeof(u32_GetAppDependenciesResult_t) >= 148 ); +C_ASSERT( offsetof(u32_GetAppDependenciesResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_GetAppDependenciesResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_GetAppDependenciesResult_t, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_GetAppDependenciesResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_GetAppDependenciesResult_t, m_rgAppIDs) == 12 ); +C_ASSERT( sizeof(u32_GetAppDependenciesResult_t().m_rgAppIDs) >= 128 ); +C_ASSERT( offsetof(u32_GetAppDependenciesResult_t, m_nNumAppDependencies) == 140 ); +C_ASSERT( sizeof(u32_GetAppDependenciesResult_t().m_nNumAppDependencies) >= 4 ); +C_ASSERT( offsetof(u32_GetAppDependenciesResult_t, m_nTotalNumAppDependencies) == 144 ); +C_ASSERT( sizeof(u32_GetAppDependenciesResult_t().m_nTotalNumAppDependencies) >= 4 ); + +C_ASSERT( sizeof(w64_HTML_ChangedTitle_t) >= 16 ); +C_ASSERT( offsetof(w64_HTML_ChangedTitle_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w64_HTML_ChangedTitle_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w64_HTML_ChangedTitle_t, pchTitle) == 8 ); +C_ASSERT( sizeof(w64_HTML_ChangedTitle_t().pchTitle) >= 8 ); + +C_ASSERT( sizeof(u64_HTML_ChangedTitle_t) >= 12 ); +C_ASSERT( offsetof(u64_HTML_ChangedTitle_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u64_HTML_ChangedTitle_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u64_HTML_ChangedTitle_t, pchTitle) == 4 ); +C_ASSERT( sizeof(u64_HTML_ChangedTitle_t().pchTitle) >= 8 ); + +C_ASSERT( sizeof(w32_HTML_ChangedTitle_t) >= 8 ); +C_ASSERT( offsetof(w32_HTML_ChangedTitle_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w32_HTML_ChangedTitle_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w32_HTML_ChangedTitle_t, pchTitle) == 4 ); +C_ASSERT( sizeof(w32_HTML_ChangedTitle_t().pchTitle) >= 4 ); + +C_ASSERT( sizeof(u32_HTML_ChangedTitle_t) >= 8 ); +C_ASSERT( offsetof(u32_HTML_ChangedTitle_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u32_HTML_ChangedTitle_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u32_HTML_ChangedTitle_t, pchTitle) == 4 ); +C_ASSERT( sizeof(u32_HTML_ChangedTitle_t().pchTitle) >= 4 ); + +C_ASSERT( sizeof(w64_HTML_ComboNeedsPaint_t) >= 24 ); +C_ASSERT( offsetof(w64_HTML_ComboNeedsPaint_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w64_HTML_ComboNeedsPaint_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w64_HTML_ComboNeedsPaint_t, pBGRA) == 8 ); +C_ASSERT( sizeof(w64_HTML_ComboNeedsPaint_t().pBGRA) >= 8 ); +C_ASSERT( offsetof(w64_HTML_ComboNeedsPaint_t, unWide) == 16 ); +C_ASSERT( sizeof(w64_HTML_ComboNeedsPaint_t().unWide) >= 4 ); +C_ASSERT( offsetof(w64_HTML_ComboNeedsPaint_t, unTall) == 20 ); +C_ASSERT( sizeof(w64_HTML_ComboNeedsPaint_t().unTall) >= 4 ); + +C_ASSERT( sizeof(u64_HTML_ComboNeedsPaint_t) >= 20 ); +C_ASSERT( offsetof(u64_HTML_ComboNeedsPaint_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u64_HTML_ComboNeedsPaint_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u64_HTML_ComboNeedsPaint_t, pBGRA) == 4 ); +C_ASSERT( sizeof(u64_HTML_ComboNeedsPaint_t().pBGRA) >= 8 ); +C_ASSERT( offsetof(u64_HTML_ComboNeedsPaint_t, unWide) == 12 ); +C_ASSERT( sizeof(u64_HTML_ComboNeedsPaint_t().unWide) >= 4 ); +C_ASSERT( offsetof(u64_HTML_ComboNeedsPaint_t, unTall) == 16 ); +C_ASSERT( sizeof(u64_HTML_ComboNeedsPaint_t().unTall) >= 4 ); + +C_ASSERT( sizeof(w32_HTML_ComboNeedsPaint_t) >= 16 ); +C_ASSERT( offsetof(w32_HTML_ComboNeedsPaint_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w32_HTML_ComboNeedsPaint_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w32_HTML_ComboNeedsPaint_t, pBGRA) == 4 ); +C_ASSERT( sizeof(w32_HTML_ComboNeedsPaint_t().pBGRA) >= 4 ); +C_ASSERT( offsetof(w32_HTML_ComboNeedsPaint_t, unWide) == 8 ); +C_ASSERT( sizeof(w32_HTML_ComboNeedsPaint_t().unWide) >= 4 ); +C_ASSERT( offsetof(w32_HTML_ComboNeedsPaint_t, unTall) == 12 ); +C_ASSERT( sizeof(w32_HTML_ComboNeedsPaint_t().unTall) >= 4 ); + +C_ASSERT( sizeof(u32_HTML_ComboNeedsPaint_t) >= 16 ); +C_ASSERT( offsetof(u32_HTML_ComboNeedsPaint_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u32_HTML_ComboNeedsPaint_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u32_HTML_ComboNeedsPaint_t, pBGRA) == 4 ); +C_ASSERT( sizeof(u32_HTML_ComboNeedsPaint_t().pBGRA) >= 4 ); +C_ASSERT( offsetof(u32_HTML_ComboNeedsPaint_t, unWide) == 8 ); +C_ASSERT( sizeof(u32_HTML_ComboNeedsPaint_t().unWide) >= 4 ); +C_ASSERT( offsetof(u32_HTML_ComboNeedsPaint_t, unTall) == 12 ); +C_ASSERT( sizeof(u32_HTML_ComboNeedsPaint_t().unTall) >= 4 ); + +C_ASSERT( sizeof(w64_HTML_FileOpenDialog_t) >= 24 ); +C_ASSERT( offsetof(w64_HTML_FileOpenDialog_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w64_HTML_FileOpenDialog_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w64_HTML_FileOpenDialog_t, pchTitle) == 8 ); +C_ASSERT( sizeof(w64_HTML_FileOpenDialog_t().pchTitle) >= 8 ); +C_ASSERT( offsetof(w64_HTML_FileOpenDialog_t, pchInitialFile) == 16 ); +C_ASSERT( sizeof(w64_HTML_FileOpenDialog_t().pchInitialFile) >= 8 ); + +C_ASSERT( sizeof(u64_HTML_FileOpenDialog_t) >= 20 ); +C_ASSERT( offsetof(u64_HTML_FileOpenDialog_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u64_HTML_FileOpenDialog_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u64_HTML_FileOpenDialog_t, pchTitle) == 4 ); +C_ASSERT( sizeof(u64_HTML_FileOpenDialog_t().pchTitle) >= 8 ); +C_ASSERT( offsetof(u64_HTML_FileOpenDialog_t, pchInitialFile) == 12 ); +C_ASSERT( sizeof(u64_HTML_FileOpenDialog_t().pchInitialFile) >= 8 ); + +C_ASSERT( sizeof(w32_HTML_FileOpenDialog_t) >= 12 ); +C_ASSERT( offsetof(w32_HTML_FileOpenDialog_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w32_HTML_FileOpenDialog_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w32_HTML_FileOpenDialog_t, pchTitle) == 4 ); +C_ASSERT( sizeof(w32_HTML_FileOpenDialog_t().pchTitle) >= 4 ); +C_ASSERT( offsetof(w32_HTML_FileOpenDialog_t, pchInitialFile) == 8 ); +C_ASSERT( sizeof(w32_HTML_FileOpenDialog_t().pchInitialFile) >= 4 ); + +C_ASSERT( sizeof(u32_HTML_FileOpenDialog_t) >= 12 ); +C_ASSERT( offsetof(u32_HTML_FileOpenDialog_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u32_HTML_FileOpenDialog_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u32_HTML_FileOpenDialog_t, pchTitle) == 4 ); +C_ASSERT( sizeof(u32_HTML_FileOpenDialog_t().pchTitle) >= 4 ); +C_ASSERT( offsetof(u32_HTML_FileOpenDialog_t, pchInitialFile) == 8 ); +C_ASSERT( sizeof(u32_HTML_FileOpenDialog_t().pchInitialFile) >= 4 ); + +C_ASSERT( sizeof(w64_HTML_FinishedRequest_t) >= 24 ); +C_ASSERT( offsetof(w64_HTML_FinishedRequest_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w64_HTML_FinishedRequest_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w64_HTML_FinishedRequest_t, pchURL) == 8 ); +C_ASSERT( sizeof(w64_HTML_FinishedRequest_t().pchURL) >= 8 ); +C_ASSERT( offsetof(w64_HTML_FinishedRequest_t, pchPageTitle) == 16 ); +C_ASSERT( sizeof(w64_HTML_FinishedRequest_t().pchPageTitle) >= 8 ); + +C_ASSERT( sizeof(u64_HTML_FinishedRequest_t) >= 20 ); +C_ASSERT( offsetof(u64_HTML_FinishedRequest_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u64_HTML_FinishedRequest_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u64_HTML_FinishedRequest_t, pchURL) == 4 ); +C_ASSERT( sizeof(u64_HTML_FinishedRequest_t().pchURL) >= 8 ); +C_ASSERT( offsetof(u64_HTML_FinishedRequest_t, pchPageTitle) == 12 ); +C_ASSERT( sizeof(u64_HTML_FinishedRequest_t().pchPageTitle) >= 8 ); + +C_ASSERT( sizeof(w32_HTML_FinishedRequest_t) >= 12 ); +C_ASSERT( offsetof(w32_HTML_FinishedRequest_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w32_HTML_FinishedRequest_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w32_HTML_FinishedRequest_t, pchURL) == 4 ); +C_ASSERT( sizeof(w32_HTML_FinishedRequest_t().pchURL) >= 4 ); +C_ASSERT( offsetof(w32_HTML_FinishedRequest_t, pchPageTitle) == 8 ); +C_ASSERT( sizeof(w32_HTML_FinishedRequest_t().pchPageTitle) >= 4 ); + +C_ASSERT( sizeof(u32_HTML_FinishedRequest_t) >= 12 ); +C_ASSERT( offsetof(u32_HTML_FinishedRequest_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u32_HTML_FinishedRequest_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u32_HTML_FinishedRequest_t, pchURL) == 4 ); +C_ASSERT( sizeof(u32_HTML_FinishedRequest_t().pchURL) >= 4 ); +C_ASSERT( offsetof(u32_HTML_FinishedRequest_t, pchPageTitle) == 8 ); +C_ASSERT( sizeof(u32_HTML_FinishedRequest_t().pchPageTitle) >= 4 ); + +C_ASSERT( sizeof(w64_HTML_JSAlert_t) >= 16 ); +C_ASSERT( offsetof(w64_HTML_JSAlert_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w64_HTML_JSAlert_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w64_HTML_JSAlert_t, pchMessage) == 8 ); +C_ASSERT( sizeof(w64_HTML_JSAlert_t().pchMessage) >= 8 ); + +C_ASSERT( sizeof(u64_HTML_JSAlert_t) >= 12 ); +C_ASSERT( offsetof(u64_HTML_JSAlert_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u64_HTML_JSAlert_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u64_HTML_JSAlert_t, pchMessage) == 4 ); +C_ASSERT( sizeof(u64_HTML_JSAlert_t().pchMessage) >= 8 ); + +C_ASSERT( sizeof(w32_HTML_JSAlert_t) >= 8 ); +C_ASSERT( offsetof(w32_HTML_JSAlert_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w32_HTML_JSAlert_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w32_HTML_JSAlert_t, pchMessage) == 4 ); +C_ASSERT( sizeof(w32_HTML_JSAlert_t().pchMessage) >= 4 ); + +C_ASSERT( sizeof(u32_HTML_JSAlert_t) >= 8 ); +C_ASSERT( offsetof(u32_HTML_JSAlert_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u32_HTML_JSAlert_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u32_HTML_JSAlert_t, pchMessage) == 4 ); +C_ASSERT( sizeof(u32_HTML_JSAlert_t().pchMessage) >= 4 ); + +C_ASSERT( sizeof(w64_HTML_JSConfirm_t) >= 16 ); +C_ASSERT( offsetof(w64_HTML_JSConfirm_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w64_HTML_JSConfirm_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w64_HTML_JSConfirm_t, pchMessage) == 8 ); +C_ASSERT( sizeof(w64_HTML_JSConfirm_t().pchMessage) >= 8 ); + +C_ASSERT( sizeof(u64_HTML_JSConfirm_t) >= 12 ); +C_ASSERT( offsetof(u64_HTML_JSConfirm_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u64_HTML_JSConfirm_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u64_HTML_JSConfirm_t, pchMessage) == 4 ); +C_ASSERT( sizeof(u64_HTML_JSConfirm_t().pchMessage) >= 8 ); + +C_ASSERT( sizeof(w32_HTML_JSConfirm_t) >= 8 ); +C_ASSERT( offsetof(w32_HTML_JSConfirm_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w32_HTML_JSConfirm_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w32_HTML_JSConfirm_t, pchMessage) == 4 ); +C_ASSERT( sizeof(w32_HTML_JSConfirm_t().pchMessage) >= 4 ); + +C_ASSERT( sizeof(u32_HTML_JSConfirm_t) >= 8 ); +C_ASSERT( offsetof(u32_HTML_JSConfirm_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u32_HTML_JSConfirm_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u32_HTML_JSConfirm_t, pchMessage) == 4 ); +C_ASSERT( sizeof(u32_HTML_JSConfirm_t().pchMessage) >= 4 ); + +C_ASSERT( sizeof(w64_HTML_LinkAtPosition_t) >= 32 ); +C_ASSERT( offsetof(w64_HTML_LinkAtPosition_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w64_HTML_LinkAtPosition_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w64_HTML_LinkAtPosition_t, x) == 4 ); +C_ASSERT( sizeof(w64_HTML_LinkAtPosition_t().x) >= 4 ); +C_ASSERT( offsetof(w64_HTML_LinkAtPosition_t, y) == 8 ); +C_ASSERT( sizeof(w64_HTML_LinkAtPosition_t().y) >= 4 ); +C_ASSERT( offsetof(w64_HTML_LinkAtPosition_t, pchURL) == 16 ); +C_ASSERT( sizeof(w64_HTML_LinkAtPosition_t().pchURL) >= 8 ); +C_ASSERT( offsetof(w64_HTML_LinkAtPosition_t, bInput) == 24 ); +C_ASSERT( sizeof(w64_HTML_LinkAtPosition_t().bInput) >= 1 ); +C_ASSERT( offsetof(w64_HTML_LinkAtPosition_t, bLiveLink) == 25 ); +C_ASSERT( sizeof(w64_HTML_LinkAtPosition_t().bLiveLink) >= 1 ); + +C_ASSERT( sizeof(u64_HTML_LinkAtPosition_t) >= 24 ); +C_ASSERT( offsetof(u64_HTML_LinkAtPosition_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u64_HTML_LinkAtPosition_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u64_HTML_LinkAtPosition_t, x) == 4 ); +C_ASSERT( sizeof(u64_HTML_LinkAtPosition_t().x) >= 4 ); +C_ASSERT( offsetof(u64_HTML_LinkAtPosition_t, y) == 8 ); +C_ASSERT( sizeof(u64_HTML_LinkAtPosition_t().y) >= 4 ); +C_ASSERT( offsetof(u64_HTML_LinkAtPosition_t, pchURL) == 12 ); +C_ASSERT( sizeof(u64_HTML_LinkAtPosition_t().pchURL) >= 8 ); +C_ASSERT( offsetof(u64_HTML_LinkAtPosition_t, bInput) == 20 ); +C_ASSERT( sizeof(u64_HTML_LinkAtPosition_t().bInput) >= 1 ); +C_ASSERT( offsetof(u64_HTML_LinkAtPosition_t, bLiveLink) == 21 ); +C_ASSERT( sizeof(u64_HTML_LinkAtPosition_t().bLiveLink) >= 1 ); + +C_ASSERT( sizeof(w32_HTML_LinkAtPosition_t) >= 20 ); +C_ASSERT( offsetof(w32_HTML_LinkAtPosition_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w32_HTML_LinkAtPosition_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w32_HTML_LinkAtPosition_t, x) == 4 ); +C_ASSERT( sizeof(w32_HTML_LinkAtPosition_t().x) >= 4 ); +C_ASSERT( offsetof(w32_HTML_LinkAtPosition_t, y) == 8 ); +C_ASSERT( sizeof(w32_HTML_LinkAtPosition_t().y) >= 4 ); +C_ASSERT( offsetof(w32_HTML_LinkAtPosition_t, pchURL) == 12 ); +C_ASSERT( sizeof(w32_HTML_LinkAtPosition_t().pchURL) >= 4 ); +C_ASSERT( offsetof(w32_HTML_LinkAtPosition_t, bInput) == 16 ); +C_ASSERT( sizeof(w32_HTML_LinkAtPosition_t().bInput) >= 1 ); +C_ASSERT( offsetof(w32_HTML_LinkAtPosition_t, bLiveLink) == 17 ); +C_ASSERT( sizeof(w32_HTML_LinkAtPosition_t().bLiveLink) >= 1 ); + +C_ASSERT( sizeof(u32_HTML_LinkAtPosition_t) >= 20 ); +C_ASSERT( offsetof(u32_HTML_LinkAtPosition_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u32_HTML_LinkAtPosition_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u32_HTML_LinkAtPosition_t, x) == 4 ); +C_ASSERT( sizeof(u32_HTML_LinkAtPosition_t().x) >= 4 ); +C_ASSERT( offsetof(u32_HTML_LinkAtPosition_t, y) == 8 ); +C_ASSERT( sizeof(u32_HTML_LinkAtPosition_t().y) >= 4 ); +C_ASSERT( offsetof(u32_HTML_LinkAtPosition_t, pchURL) == 12 ); +C_ASSERT( sizeof(u32_HTML_LinkAtPosition_t().pchURL) >= 4 ); +C_ASSERT( offsetof(u32_HTML_LinkAtPosition_t, bInput) == 16 ); +C_ASSERT( sizeof(u32_HTML_LinkAtPosition_t().bInput) >= 1 ); +C_ASSERT( offsetof(u32_HTML_LinkAtPosition_t, bLiveLink) == 17 ); +C_ASSERT( sizeof(u32_HTML_LinkAtPosition_t().bLiveLink) >= 1 ); + +C_ASSERT( sizeof(w64_HTML_NeedsPaint_t) >= 56 ); +C_ASSERT( offsetof(w64_HTML_NeedsPaint_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w64_HTML_NeedsPaint_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w64_HTML_NeedsPaint_t, pBGRA) == 8 ); +C_ASSERT( sizeof(w64_HTML_NeedsPaint_t().pBGRA) >= 8 ); +C_ASSERT( offsetof(w64_HTML_NeedsPaint_t, unWide) == 16 ); +C_ASSERT( sizeof(w64_HTML_NeedsPaint_t().unWide) >= 4 ); +C_ASSERT( offsetof(w64_HTML_NeedsPaint_t, unTall) == 20 ); +C_ASSERT( sizeof(w64_HTML_NeedsPaint_t().unTall) >= 4 ); +C_ASSERT( offsetof(w64_HTML_NeedsPaint_t, unUpdateX) == 24 ); +C_ASSERT( sizeof(w64_HTML_NeedsPaint_t().unUpdateX) >= 4 ); +C_ASSERT( offsetof(w64_HTML_NeedsPaint_t, unUpdateY) == 28 ); +C_ASSERT( sizeof(w64_HTML_NeedsPaint_t().unUpdateY) >= 4 ); +C_ASSERT( offsetof(w64_HTML_NeedsPaint_t, unUpdateWide) == 32 ); +C_ASSERT( sizeof(w64_HTML_NeedsPaint_t().unUpdateWide) >= 4 ); +C_ASSERT( offsetof(w64_HTML_NeedsPaint_t, unUpdateTall) == 36 ); +C_ASSERT( sizeof(w64_HTML_NeedsPaint_t().unUpdateTall) >= 4 ); +C_ASSERT( offsetof(w64_HTML_NeedsPaint_t, unScrollX) == 40 ); +C_ASSERT( sizeof(w64_HTML_NeedsPaint_t().unScrollX) >= 4 ); +C_ASSERT( offsetof(w64_HTML_NeedsPaint_t, unScrollY) == 44 ); +C_ASSERT( sizeof(w64_HTML_NeedsPaint_t().unScrollY) >= 4 ); +C_ASSERT( offsetof(w64_HTML_NeedsPaint_t, flPageScale) == 48 ); +C_ASSERT( sizeof(w64_HTML_NeedsPaint_t().flPageScale) >= 4 ); +C_ASSERT( offsetof(w64_HTML_NeedsPaint_t, unPageSerial) == 52 ); +C_ASSERT( sizeof(w64_HTML_NeedsPaint_t().unPageSerial) >= 4 ); + +C_ASSERT( sizeof(u64_HTML_NeedsPaint_t) >= 52 ); +C_ASSERT( offsetof(u64_HTML_NeedsPaint_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u64_HTML_NeedsPaint_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u64_HTML_NeedsPaint_t, pBGRA) == 4 ); +C_ASSERT( sizeof(u64_HTML_NeedsPaint_t().pBGRA) >= 8 ); +C_ASSERT( offsetof(u64_HTML_NeedsPaint_t, unWide) == 12 ); +C_ASSERT( sizeof(u64_HTML_NeedsPaint_t().unWide) >= 4 ); +C_ASSERT( offsetof(u64_HTML_NeedsPaint_t, unTall) == 16 ); +C_ASSERT( sizeof(u64_HTML_NeedsPaint_t().unTall) >= 4 ); +C_ASSERT( offsetof(u64_HTML_NeedsPaint_t, unUpdateX) == 20 ); +C_ASSERT( sizeof(u64_HTML_NeedsPaint_t().unUpdateX) >= 4 ); +C_ASSERT( offsetof(u64_HTML_NeedsPaint_t, unUpdateY) == 24 ); +C_ASSERT( sizeof(u64_HTML_NeedsPaint_t().unUpdateY) >= 4 ); +C_ASSERT( offsetof(u64_HTML_NeedsPaint_t, unUpdateWide) == 28 ); +C_ASSERT( sizeof(u64_HTML_NeedsPaint_t().unUpdateWide) >= 4 ); +C_ASSERT( offsetof(u64_HTML_NeedsPaint_t, unUpdateTall) == 32 ); +C_ASSERT( sizeof(u64_HTML_NeedsPaint_t().unUpdateTall) >= 4 ); +C_ASSERT( offsetof(u64_HTML_NeedsPaint_t, unScrollX) == 36 ); +C_ASSERT( sizeof(u64_HTML_NeedsPaint_t().unScrollX) >= 4 ); +C_ASSERT( offsetof(u64_HTML_NeedsPaint_t, unScrollY) == 40 ); +C_ASSERT( sizeof(u64_HTML_NeedsPaint_t().unScrollY) >= 4 ); +C_ASSERT( offsetof(u64_HTML_NeedsPaint_t, flPageScale) == 44 ); +C_ASSERT( sizeof(u64_HTML_NeedsPaint_t().flPageScale) >= 4 ); +C_ASSERT( offsetof(u64_HTML_NeedsPaint_t, unPageSerial) == 48 ); +C_ASSERT( sizeof(u64_HTML_NeedsPaint_t().unPageSerial) >= 4 ); + +C_ASSERT( sizeof(w32_HTML_NeedsPaint_t) >= 48 ); +C_ASSERT( offsetof(w32_HTML_NeedsPaint_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w32_HTML_NeedsPaint_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NeedsPaint_t, pBGRA) == 4 ); +C_ASSERT( sizeof(w32_HTML_NeedsPaint_t().pBGRA) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NeedsPaint_t, unWide) == 8 ); +C_ASSERT( sizeof(w32_HTML_NeedsPaint_t().unWide) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NeedsPaint_t, unTall) == 12 ); +C_ASSERT( sizeof(w32_HTML_NeedsPaint_t().unTall) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NeedsPaint_t, unUpdateX) == 16 ); +C_ASSERT( sizeof(w32_HTML_NeedsPaint_t().unUpdateX) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NeedsPaint_t, unUpdateY) == 20 ); +C_ASSERT( sizeof(w32_HTML_NeedsPaint_t().unUpdateY) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NeedsPaint_t, unUpdateWide) == 24 ); +C_ASSERT( sizeof(w32_HTML_NeedsPaint_t().unUpdateWide) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NeedsPaint_t, unUpdateTall) == 28 ); +C_ASSERT( sizeof(w32_HTML_NeedsPaint_t().unUpdateTall) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NeedsPaint_t, unScrollX) == 32 ); +C_ASSERT( sizeof(w32_HTML_NeedsPaint_t().unScrollX) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NeedsPaint_t, unScrollY) == 36 ); +C_ASSERT( sizeof(w32_HTML_NeedsPaint_t().unScrollY) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NeedsPaint_t, flPageScale) == 40 ); +C_ASSERT( sizeof(w32_HTML_NeedsPaint_t().flPageScale) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NeedsPaint_t, unPageSerial) == 44 ); +C_ASSERT( sizeof(w32_HTML_NeedsPaint_t().unPageSerial) >= 4 ); + +C_ASSERT( sizeof(u32_HTML_NeedsPaint_t) >= 48 ); +C_ASSERT( offsetof(u32_HTML_NeedsPaint_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u32_HTML_NeedsPaint_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NeedsPaint_t, pBGRA) == 4 ); +C_ASSERT( sizeof(u32_HTML_NeedsPaint_t().pBGRA) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NeedsPaint_t, unWide) == 8 ); +C_ASSERT( sizeof(u32_HTML_NeedsPaint_t().unWide) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NeedsPaint_t, unTall) == 12 ); +C_ASSERT( sizeof(u32_HTML_NeedsPaint_t().unTall) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NeedsPaint_t, unUpdateX) == 16 ); +C_ASSERT( sizeof(u32_HTML_NeedsPaint_t().unUpdateX) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NeedsPaint_t, unUpdateY) == 20 ); +C_ASSERT( sizeof(u32_HTML_NeedsPaint_t().unUpdateY) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NeedsPaint_t, unUpdateWide) == 24 ); +C_ASSERT( sizeof(u32_HTML_NeedsPaint_t().unUpdateWide) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NeedsPaint_t, unUpdateTall) == 28 ); +C_ASSERT( sizeof(u32_HTML_NeedsPaint_t().unUpdateTall) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NeedsPaint_t, unScrollX) == 32 ); +C_ASSERT( sizeof(u32_HTML_NeedsPaint_t().unScrollX) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NeedsPaint_t, unScrollY) == 36 ); +C_ASSERT( sizeof(u32_HTML_NeedsPaint_t().unScrollY) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NeedsPaint_t, flPageScale) == 40 ); +C_ASSERT( sizeof(u32_HTML_NeedsPaint_t().flPageScale) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NeedsPaint_t, unPageSerial) == 44 ); +C_ASSERT( sizeof(u32_HTML_NeedsPaint_t().unPageSerial) >= 4 ); + +C_ASSERT( sizeof(w64_HTML_NewWindow_t_132x) >= 40 ); +C_ASSERT( offsetof(w64_HTML_NewWindow_t_132x, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w64_HTML_NewWindow_t_132x().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w64_HTML_NewWindow_t_132x, pchURL) == 8 ); +C_ASSERT( sizeof(w64_HTML_NewWindow_t_132x().pchURL) >= 8 ); +C_ASSERT( offsetof(w64_HTML_NewWindow_t_132x, unX) == 16 ); +C_ASSERT( sizeof(w64_HTML_NewWindow_t_132x().unX) >= 4 ); +C_ASSERT( offsetof(w64_HTML_NewWindow_t_132x, unY) == 20 ); +C_ASSERT( sizeof(w64_HTML_NewWindow_t_132x().unY) >= 4 ); +C_ASSERT( offsetof(w64_HTML_NewWindow_t_132x, unWide) == 24 ); +C_ASSERT( sizeof(w64_HTML_NewWindow_t_132x().unWide) >= 4 ); +C_ASSERT( offsetof(w64_HTML_NewWindow_t_132x, unTall) == 28 ); +C_ASSERT( sizeof(w64_HTML_NewWindow_t_132x().unTall) >= 4 ); +C_ASSERT( offsetof(w64_HTML_NewWindow_t_132x, unNewWindow_BrowserHandle_IGNORE) == 32 ); +C_ASSERT( sizeof(w64_HTML_NewWindow_t_132x().unNewWindow_BrowserHandle_IGNORE) >= 4 ); + +C_ASSERT( sizeof(u64_HTML_NewWindow_t_132x) >= 32 ); +C_ASSERT( offsetof(u64_HTML_NewWindow_t_132x, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u64_HTML_NewWindow_t_132x().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u64_HTML_NewWindow_t_132x, pchURL) == 4 ); +C_ASSERT( sizeof(u64_HTML_NewWindow_t_132x().pchURL) >= 8 ); +C_ASSERT( offsetof(u64_HTML_NewWindow_t_132x, unX) == 12 ); +C_ASSERT( sizeof(u64_HTML_NewWindow_t_132x().unX) >= 4 ); +C_ASSERT( offsetof(u64_HTML_NewWindow_t_132x, unY) == 16 ); +C_ASSERT( sizeof(u64_HTML_NewWindow_t_132x().unY) >= 4 ); +C_ASSERT( offsetof(u64_HTML_NewWindow_t_132x, unWide) == 20 ); +C_ASSERT( sizeof(u64_HTML_NewWindow_t_132x().unWide) >= 4 ); +C_ASSERT( offsetof(u64_HTML_NewWindow_t_132x, unTall) == 24 ); +C_ASSERT( sizeof(u64_HTML_NewWindow_t_132x().unTall) >= 4 ); +C_ASSERT( offsetof(u64_HTML_NewWindow_t_132x, unNewWindow_BrowserHandle_IGNORE) == 28 ); +C_ASSERT( sizeof(u64_HTML_NewWindow_t_132x().unNewWindow_BrowserHandle_IGNORE) >= 4 ); + +C_ASSERT( sizeof(w32_HTML_NewWindow_t_132x) >= 28 ); +C_ASSERT( offsetof(w32_HTML_NewWindow_t_132x, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w32_HTML_NewWindow_t_132x().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NewWindow_t_132x, pchURL) == 4 ); +C_ASSERT( sizeof(w32_HTML_NewWindow_t_132x().pchURL) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NewWindow_t_132x, unX) == 8 ); +C_ASSERT( sizeof(w32_HTML_NewWindow_t_132x().unX) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NewWindow_t_132x, unY) == 12 ); +C_ASSERT( sizeof(w32_HTML_NewWindow_t_132x().unY) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NewWindow_t_132x, unWide) == 16 ); +C_ASSERT( sizeof(w32_HTML_NewWindow_t_132x().unWide) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NewWindow_t_132x, unTall) == 20 ); +C_ASSERT( sizeof(w32_HTML_NewWindow_t_132x().unTall) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NewWindow_t_132x, unNewWindow_BrowserHandle_IGNORE) == 24 ); +C_ASSERT( sizeof(w32_HTML_NewWindow_t_132x().unNewWindow_BrowserHandle_IGNORE) >= 4 ); + +C_ASSERT( sizeof(u32_HTML_NewWindow_t_132x) >= 28 ); +C_ASSERT( offsetof(u32_HTML_NewWindow_t_132x, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u32_HTML_NewWindow_t_132x().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NewWindow_t_132x, pchURL) == 4 ); +C_ASSERT( sizeof(u32_HTML_NewWindow_t_132x().pchURL) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NewWindow_t_132x, unX) == 8 ); +C_ASSERT( sizeof(u32_HTML_NewWindow_t_132x().unX) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NewWindow_t_132x, unY) == 12 ); +C_ASSERT( sizeof(u32_HTML_NewWindow_t_132x().unY) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NewWindow_t_132x, unWide) == 16 ); +C_ASSERT( sizeof(u32_HTML_NewWindow_t_132x().unWide) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NewWindow_t_132x, unTall) == 20 ); +C_ASSERT( sizeof(u32_HTML_NewWindow_t_132x().unTall) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NewWindow_t_132x, unNewWindow_BrowserHandle_IGNORE) == 24 ); +C_ASSERT( sizeof(u32_HTML_NewWindow_t_132x().unNewWindow_BrowserHandle_IGNORE) >= 4 ); + +C_ASSERT( sizeof(w64_HTML_NewWindow_t_130x) >= 32 ); +C_ASSERT( offsetof(w64_HTML_NewWindow_t_130x, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w64_HTML_NewWindow_t_130x().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w64_HTML_NewWindow_t_130x, pchURL) == 8 ); +C_ASSERT( sizeof(w64_HTML_NewWindow_t_130x().pchURL) >= 8 ); +C_ASSERT( offsetof(w64_HTML_NewWindow_t_130x, unX) == 16 ); +C_ASSERT( sizeof(w64_HTML_NewWindow_t_130x().unX) >= 4 ); +C_ASSERT( offsetof(w64_HTML_NewWindow_t_130x, unY) == 20 ); +C_ASSERT( sizeof(w64_HTML_NewWindow_t_130x().unY) >= 4 ); +C_ASSERT( offsetof(w64_HTML_NewWindow_t_130x, unWide) == 24 ); +C_ASSERT( sizeof(w64_HTML_NewWindow_t_130x().unWide) >= 4 ); +C_ASSERT( offsetof(w64_HTML_NewWindow_t_130x, unTall) == 28 ); +C_ASSERT( sizeof(w64_HTML_NewWindow_t_130x().unTall) >= 4 ); + +C_ASSERT( sizeof(u64_HTML_NewWindow_t_130x) >= 28 ); +C_ASSERT( offsetof(u64_HTML_NewWindow_t_130x, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u64_HTML_NewWindow_t_130x().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u64_HTML_NewWindow_t_130x, pchURL) == 4 ); +C_ASSERT( sizeof(u64_HTML_NewWindow_t_130x().pchURL) >= 8 ); +C_ASSERT( offsetof(u64_HTML_NewWindow_t_130x, unX) == 12 ); +C_ASSERT( sizeof(u64_HTML_NewWindow_t_130x().unX) >= 4 ); +C_ASSERT( offsetof(u64_HTML_NewWindow_t_130x, unY) == 16 ); +C_ASSERT( sizeof(u64_HTML_NewWindow_t_130x().unY) >= 4 ); +C_ASSERT( offsetof(u64_HTML_NewWindow_t_130x, unWide) == 20 ); +C_ASSERT( sizeof(u64_HTML_NewWindow_t_130x().unWide) >= 4 ); +C_ASSERT( offsetof(u64_HTML_NewWindow_t_130x, unTall) == 24 ); +C_ASSERT( sizeof(u64_HTML_NewWindow_t_130x().unTall) >= 4 ); + +C_ASSERT( sizeof(w32_HTML_NewWindow_t_130x) >= 24 ); +C_ASSERT( offsetof(w32_HTML_NewWindow_t_130x, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w32_HTML_NewWindow_t_130x().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NewWindow_t_130x, pchURL) == 4 ); +C_ASSERT( sizeof(w32_HTML_NewWindow_t_130x().pchURL) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NewWindow_t_130x, unX) == 8 ); +C_ASSERT( sizeof(w32_HTML_NewWindow_t_130x().unX) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NewWindow_t_130x, unY) == 12 ); +C_ASSERT( sizeof(w32_HTML_NewWindow_t_130x().unY) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NewWindow_t_130x, unWide) == 16 ); +C_ASSERT( sizeof(w32_HTML_NewWindow_t_130x().unWide) >= 4 ); +C_ASSERT( offsetof(w32_HTML_NewWindow_t_130x, unTall) == 20 ); +C_ASSERT( sizeof(w32_HTML_NewWindow_t_130x().unTall) >= 4 ); + +C_ASSERT( sizeof(u32_HTML_NewWindow_t_130x) >= 24 ); +C_ASSERT( offsetof(u32_HTML_NewWindow_t_130x, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u32_HTML_NewWindow_t_130x().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NewWindow_t_130x, pchURL) == 4 ); +C_ASSERT( sizeof(u32_HTML_NewWindow_t_130x().pchURL) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NewWindow_t_130x, unX) == 8 ); +C_ASSERT( sizeof(u32_HTML_NewWindow_t_130x().unX) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NewWindow_t_130x, unY) == 12 ); +C_ASSERT( sizeof(u32_HTML_NewWindow_t_130x().unY) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NewWindow_t_130x, unWide) == 16 ); +C_ASSERT( sizeof(u32_HTML_NewWindow_t_130x().unWide) >= 4 ); +C_ASSERT( offsetof(u32_HTML_NewWindow_t_130x, unTall) == 20 ); +C_ASSERT( sizeof(u32_HTML_NewWindow_t_130x().unTall) >= 4 ); + +C_ASSERT( sizeof(w64_HTML_OpenLinkInNewTab_t) >= 16 ); +C_ASSERT( offsetof(w64_HTML_OpenLinkInNewTab_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w64_HTML_OpenLinkInNewTab_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w64_HTML_OpenLinkInNewTab_t, pchURL) == 8 ); +C_ASSERT( sizeof(w64_HTML_OpenLinkInNewTab_t().pchURL) >= 8 ); + +C_ASSERT( sizeof(u64_HTML_OpenLinkInNewTab_t) >= 12 ); +C_ASSERT( offsetof(u64_HTML_OpenLinkInNewTab_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u64_HTML_OpenLinkInNewTab_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u64_HTML_OpenLinkInNewTab_t, pchURL) == 4 ); +C_ASSERT( sizeof(u64_HTML_OpenLinkInNewTab_t().pchURL) >= 8 ); + +C_ASSERT( sizeof(w32_HTML_OpenLinkInNewTab_t) >= 8 ); +C_ASSERT( offsetof(w32_HTML_OpenLinkInNewTab_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w32_HTML_OpenLinkInNewTab_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w32_HTML_OpenLinkInNewTab_t, pchURL) == 4 ); +C_ASSERT( sizeof(w32_HTML_OpenLinkInNewTab_t().pchURL) >= 4 ); + +C_ASSERT( sizeof(u32_HTML_OpenLinkInNewTab_t) >= 8 ); +C_ASSERT( offsetof(u32_HTML_OpenLinkInNewTab_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u32_HTML_OpenLinkInNewTab_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u32_HTML_OpenLinkInNewTab_t, pchURL) == 4 ); +C_ASSERT( sizeof(u32_HTML_OpenLinkInNewTab_t().pchURL) >= 4 ); + +C_ASSERT( sizeof(w64_HTML_ShowToolTip_t) >= 16 ); +C_ASSERT( offsetof(w64_HTML_ShowToolTip_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w64_HTML_ShowToolTip_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w64_HTML_ShowToolTip_t, pchMsg) == 8 ); +C_ASSERT( sizeof(w64_HTML_ShowToolTip_t().pchMsg) >= 8 ); + +C_ASSERT( sizeof(u64_HTML_ShowToolTip_t) >= 12 ); +C_ASSERT( offsetof(u64_HTML_ShowToolTip_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u64_HTML_ShowToolTip_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u64_HTML_ShowToolTip_t, pchMsg) == 4 ); +C_ASSERT( sizeof(u64_HTML_ShowToolTip_t().pchMsg) >= 8 ); + +C_ASSERT( sizeof(w32_HTML_ShowToolTip_t) >= 8 ); +C_ASSERT( offsetof(w32_HTML_ShowToolTip_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w32_HTML_ShowToolTip_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w32_HTML_ShowToolTip_t, pchMsg) == 4 ); +C_ASSERT( sizeof(w32_HTML_ShowToolTip_t().pchMsg) >= 4 ); + +C_ASSERT( sizeof(u32_HTML_ShowToolTip_t) >= 8 ); +C_ASSERT( offsetof(u32_HTML_ShowToolTip_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u32_HTML_ShowToolTip_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u32_HTML_ShowToolTip_t, pchMsg) == 4 ); +C_ASSERT( sizeof(u32_HTML_ShowToolTip_t().pchMsg) >= 4 ); + +C_ASSERT( sizeof(w64_HTML_StartRequest_t) >= 40 ); +C_ASSERT( offsetof(w64_HTML_StartRequest_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w64_HTML_StartRequest_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w64_HTML_StartRequest_t, pchURL) == 8 ); +C_ASSERT( sizeof(w64_HTML_StartRequest_t().pchURL) >= 8 ); +C_ASSERT( offsetof(w64_HTML_StartRequest_t, pchTarget) == 16 ); +C_ASSERT( sizeof(w64_HTML_StartRequest_t().pchTarget) >= 8 ); +C_ASSERT( offsetof(w64_HTML_StartRequest_t, pchPostData) == 24 ); +C_ASSERT( sizeof(w64_HTML_StartRequest_t().pchPostData) >= 8 ); +C_ASSERT( offsetof(w64_HTML_StartRequest_t, bIsRedirect) == 32 ); +C_ASSERT( sizeof(w64_HTML_StartRequest_t().bIsRedirect) >= 1 ); + +C_ASSERT( sizeof(u64_HTML_StartRequest_t) >= 32 ); +C_ASSERT( offsetof(u64_HTML_StartRequest_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u64_HTML_StartRequest_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u64_HTML_StartRequest_t, pchURL) == 4 ); +C_ASSERT( sizeof(u64_HTML_StartRequest_t().pchURL) >= 8 ); +C_ASSERT( offsetof(u64_HTML_StartRequest_t, pchTarget) == 12 ); +C_ASSERT( sizeof(u64_HTML_StartRequest_t().pchTarget) >= 8 ); +C_ASSERT( offsetof(u64_HTML_StartRequest_t, pchPostData) == 20 ); +C_ASSERT( sizeof(u64_HTML_StartRequest_t().pchPostData) >= 8 ); +C_ASSERT( offsetof(u64_HTML_StartRequest_t, bIsRedirect) == 28 ); +C_ASSERT( sizeof(u64_HTML_StartRequest_t().bIsRedirect) >= 1 ); + +C_ASSERT( sizeof(w32_HTML_StartRequest_t) >= 20 ); +C_ASSERT( offsetof(w32_HTML_StartRequest_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w32_HTML_StartRequest_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w32_HTML_StartRequest_t, pchURL) == 4 ); +C_ASSERT( sizeof(w32_HTML_StartRequest_t().pchURL) >= 4 ); +C_ASSERT( offsetof(w32_HTML_StartRequest_t, pchTarget) == 8 ); +C_ASSERT( sizeof(w32_HTML_StartRequest_t().pchTarget) >= 4 ); +C_ASSERT( offsetof(w32_HTML_StartRequest_t, pchPostData) == 12 ); +C_ASSERT( sizeof(w32_HTML_StartRequest_t().pchPostData) >= 4 ); +C_ASSERT( offsetof(w32_HTML_StartRequest_t, bIsRedirect) == 16 ); +C_ASSERT( sizeof(w32_HTML_StartRequest_t().bIsRedirect) >= 1 ); + +C_ASSERT( sizeof(u32_HTML_StartRequest_t) >= 20 ); +C_ASSERT( offsetof(u32_HTML_StartRequest_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u32_HTML_StartRequest_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u32_HTML_StartRequest_t, pchURL) == 4 ); +C_ASSERT( sizeof(u32_HTML_StartRequest_t().pchURL) >= 4 ); +C_ASSERT( offsetof(u32_HTML_StartRequest_t, pchTarget) == 8 ); +C_ASSERT( sizeof(u32_HTML_StartRequest_t().pchTarget) >= 4 ); +C_ASSERT( offsetof(u32_HTML_StartRequest_t, pchPostData) == 12 ); +C_ASSERT( sizeof(u32_HTML_StartRequest_t().pchPostData) >= 4 ); +C_ASSERT( offsetof(u32_HTML_StartRequest_t, bIsRedirect) == 16 ); +C_ASSERT( sizeof(u32_HTML_StartRequest_t().bIsRedirect) >= 1 ); + +C_ASSERT( sizeof(w64_HTML_StatusText_t) >= 16 ); +C_ASSERT( offsetof(w64_HTML_StatusText_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w64_HTML_StatusText_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w64_HTML_StatusText_t, pchMsg) == 8 ); +C_ASSERT( sizeof(w64_HTML_StatusText_t().pchMsg) >= 8 ); + +C_ASSERT( sizeof(u64_HTML_StatusText_t) >= 12 ); +C_ASSERT( offsetof(u64_HTML_StatusText_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u64_HTML_StatusText_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u64_HTML_StatusText_t, pchMsg) == 4 ); +C_ASSERT( sizeof(u64_HTML_StatusText_t().pchMsg) >= 8 ); + +C_ASSERT( sizeof(w32_HTML_StatusText_t) >= 8 ); +C_ASSERT( offsetof(w32_HTML_StatusText_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w32_HTML_StatusText_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w32_HTML_StatusText_t, pchMsg) == 4 ); +C_ASSERT( sizeof(w32_HTML_StatusText_t().pchMsg) >= 4 ); + +C_ASSERT( sizeof(u32_HTML_StatusText_t) >= 8 ); +C_ASSERT( offsetof(u32_HTML_StatusText_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u32_HTML_StatusText_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u32_HTML_StatusText_t, pchMsg) == 4 ); +C_ASSERT( sizeof(u32_HTML_StatusText_t().pchMsg) >= 4 ); + +C_ASSERT( sizeof(w64_HTML_URLChanged_t) >= 48 ); +C_ASSERT( offsetof(w64_HTML_URLChanged_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w64_HTML_URLChanged_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w64_HTML_URLChanged_t, pchURL) == 8 ); +C_ASSERT( sizeof(w64_HTML_URLChanged_t().pchURL) >= 8 ); +C_ASSERT( offsetof(w64_HTML_URLChanged_t, pchPostData) == 16 ); +C_ASSERT( sizeof(w64_HTML_URLChanged_t().pchPostData) >= 8 ); +C_ASSERT( offsetof(w64_HTML_URLChanged_t, bIsRedirect) == 24 ); +C_ASSERT( sizeof(w64_HTML_URLChanged_t().bIsRedirect) >= 1 ); +C_ASSERT( offsetof(w64_HTML_URLChanged_t, pchPageTitle) == 32 ); +C_ASSERT( sizeof(w64_HTML_URLChanged_t().pchPageTitle) >= 8 ); +C_ASSERT( offsetof(w64_HTML_URLChanged_t, bNewNavigation) == 40 ); +C_ASSERT( sizeof(w64_HTML_URLChanged_t().bNewNavigation) >= 1 ); + +C_ASSERT( sizeof(u64_HTML_URLChanged_t) >= 36 ); +C_ASSERT( offsetof(u64_HTML_URLChanged_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u64_HTML_URLChanged_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u64_HTML_URLChanged_t, pchURL) == 4 ); +C_ASSERT( sizeof(u64_HTML_URLChanged_t().pchURL) >= 8 ); +C_ASSERT( offsetof(u64_HTML_URLChanged_t, pchPostData) == 12 ); +C_ASSERT( sizeof(u64_HTML_URLChanged_t().pchPostData) >= 8 ); +C_ASSERT( offsetof(u64_HTML_URLChanged_t, bIsRedirect) == 20 ); +C_ASSERT( sizeof(u64_HTML_URLChanged_t().bIsRedirect) >= 1 ); +C_ASSERT( offsetof(u64_HTML_URLChanged_t, pchPageTitle) == 24 ); +C_ASSERT( sizeof(u64_HTML_URLChanged_t().pchPageTitle) >= 8 ); +C_ASSERT( offsetof(u64_HTML_URLChanged_t, bNewNavigation) == 32 ); +C_ASSERT( sizeof(u64_HTML_URLChanged_t().bNewNavigation) >= 1 ); + +C_ASSERT( sizeof(w32_HTML_URLChanged_t) >= 24 ); +C_ASSERT( offsetof(w32_HTML_URLChanged_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w32_HTML_URLChanged_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w32_HTML_URLChanged_t, pchURL) == 4 ); +C_ASSERT( sizeof(w32_HTML_URLChanged_t().pchURL) >= 4 ); +C_ASSERT( offsetof(w32_HTML_URLChanged_t, pchPostData) == 8 ); +C_ASSERT( sizeof(w32_HTML_URLChanged_t().pchPostData) >= 4 ); +C_ASSERT( offsetof(w32_HTML_URLChanged_t, bIsRedirect) == 12 ); +C_ASSERT( sizeof(w32_HTML_URLChanged_t().bIsRedirect) >= 1 ); +C_ASSERT( offsetof(w32_HTML_URLChanged_t, pchPageTitle) == 16 ); +C_ASSERT( sizeof(w32_HTML_URLChanged_t().pchPageTitle) >= 4 ); +C_ASSERT( offsetof(w32_HTML_URLChanged_t, bNewNavigation) == 20 ); +C_ASSERT( sizeof(w32_HTML_URLChanged_t().bNewNavigation) >= 1 ); + +C_ASSERT( sizeof(u32_HTML_URLChanged_t) >= 24 ); +C_ASSERT( offsetof(u32_HTML_URLChanged_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u32_HTML_URLChanged_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u32_HTML_URLChanged_t, pchURL) == 4 ); +C_ASSERT( sizeof(u32_HTML_URLChanged_t().pchURL) >= 4 ); +C_ASSERT( offsetof(u32_HTML_URLChanged_t, pchPostData) == 8 ); +C_ASSERT( sizeof(u32_HTML_URLChanged_t().pchPostData) >= 4 ); +C_ASSERT( offsetof(u32_HTML_URLChanged_t, bIsRedirect) == 12 ); +C_ASSERT( sizeof(u32_HTML_URLChanged_t().bIsRedirect) >= 1 ); +C_ASSERT( offsetof(u32_HTML_URLChanged_t, pchPageTitle) == 16 ); +C_ASSERT( sizeof(u32_HTML_URLChanged_t().pchPageTitle) >= 4 ); +C_ASSERT( offsetof(u32_HTML_URLChanged_t, bNewNavigation) == 20 ); +C_ASSERT( sizeof(u32_HTML_URLChanged_t().bNewNavigation) >= 1 ); + +C_ASSERT( sizeof(w64_HTML_UpdateToolTip_t) >= 16 ); +C_ASSERT( offsetof(w64_HTML_UpdateToolTip_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w64_HTML_UpdateToolTip_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w64_HTML_UpdateToolTip_t, pchMsg) == 8 ); +C_ASSERT( sizeof(w64_HTML_UpdateToolTip_t().pchMsg) >= 8 ); + +C_ASSERT( sizeof(u64_HTML_UpdateToolTip_t) >= 12 ); +C_ASSERT( offsetof(u64_HTML_UpdateToolTip_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u64_HTML_UpdateToolTip_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u64_HTML_UpdateToolTip_t, pchMsg) == 4 ); +C_ASSERT( sizeof(u64_HTML_UpdateToolTip_t().pchMsg) >= 8 ); + +C_ASSERT( sizeof(w32_HTML_UpdateToolTip_t) >= 8 ); +C_ASSERT( offsetof(w32_HTML_UpdateToolTip_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(w32_HTML_UpdateToolTip_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(w32_HTML_UpdateToolTip_t, pchMsg) == 4 ); +C_ASSERT( sizeof(w32_HTML_UpdateToolTip_t().pchMsg) >= 4 ); + +C_ASSERT( sizeof(u32_HTML_UpdateToolTip_t) >= 8 ); +C_ASSERT( offsetof(u32_HTML_UpdateToolTip_t, unBrowserHandle) == 0 ); +C_ASSERT( sizeof(u32_HTML_UpdateToolTip_t().unBrowserHandle) >= 4 ); +C_ASSERT( offsetof(u32_HTML_UpdateToolTip_t, pchMsg) == 4 ); +C_ASSERT( sizeof(u32_HTML_UpdateToolTip_t().pchMsg) >= 4 ); + +C_ASSERT( sizeof(w64_HTTPRequestCompleted_t_132x) >= 32 ); +C_ASSERT( offsetof(w64_HTTPRequestCompleted_t_132x, m_hRequest) == 0 ); +C_ASSERT( sizeof(w64_HTTPRequestCompleted_t_132x().m_hRequest) >= 4 ); +C_ASSERT( offsetof(w64_HTTPRequestCompleted_t_132x, m_ulContextValue) == 8 ); +C_ASSERT( sizeof(w64_HTTPRequestCompleted_t_132x().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(w64_HTTPRequestCompleted_t_132x, m_bRequestSuccessful) == 16 ); +C_ASSERT( sizeof(w64_HTTPRequestCompleted_t_132x().m_bRequestSuccessful) >= 1 ); +C_ASSERT( offsetof(w64_HTTPRequestCompleted_t_132x, m_eStatusCode) == 20 ); +C_ASSERT( sizeof(w64_HTTPRequestCompleted_t_132x().m_eStatusCode) >= 4 ); +C_ASSERT( offsetof(w64_HTTPRequestCompleted_t_132x, m_unBodySize) == 24 ); +C_ASSERT( sizeof(w64_HTTPRequestCompleted_t_132x().m_unBodySize) >= 4 ); + +C_ASSERT( sizeof(u64_HTTPRequestCompleted_t_132x) >= 24 ); +C_ASSERT( offsetof(u64_HTTPRequestCompleted_t_132x, m_hRequest) == 0 ); +C_ASSERT( sizeof(u64_HTTPRequestCompleted_t_132x().m_hRequest) >= 4 ); +C_ASSERT( offsetof(u64_HTTPRequestCompleted_t_132x, m_ulContextValue) == 4 ); +C_ASSERT( sizeof(u64_HTTPRequestCompleted_t_132x().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(u64_HTTPRequestCompleted_t_132x, m_bRequestSuccessful) == 12 ); +C_ASSERT( sizeof(u64_HTTPRequestCompleted_t_132x().m_bRequestSuccessful) >= 1 ); +C_ASSERT( offsetof(u64_HTTPRequestCompleted_t_132x, m_eStatusCode) == 16 ); +C_ASSERT( sizeof(u64_HTTPRequestCompleted_t_132x().m_eStatusCode) >= 4 ); +C_ASSERT( offsetof(u64_HTTPRequestCompleted_t_132x, m_unBodySize) == 20 ); +C_ASSERT( sizeof(u64_HTTPRequestCompleted_t_132x().m_unBodySize) >= 4 ); + +C_ASSERT( sizeof(w32_HTTPRequestCompleted_t_132x) >= 32 ); +C_ASSERT( offsetof(w32_HTTPRequestCompleted_t_132x, m_hRequest) == 0 ); +C_ASSERT( sizeof(w32_HTTPRequestCompleted_t_132x().m_hRequest) >= 4 ); +C_ASSERT( offsetof(w32_HTTPRequestCompleted_t_132x, m_ulContextValue) == 8 ); +C_ASSERT( sizeof(w32_HTTPRequestCompleted_t_132x().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(w32_HTTPRequestCompleted_t_132x, m_bRequestSuccessful) == 16 ); +C_ASSERT( sizeof(w32_HTTPRequestCompleted_t_132x().m_bRequestSuccessful) >= 1 ); +C_ASSERT( offsetof(w32_HTTPRequestCompleted_t_132x, m_eStatusCode) == 20 ); +C_ASSERT( sizeof(w32_HTTPRequestCompleted_t_132x().m_eStatusCode) >= 4 ); +C_ASSERT( offsetof(w32_HTTPRequestCompleted_t_132x, m_unBodySize) == 24 ); +C_ASSERT( sizeof(w32_HTTPRequestCompleted_t_132x().m_unBodySize) >= 4 ); + +C_ASSERT( sizeof(u32_HTTPRequestCompleted_t_132x) >= 24 ); +C_ASSERT( offsetof(u32_HTTPRequestCompleted_t_132x, m_hRequest) == 0 ); +C_ASSERT( sizeof(u32_HTTPRequestCompleted_t_132x().m_hRequest) >= 4 ); +C_ASSERT( offsetof(u32_HTTPRequestCompleted_t_132x, m_ulContextValue) == 4 ); +C_ASSERT( sizeof(u32_HTTPRequestCompleted_t_132x().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(u32_HTTPRequestCompleted_t_132x, m_bRequestSuccessful) == 12 ); +C_ASSERT( sizeof(u32_HTTPRequestCompleted_t_132x().m_bRequestSuccessful) >= 1 ); +C_ASSERT( offsetof(u32_HTTPRequestCompleted_t_132x, m_eStatusCode) == 16 ); +C_ASSERT( sizeof(u32_HTTPRequestCompleted_t_132x().m_eStatusCode) >= 4 ); +C_ASSERT( offsetof(u32_HTTPRequestCompleted_t_132x, m_unBodySize) == 20 ); +C_ASSERT( sizeof(u32_HTTPRequestCompleted_t_132x().m_unBodySize) >= 4 ); + +C_ASSERT( sizeof(w64_HTTPRequestCompleted_t_123) >= 24 ); +C_ASSERT( offsetof(w64_HTTPRequestCompleted_t_123, m_hRequest) == 0 ); +C_ASSERT( sizeof(w64_HTTPRequestCompleted_t_123().m_hRequest) >= 4 ); +C_ASSERT( offsetof(w64_HTTPRequestCompleted_t_123, m_ulContextValue) == 8 ); +C_ASSERT( sizeof(w64_HTTPRequestCompleted_t_123().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(w64_HTTPRequestCompleted_t_123, m_bRequestSuccessful) == 16 ); +C_ASSERT( sizeof(w64_HTTPRequestCompleted_t_123().m_bRequestSuccessful) >= 1 ); +C_ASSERT( offsetof(w64_HTTPRequestCompleted_t_123, m_eStatusCode) == 20 ); +C_ASSERT( sizeof(w64_HTTPRequestCompleted_t_123().m_eStatusCode) >= 4 ); + +C_ASSERT( sizeof(u64_HTTPRequestCompleted_t_123) >= 20 ); +C_ASSERT( offsetof(u64_HTTPRequestCompleted_t_123, m_hRequest) == 0 ); +C_ASSERT( sizeof(u64_HTTPRequestCompleted_t_123().m_hRequest) >= 4 ); +C_ASSERT( offsetof(u64_HTTPRequestCompleted_t_123, m_ulContextValue) == 4 ); +C_ASSERT( sizeof(u64_HTTPRequestCompleted_t_123().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(u64_HTTPRequestCompleted_t_123, m_bRequestSuccessful) == 12 ); +C_ASSERT( sizeof(u64_HTTPRequestCompleted_t_123().m_bRequestSuccessful) >= 1 ); +C_ASSERT( offsetof(u64_HTTPRequestCompleted_t_123, m_eStatusCode) == 16 ); +C_ASSERT( sizeof(u64_HTTPRequestCompleted_t_123().m_eStatusCode) >= 4 ); + +C_ASSERT( sizeof(w32_HTTPRequestCompleted_t_123) >= 24 ); +C_ASSERT( offsetof(w32_HTTPRequestCompleted_t_123, m_hRequest) == 0 ); +C_ASSERT( sizeof(w32_HTTPRequestCompleted_t_123().m_hRequest) >= 4 ); +C_ASSERT( offsetof(w32_HTTPRequestCompleted_t_123, m_ulContextValue) == 8 ); +C_ASSERT( sizeof(w32_HTTPRequestCompleted_t_123().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(w32_HTTPRequestCompleted_t_123, m_bRequestSuccessful) == 16 ); +C_ASSERT( sizeof(w32_HTTPRequestCompleted_t_123().m_bRequestSuccessful) >= 1 ); +C_ASSERT( offsetof(w32_HTTPRequestCompleted_t_123, m_eStatusCode) == 20 ); +C_ASSERT( sizeof(w32_HTTPRequestCompleted_t_123().m_eStatusCode) >= 4 ); + +C_ASSERT( sizeof(u32_HTTPRequestCompleted_t_123) >= 20 ); +C_ASSERT( offsetof(u32_HTTPRequestCompleted_t_123, m_hRequest) == 0 ); +C_ASSERT( sizeof(u32_HTTPRequestCompleted_t_123().m_hRequest) >= 4 ); +C_ASSERT( offsetof(u32_HTTPRequestCompleted_t_123, m_ulContextValue) == 4 ); +C_ASSERT( sizeof(u32_HTTPRequestCompleted_t_123().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(u32_HTTPRequestCompleted_t_123, m_bRequestSuccessful) == 12 ); +C_ASSERT( sizeof(u32_HTTPRequestCompleted_t_123().m_bRequestSuccessful) >= 1 ); +C_ASSERT( offsetof(u32_HTTPRequestCompleted_t_123, m_eStatusCode) == 16 ); +C_ASSERT( sizeof(u32_HTTPRequestCompleted_t_123().m_eStatusCode) >= 4 ); + +C_ASSERT( sizeof(w64_HTTPRequestCompleted_t_115) >= 24 ); +C_ASSERT( offsetof(w64_HTTPRequestCompleted_t_115, m_hRequest) == 0 ); +C_ASSERT( sizeof(w64_HTTPRequestCompleted_t_115().m_hRequest) >= 4 ); +C_ASSERT( offsetof(w64_HTTPRequestCompleted_t_115, m_ulContextValue) == 8 ); +C_ASSERT( sizeof(w64_HTTPRequestCompleted_t_115().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(w64_HTTPRequestCompleted_t_115, m_bRequestSuccessful) == 16 ); +C_ASSERT( sizeof(w64_HTTPRequestCompleted_t_115().m_bRequestSuccessful) >= 1 ); +C_ASSERT( offsetof(w64_HTTPRequestCompleted_t_115, m_eStatusCode) == 20 ); +C_ASSERT( sizeof(w64_HTTPRequestCompleted_t_115().m_eStatusCode) >= 4 ); + +C_ASSERT( sizeof(u64_HTTPRequestCompleted_t_115) >= 24 ); +C_ASSERT( offsetof(u64_HTTPRequestCompleted_t_115, m_hRequest) == 0 ); +C_ASSERT( sizeof(u64_HTTPRequestCompleted_t_115().m_hRequest) >= 4 ); +C_ASSERT( offsetof(u64_HTTPRequestCompleted_t_115, m_ulContextValue) == 8 ); +C_ASSERT( sizeof(u64_HTTPRequestCompleted_t_115().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(u64_HTTPRequestCompleted_t_115, m_bRequestSuccessful) == 16 ); +C_ASSERT( sizeof(u64_HTTPRequestCompleted_t_115().m_bRequestSuccessful) >= 1 ); +C_ASSERT( offsetof(u64_HTTPRequestCompleted_t_115, m_eStatusCode) == 20 ); +C_ASSERT( sizeof(u64_HTTPRequestCompleted_t_115().m_eStatusCode) >= 4 ); + +C_ASSERT( sizeof(w32_HTTPRequestCompleted_t_115) >= 24 ); +C_ASSERT( offsetof(w32_HTTPRequestCompleted_t_115, m_hRequest) == 0 ); +C_ASSERT( sizeof(w32_HTTPRequestCompleted_t_115().m_hRequest) >= 4 ); +C_ASSERT( offsetof(w32_HTTPRequestCompleted_t_115, m_ulContextValue) == 8 ); +C_ASSERT( sizeof(w32_HTTPRequestCompleted_t_115().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(w32_HTTPRequestCompleted_t_115, m_bRequestSuccessful) == 16 ); +C_ASSERT( sizeof(w32_HTTPRequestCompleted_t_115().m_bRequestSuccessful) >= 1 ); +C_ASSERT( offsetof(w32_HTTPRequestCompleted_t_115, m_eStatusCode) == 20 ); +C_ASSERT( sizeof(w32_HTTPRequestCompleted_t_115().m_eStatusCode) >= 4 ); + +C_ASSERT( sizeof(u32_HTTPRequestCompleted_t_115) >= 20 ); +C_ASSERT( offsetof(u32_HTTPRequestCompleted_t_115, m_hRequest) == 0 ); +C_ASSERT( sizeof(u32_HTTPRequestCompleted_t_115().m_hRequest) >= 4 ); +C_ASSERT( offsetof(u32_HTTPRequestCompleted_t_115, m_ulContextValue) == 4 ); +C_ASSERT( sizeof(u32_HTTPRequestCompleted_t_115().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(u32_HTTPRequestCompleted_t_115, m_bRequestSuccessful) == 12 ); +C_ASSERT( sizeof(u32_HTTPRequestCompleted_t_115().m_bRequestSuccessful) >= 1 ); +C_ASSERT( offsetof(u32_HTTPRequestCompleted_t_115, m_eStatusCode) == 16 ); +C_ASSERT( sizeof(u32_HTTPRequestCompleted_t_115().m_eStatusCode) >= 4 ); + +C_ASSERT( sizeof(w64_HTTPRequestDataReceived_t_123) >= 24 ); +C_ASSERT( offsetof(w64_HTTPRequestDataReceived_t_123, m_hRequest) == 0 ); +C_ASSERT( sizeof(w64_HTTPRequestDataReceived_t_123().m_hRequest) >= 4 ); +C_ASSERT( offsetof(w64_HTTPRequestDataReceived_t_123, m_ulContextValue) == 8 ); +C_ASSERT( sizeof(w64_HTTPRequestDataReceived_t_123().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(w64_HTTPRequestDataReceived_t_123, m_cOffset) == 16 ); +C_ASSERT( sizeof(w64_HTTPRequestDataReceived_t_123().m_cOffset) >= 4 ); +C_ASSERT( offsetof(w64_HTTPRequestDataReceived_t_123, m_cBytesReceived) == 20 ); +C_ASSERT( sizeof(w64_HTTPRequestDataReceived_t_123().m_cBytesReceived) >= 4 ); + +C_ASSERT( sizeof(u64_HTTPRequestDataReceived_t_123) >= 20 ); +C_ASSERT( offsetof(u64_HTTPRequestDataReceived_t_123, m_hRequest) == 0 ); +C_ASSERT( sizeof(u64_HTTPRequestDataReceived_t_123().m_hRequest) >= 4 ); +C_ASSERT( offsetof(u64_HTTPRequestDataReceived_t_123, m_ulContextValue) == 4 ); +C_ASSERT( sizeof(u64_HTTPRequestDataReceived_t_123().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(u64_HTTPRequestDataReceived_t_123, m_cOffset) == 12 ); +C_ASSERT( sizeof(u64_HTTPRequestDataReceived_t_123().m_cOffset) >= 4 ); +C_ASSERT( offsetof(u64_HTTPRequestDataReceived_t_123, m_cBytesReceived) == 16 ); +C_ASSERT( sizeof(u64_HTTPRequestDataReceived_t_123().m_cBytesReceived) >= 4 ); + +C_ASSERT( sizeof(w32_HTTPRequestDataReceived_t_123) >= 24 ); +C_ASSERT( offsetof(w32_HTTPRequestDataReceived_t_123, m_hRequest) == 0 ); +C_ASSERT( sizeof(w32_HTTPRequestDataReceived_t_123().m_hRequest) >= 4 ); +C_ASSERT( offsetof(w32_HTTPRequestDataReceived_t_123, m_ulContextValue) == 8 ); +C_ASSERT( sizeof(w32_HTTPRequestDataReceived_t_123().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(w32_HTTPRequestDataReceived_t_123, m_cOffset) == 16 ); +C_ASSERT( sizeof(w32_HTTPRequestDataReceived_t_123().m_cOffset) >= 4 ); +C_ASSERT( offsetof(w32_HTTPRequestDataReceived_t_123, m_cBytesReceived) == 20 ); +C_ASSERT( sizeof(w32_HTTPRequestDataReceived_t_123().m_cBytesReceived) >= 4 ); + +C_ASSERT( sizeof(u32_HTTPRequestDataReceived_t_123) >= 20 ); +C_ASSERT( offsetof(u32_HTTPRequestDataReceived_t_123, m_hRequest) == 0 ); +C_ASSERT( sizeof(u32_HTTPRequestDataReceived_t_123().m_hRequest) >= 4 ); +C_ASSERT( offsetof(u32_HTTPRequestDataReceived_t_123, m_ulContextValue) == 4 ); +C_ASSERT( sizeof(u32_HTTPRequestDataReceived_t_123().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(u32_HTTPRequestDataReceived_t_123, m_cOffset) == 12 ); +C_ASSERT( sizeof(u32_HTTPRequestDataReceived_t_123().m_cOffset) >= 4 ); +C_ASSERT( offsetof(u32_HTTPRequestDataReceived_t_123, m_cBytesReceived) == 16 ); +C_ASSERT( sizeof(u32_HTTPRequestDataReceived_t_123().m_cBytesReceived) >= 4 ); + +C_ASSERT( sizeof(w64_HTTPRequestDataReceived_t_121x) >= 24 ); +C_ASSERT( offsetof(w64_HTTPRequestDataReceived_t_121x, m_hRequest) == 0 ); +C_ASSERT( sizeof(w64_HTTPRequestDataReceived_t_121x().m_hRequest) >= 4 ); +C_ASSERT( offsetof(w64_HTTPRequestDataReceived_t_121x, m_ulContextValue) == 8 ); +C_ASSERT( sizeof(w64_HTTPRequestDataReceived_t_121x().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(w64_HTTPRequestDataReceived_t_121x, m_cOffset) == 16 ); +C_ASSERT( sizeof(w64_HTTPRequestDataReceived_t_121x().m_cOffset) >= 4 ); +C_ASSERT( offsetof(w64_HTTPRequestDataReceived_t_121x, m_cBytesReceived) == 20 ); +C_ASSERT( sizeof(w64_HTTPRequestDataReceived_t_121x().m_cBytesReceived) >= 4 ); + +C_ASSERT( sizeof(u64_HTTPRequestDataReceived_t_121x) >= 24 ); +C_ASSERT( offsetof(u64_HTTPRequestDataReceived_t_121x, m_hRequest) == 0 ); +C_ASSERT( sizeof(u64_HTTPRequestDataReceived_t_121x().m_hRequest) >= 4 ); +C_ASSERT( offsetof(u64_HTTPRequestDataReceived_t_121x, m_ulContextValue) == 8 ); +C_ASSERT( sizeof(u64_HTTPRequestDataReceived_t_121x().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(u64_HTTPRequestDataReceived_t_121x, m_cOffset) == 16 ); +C_ASSERT( sizeof(u64_HTTPRequestDataReceived_t_121x().m_cOffset) >= 4 ); +C_ASSERT( offsetof(u64_HTTPRequestDataReceived_t_121x, m_cBytesReceived) == 20 ); +C_ASSERT( sizeof(u64_HTTPRequestDataReceived_t_121x().m_cBytesReceived) >= 4 ); + +C_ASSERT( sizeof(w32_HTTPRequestDataReceived_t_121x) >= 24 ); +C_ASSERT( offsetof(w32_HTTPRequestDataReceived_t_121x, m_hRequest) == 0 ); +C_ASSERT( sizeof(w32_HTTPRequestDataReceived_t_121x().m_hRequest) >= 4 ); +C_ASSERT( offsetof(w32_HTTPRequestDataReceived_t_121x, m_ulContextValue) == 8 ); +C_ASSERT( sizeof(w32_HTTPRequestDataReceived_t_121x().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(w32_HTTPRequestDataReceived_t_121x, m_cOffset) == 16 ); +C_ASSERT( sizeof(w32_HTTPRequestDataReceived_t_121x().m_cOffset) >= 4 ); +C_ASSERT( offsetof(w32_HTTPRequestDataReceived_t_121x, m_cBytesReceived) == 20 ); +C_ASSERT( sizeof(w32_HTTPRequestDataReceived_t_121x().m_cBytesReceived) >= 4 ); + +C_ASSERT( sizeof(u32_HTTPRequestDataReceived_t_121x) >= 20 ); +C_ASSERT( offsetof(u32_HTTPRequestDataReceived_t_121x, m_hRequest) == 0 ); +C_ASSERT( sizeof(u32_HTTPRequestDataReceived_t_121x().m_hRequest) >= 4 ); +C_ASSERT( offsetof(u32_HTTPRequestDataReceived_t_121x, m_ulContextValue) == 4 ); +C_ASSERT( sizeof(u32_HTTPRequestDataReceived_t_121x().m_ulContextValue) >= 8 ); +C_ASSERT( offsetof(u32_HTTPRequestDataReceived_t_121x, m_cOffset) == 12 ); +C_ASSERT( sizeof(u32_HTTPRequestDataReceived_t_121x().m_cOffset) >= 4 ); +C_ASSERT( offsetof(u32_HTTPRequestDataReceived_t_121x, m_cBytesReceived) == 16 ); +C_ASSERT( sizeof(u32_HTTPRequestDataReceived_t_121x().m_cBytesReceived) >= 4 ); + +C_ASSERT( sizeof(w64_HTTPRequestHeadersReceived_t_123) >= 16 ); +C_ASSERT( offsetof(w64_HTTPRequestHeadersReceived_t_123, m_hRequest) == 0 ); +C_ASSERT( sizeof(w64_HTTPRequestHeadersReceived_t_123().m_hRequest) >= 4 ); +C_ASSERT( offsetof(w64_HTTPRequestHeadersReceived_t_123, m_ulContextValue) == 8 ); +C_ASSERT( sizeof(w64_HTTPRequestHeadersReceived_t_123().m_ulContextValue) >= 8 ); + +C_ASSERT( sizeof(u64_HTTPRequestHeadersReceived_t_123) >= 12 ); +C_ASSERT( offsetof(u64_HTTPRequestHeadersReceived_t_123, m_hRequest) == 0 ); +C_ASSERT( sizeof(u64_HTTPRequestHeadersReceived_t_123().m_hRequest) >= 4 ); +C_ASSERT( offsetof(u64_HTTPRequestHeadersReceived_t_123, m_ulContextValue) == 4 ); +C_ASSERT( sizeof(u64_HTTPRequestHeadersReceived_t_123().m_ulContextValue) >= 8 ); + +C_ASSERT( sizeof(w32_HTTPRequestHeadersReceived_t_123) >= 16 ); +C_ASSERT( offsetof(w32_HTTPRequestHeadersReceived_t_123, m_hRequest) == 0 ); +C_ASSERT( sizeof(w32_HTTPRequestHeadersReceived_t_123().m_hRequest) >= 4 ); +C_ASSERT( offsetof(w32_HTTPRequestHeadersReceived_t_123, m_ulContextValue) == 8 ); +C_ASSERT( sizeof(w32_HTTPRequestHeadersReceived_t_123().m_ulContextValue) >= 8 ); + +C_ASSERT( sizeof(u32_HTTPRequestHeadersReceived_t_123) >= 12 ); +C_ASSERT( offsetof(u32_HTTPRequestHeadersReceived_t_123, m_hRequest) == 0 ); +C_ASSERT( sizeof(u32_HTTPRequestHeadersReceived_t_123().m_hRequest) >= 4 ); +C_ASSERT( offsetof(u32_HTTPRequestHeadersReceived_t_123, m_ulContextValue) == 4 ); +C_ASSERT( sizeof(u32_HTTPRequestHeadersReceived_t_123().m_ulContextValue) >= 8 ); + +C_ASSERT( sizeof(w64_HTTPRequestHeadersReceived_t_121x) >= 16 ); +C_ASSERT( offsetof(w64_HTTPRequestHeadersReceived_t_121x, m_hRequest) == 0 ); +C_ASSERT( sizeof(w64_HTTPRequestHeadersReceived_t_121x().m_hRequest) >= 4 ); +C_ASSERT( offsetof(w64_HTTPRequestHeadersReceived_t_121x, m_ulContextValue) == 8 ); +C_ASSERT( sizeof(w64_HTTPRequestHeadersReceived_t_121x().m_ulContextValue) >= 8 ); + +C_ASSERT( sizeof(u64_HTTPRequestHeadersReceived_t_121x) >= 16 ); +C_ASSERT( offsetof(u64_HTTPRequestHeadersReceived_t_121x, m_hRequest) == 0 ); +C_ASSERT( sizeof(u64_HTTPRequestHeadersReceived_t_121x().m_hRequest) >= 4 ); +C_ASSERT( offsetof(u64_HTTPRequestHeadersReceived_t_121x, m_ulContextValue) == 8 ); +C_ASSERT( sizeof(u64_HTTPRequestHeadersReceived_t_121x().m_ulContextValue) >= 8 ); + +C_ASSERT( sizeof(w32_HTTPRequestHeadersReceived_t_121x) >= 16 ); +C_ASSERT( offsetof(w32_HTTPRequestHeadersReceived_t_121x, m_hRequest) == 0 ); +C_ASSERT( sizeof(w32_HTTPRequestHeadersReceived_t_121x().m_hRequest) >= 4 ); +C_ASSERT( offsetof(w32_HTTPRequestHeadersReceived_t_121x, m_ulContextValue) == 8 ); +C_ASSERT( sizeof(w32_HTTPRequestHeadersReceived_t_121x().m_ulContextValue) >= 8 ); + +C_ASSERT( sizeof(u32_HTTPRequestHeadersReceived_t_121x) >= 12 ); +C_ASSERT( offsetof(u32_HTTPRequestHeadersReceived_t_121x, m_hRequest) == 0 ); +C_ASSERT( sizeof(u32_HTTPRequestHeadersReceived_t_121x().m_hRequest) >= 4 ); +C_ASSERT( offsetof(u32_HTTPRequestHeadersReceived_t_121x, m_ulContextValue) == 4 ); +C_ASSERT( sizeof(u32_HTTPRequestHeadersReceived_t_121x().m_ulContextValue) >= 8 ); + +C_ASSERT( sizeof(w64_ItemInstalled_t) >= 16 ); +C_ASSERT( offsetof(w64_ItemInstalled_t, m_unAppID) == 0 ); +C_ASSERT( sizeof(w64_ItemInstalled_t().m_unAppID) >= 4 ); +C_ASSERT( offsetof(w64_ItemInstalled_t, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_ItemInstalled_t().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u64_ItemInstalled_t) >= 12 ); +C_ASSERT( offsetof(u64_ItemInstalled_t, m_unAppID) == 0 ); +C_ASSERT( sizeof(u64_ItemInstalled_t().m_unAppID) >= 4 ); +C_ASSERT( offsetof(u64_ItemInstalled_t, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_ItemInstalled_t().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w32_ItemInstalled_t) >= 16 ); +C_ASSERT( offsetof(w32_ItemInstalled_t, m_unAppID) == 0 ); +C_ASSERT( sizeof(w32_ItemInstalled_t().m_unAppID) >= 4 ); +C_ASSERT( offsetof(w32_ItemInstalled_t, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_ItemInstalled_t().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u32_ItemInstalled_t) >= 12 ); +C_ASSERT( offsetof(u32_ItemInstalled_t, m_unAppID) == 0 ); +C_ASSERT( sizeof(u32_ItemInstalled_t().m_unAppID) >= 4 ); +C_ASSERT( offsetof(u32_ItemInstalled_t, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_ItemInstalled_t().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w64_JoinPartyCallback_t) >= 280 ); +C_ASSERT( offsetof(w64_JoinPartyCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_JoinPartyCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_JoinPartyCallback_t, m_ulBeaconID) == 8 ); +C_ASSERT( sizeof(w64_JoinPartyCallback_t().m_ulBeaconID) >= 8 ); +C_ASSERT( offsetof(w64_JoinPartyCallback_t, m_SteamIDBeaconOwner) == 16 ); +C_ASSERT( sizeof(w64_JoinPartyCallback_t().m_SteamIDBeaconOwner) >= 8 ); +C_ASSERT( offsetof(w64_JoinPartyCallback_t, m_rgchConnectString) == 24 ); +C_ASSERT( sizeof(w64_JoinPartyCallback_t().m_rgchConnectString) >= 256 ); + +C_ASSERT( sizeof(u64_JoinPartyCallback_t) >= 276 ); +C_ASSERT( offsetof(u64_JoinPartyCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_JoinPartyCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_JoinPartyCallback_t, m_ulBeaconID) == 4 ); +C_ASSERT( sizeof(u64_JoinPartyCallback_t().m_ulBeaconID) >= 8 ); +C_ASSERT( offsetof(u64_JoinPartyCallback_t, m_SteamIDBeaconOwner) == 12 ); +C_ASSERT( sizeof(u64_JoinPartyCallback_t().m_SteamIDBeaconOwner) >= 8 ); +C_ASSERT( offsetof(u64_JoinPartyCallback_t, m_rgchConnectString) == 20 ); +C_ASSERT( sizeof(u64_JoinPartyCallback_t().m_rgchConnectString) >= 256 ); + +C_ASSERT( sizeof(w32_JoinPartyCallback_t) >= 280 ); +C_ASSERT( offsetof(w32_JoinPartyCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_JoinPartyCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_JoinPartyCallback_t, m_ulBeaconID) == 8 ); +C_ASSERT( sizeof(w32_JoinPartyCallback_t().m_ulBeaconID) >= 8 ); +C_ASSERT( offsetof(w32_JoinPartyCallback_t, m_SteamIDBeaconOwner) == 16 ); +C_ASSERT( sizeof(w32_JoinPartyCallback_t().m_SteamIDBeaconOwner) >= 8 ); +C_ASSERT( offsetof(w32_JoinPartyCallback_t, m_rgchConnectString) == 24 ); +C_ASSERT( sizeof(w32_JoinPartyCallback_t().m_rgchConnectString) >= 256 ); + +C_ASSERT( sizeof(u32_JoinPartyCallback_t) >= 276 ); +C_ASSERT( offsetof(u32_JoinPartyCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_JoinPartyCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_JoinPartyCallback_t, m_ulBeaconID) == 4 ); +C_ASSERT( sizeof(u32_JoinPartyCallback_t().m_ulBeaconID) >= 8 ); +C_ASSERT( offsetof(u32_JoinPartyCallback_t, m_SteamIDBeaconOwner) == 12 ); +C_ASSERT( sizeof(u32_JoinPartyCallback_t().m_SteamIDBeaconOwner) >= 8 ); +C_ASSERT( offsetof(u32_JoinPartyCallback_t, m_rgchConnectString) == 20 ); +C_ASSERT( sizeof(u32_JoinPartyCallback_t().m_rgchConnectString) >= 256 ); + +C_ASSERT( sizeof(w64_LeaderboardEntry_t_123) >= 32 ); +C_ASSERT( offsetof(w64_LeaderboardEntry_t_123, m_steamIDUser) == 0 ); +C_ASSERT( sizeof(w64_LeaderboardEntry_t_123().m_steamIDUser) >= 8 ); +C_ASSERT( offsetof(w64_LeaderboardEntry_t_123, m_nGlobalRank) == 8 ); +C_ASSERT( sizeof(w64_LeaderboardEntry_t_123().m_nGlobalRank) >= 4 ); +C_ASSERT( offsetof(w64_LeaderboardEntry_t_123, m_nScore) == 12 ); +C_ASSERT( sizeof(w64_LeaderboardEntry_t_123().m_nScore) >= 4 ); +C_ASSERT( offsetof(w64_LeaderboardEntry_t_123, m_cDetails) == 16 ); +C_ASSERT( sizeof(w64_LeaderboardEntry_t_123().m_cDetails) >= 4 ); +C_ASSERT( offsetof(w64_LeaderboardEntry_t_123, m_hUGC) == 24 ); +C_ASSERT( sizeof(w64_LeaderboardEntry_t_123().m_hUGC) >= 8 ); + +C_ASSERT( sizeof(u64_LeaderboardEntry_t_123) >= 28 ); +C_ASSERT( offsetof(u64_LeaderboardEntry_t_123, m_steamIDUser) == 0 ); +C_ASSERT( sizeof(u64_LeaderboardEntry_t_123().m_steamIDUser) >= 8 ); +C_ASSERT( offsetof(u64_LeaderboardEntry_t_123, m_nGlobalRank) == 8 ); +C_ASSERT( sizeof(u64_LeaderboardEntry_t_123().m_nGlobalRank) >= 4 ); +C_ASSERT( offsetof(u64_LeaderboardEntry_t_123, m_nScore) == 12 ); +C_ASSERT( sizeof(u64_LeaderboardEntry_t_123().m_nScore) >= 4 ); +C_ASSERT( offsetof(u64_LeaderboardEntry_t_123, m_cDetails) == 16 ); +C_ASSERT( sizeof(u64_LeaderboardEntry_t_123().m_cDetails) >= 4 ); +C_ASSERT( offsetof(u64_LeaderboardEntry_t_123, m_hUGC) == 20 ); +C_ASSERT( sizeof(u64_LeaderboardEntry_t_123().m_hUGC) >= 8 ); + +C_ASSERT( sizeof(w32_LeaderboardEntry_t_123) >= 32 ); +C_ASSERT( offsetof(w32_LeaderboardEntry_t_123, m_steamIDUser) == 0 ); +C_ASSERT( sizeof(w32_LeaderboardEntry_t_123().m_steamIDUser) >= 8 ); +C_ASSERT( offsetof(w32_LeaderboardEntry_t_123, m_nGlobalRank) == 8 ); +C_ASSERT( sizeof(w32_LeaderboardEntry_t_123().m_nGlobalRank) >= 4 ); +C_ASSERT( offsetof(w32_LeaderboardEntry_t_123, m_nScore) == 12 ); +C_ASSERT( sizeof(w32_LeaderboardEntry_t_123().m_nScore) >= 4 ); +C_ASSERT( offsetof(w32_LeaderboardEntry_t_123, m_cDetails) == 16 ); +C_ASSERT( sizeof(w32_LeaderboardEntry_t_123().m_cDetails) >= 4 ); +C_ASSERT( offsetof(w32_LeaderboardEntry_t_123, m_hUGC) == 24 ); +C_ASSERT( sizeof(w32_LeaderboardEntry_t_123().m_hUGC) >= 8 ); + +C_ASSERT( sizeof(u32_LeaderboardEntry_t_123) >= 28 ); +C_ASSERT( offsetof(u32_LeaderboardEntry_t_123, m_steamIDUser) == 0 ); +C_ASSERT( sizeof(u32_LeaderboardEntry_t_123().m_steamIDUser) >= 8 ); +C_ASSERT( offsetof(u32_LeaderboardEntry_t_123, m_nGlobalRank) == 8 ); +C_ASSERT( sizeof(u32_LeaderboardEntry_t_123().m_nGlobalRank) >= 4 ); +C_ASSERT( offsetof(u32_LeaderboardEntry_t_123, m_nScore) == 12 ); +C_ASSERT( sizeof(u32_LeaderboardEntry_t_123().m_nScore) >= 4 ); +C_ASSERT( offsetof(u32_LeaderboardEntry_t_123, m_cDetails) == 16 ); +C_ASSERT( sizeof(u32_LeaderboardEntry_t_123().m_cDetails) >= 4 ); +C_ASSERT( offsetof(u32_LeaderboardEntry_t_123, m_hUGC) == 20 ); +C_ASSERT( sizeof(u32_LeaderboardEntry_t_123().m_hUGC) >= 8 ); + +C_ASSERT( sizeof(w64_LeaderboardEntry_t_111x) >= 32 ); +C_ASSERT( offsetof(w64_LeaderboardEntry_t_111x, m_steamIDUser) == 0 ); +C_ASSERT( sizeof(w64_LeaderboardEntry_t_111x().m_steamIDUser) >= 8 ); +C_ASSERT( offsetof(w64_LeaderboardEntry_t_111x, m_nGlobalRank) == 8 ); +C_ASSERT( sizeof(w64_LeaderboardEntry_t_111x().m_nGlobalRank) >= 4 ); +C_ASSERT( offsetof(w64_LeaderboardEntry_t_111x, m_nScore) == 12 ); +C_ASSERT( sizeof(w64_LeaderboardEntry_t_111x().m_nScore) >= 4 ); +C_ASSERT( offsetof(w64_LeaderboardEntry_t_111x, m_cDetails) == 16 ); +C_ASSERT( sizeof(w64_LeaderboardEntry_t_111x().m_cDetails) >= 4 ); +C_ASSERT( offsetof(w64_LeaderboardEntry_t_111x, m_hUGC) == 24 ); +C_ASSERT( sizeof(w64_LeaderboardEntry_t_111x().m_hUGC) >= 8 ); + +C_ASSERT( sizeof(u64_LeaderboardEntry_t_111x) >= 32 ); +C_ASSERT( offsetof(u64_LeaderboardEntry_t_111x, m_steamIDUser) == 0 ); +C_ASSERT( sizeof(u64_LeaderboardEntry_t_111x().m_steamIDUser) >= 8 ); +C_ASSERT( offsetof(u64_LeaderboardEntry_t_111x, m_nGlobalRank) == 8 ); +C_ASSERT( sizeof(u64_LeaderboardEntry_t_111x().m_nGlobalRank) >= 4 ); +C_ASSERT( offsetof(u64_LeaderboardEntry_t_111x, m_nScore) == 12 ); +C_ASSERT( sizeof(u64_LeaderboardEntry_t_111x().m_nScore) >= 4 ); +C_ASSERT( offsetof(u64_LeaderboardEntry_t_111x, m_cDetails) == 16 ); +C_ASSERT( sizeof(u64_LeaderboardEntry_t_111x().m_cDetails) >= 4 ); +C_ASSERT( offsetof(u64_LeaderboardEntry_t_111x, m_hUGC) == 24 ); +C_ASSERT( sizeof(u64_LeaderboardEntry_t_111x().m_hUGC) >= 8 ); + +C_ASSERT( sizeof(w32_LeaderboardEntry_t_111x) >= 32 ); +C_ASSERT( offsetof(w32_LeaderboardEntry_t_111x, m_steamIDUser) == 0 ); +C_ASSERT( sizeof(w32_LeaderboardEntry_t_111x().m_steamIDUser) >= 8 ); +C_ASSERT( offsetof(w32_LeaderboardEntry_t_111x, m_nGlobalRank) == 8 ); +C_ASSERT( sizeof(w32_LeaderboardEntry_t_111x().m_nGlobalRank) >= 4 ); +C_ASSERT( offsetof(w32_LeaderboardEntry_t_111x, m_nScore) == 12 ); +C_ASSERT( sizeof(w32_LeaderboardEntry_t_111x().m_nScore) >= 4 ); +C_ASSERT( offsetof(w32_LeaderboardEntry_t_111x, m_cDetails) == 16 ); +C_ASSERT( sizeof(w32_LeaderboardEntry_t_111x().m_cDetails) >= 4 ); +C_ASSERT( offsetof(w32_LeaderboardEntry_t_111x, m_hUGC) == 24 ); +C_ASSERT( sizeof(w32_LeaderboardEntry_t_111x().m_hUGC) >= 8 ); + +C_ASSERT( sizeof(u32_LeaderboardEntry_t_111x) >= 28 ); +C_ASSERT( offsetof(u32_LeaderboardEntry_t_111x, m_steamIDUser) == 0 ); +C_ASSERT( sizeof(u32_LeaderboardEntry_t_111x().m_steamIDUser) >= 8 ); +C_ASSERT( offsetof(u32_LeaderboardEntry_t_111x, m_nGlobalRank) == 8 ); +C_ASSERT( sizeof(u32_LeaderboardEntry_t_111x().m_nGlobalRank) >= 4 ); +C_ASSERT( offsetof(u32_LeaderboardEntry_t_111x, m_nScore) == 12 ); +C_ASSERT( sizeof(u32_LeaderboardEntry_t_111x().m_nScore) >= 4 ); +C_ASSERT( offsetof(u32_LeaderboardEntry_t_111x, m_cDetails) == 16 ); +C_ASSERT( sizeof(u32_LeaderboardEntry_t_111x().m_cDetails) >= 4 ); +C_ASSERT( offsetof(u32_LeaderboardEntry_t_111x, m_hUGC) == 20 ); +C_ASSERT( sizeof(u32_LeaderboardEntry_t_111x().m_hUGC) >= 8 ); + +C_ASSERT( sizeof(w64_LeaderboardEntry_t_104) >= 20 ); +C_ASSERT( offsetof(w64_LeaderboardEntry_t_104, m_steamIDUser) == 0 ); +C_ASSERT( sizeof(w64_LeaderboardEntry_t_104().m_steamIDUser) >= 8 ); +C_ASSERT( offsetof(w64_LeaderboardEntry_t_104, m_nGlobalRank) == 8 ); +C_ASSERT( sizeof(w64_LeaderboardEntry_t_104().m_nGlobalRank) >= 4 ); +C_ASSERT( offsetof(w64_LeaderboardEntry_t_104, m_nScore) == 12 ); +C_ASSERT( sizeof(w64_LeaderboardEntry_t_104().m_nScore) >= 4 ); +C_ASSERT( offsetof(w64_LeaderboardEntry_t_104, m_cDetails) == 16 ); +C_ASSERT( sizeof(w64_LeaderboardEntry_t_104().m_cDetails) >= 4 ); + +C_ASSERT( sizeof(u64_LeaderboardEntry_t_104) >= 20 ); +C_ASSERT( offsetof(u64_LeaderboardEntry_t_104, m_steamIDUser) == 0 ); +C_ASSERT( sizeof(u64_LeaderboardEntry_t_104().m_steamIDUser) >= 8 ); +C_ASSERT( offsetof(u64_LeaderboardEntry_t_104, m_nGlobalRank) == 8 ); +C_ASSERT( sizeof(u64_LeaderboardEntry_t_104().m_nGlobalRank) >= 4 ); +C_ASSERT( offsetof(u64_LeaderboardEntry_t_104, m_nScore) == 12 ); +C_ASSERT( sizeof(u64_LeaderboardEntry_t_104().m_nScore) >= 4 ); +C_ASSERT( offsetof(u64_LeaderboardEntry_t_104, m_cDetails) == 16 ); +C_ASSERT( sizeof(u64_LeaderboardEntry_t_104().m_cDetails) >= 4 ); + +C_ASSERT( sizeof(w32_LeaderboardEntry_t_104) >= 20 ); +C_ASSERT( offsetof(w32_LeaderboardEntry_t_104, m_steamIDUser) == 0 ); +C_ASSERT( sizeof(w32_LeaderboardEntry_t_104().m_steamIDUser) >= 8 ); +C_ASSERT( offsetof(w32_LeaderboardEntry_t_104, m_nGlobalRank) == 8 ); +C_ASSERT( sizeof(w32_LeaderboardEntry_t_104().m_nGlobalRank) >= 4 ); +C_ASSERT( offsetof(w32_LeaderboardEntry_t_104, m_nScore) == 12 ); +C_ASSERT( sizeof(w32_LeaderboardEntry_t_104().m_nScore) >= 4 ); +C_ASSERT( offsetof(w32_LeaderboardEntry_t_104, m_cDetails) == 16 ); +C_ASSERT( sizeof(w32_LeaderboardEntry_t_104().m_cDetails) >= 4 ); + +C_ASSERT( sizeof(u32_LeaderboardEntry_t_104) >= 20 ); +C_ASSERT( offsetof(u32_LeaderboardEntry_t_104, m_steamIDUser) == 0 ); +C_ASSERT( sizeof(u32_LeaderboardEntry_t_104().m_steamIDUser) >= 8 ); +C_ASSERT( offsetof(u32_LeaderboardEntry_t_104, m_nGlobalRank) == 8 ); +C_ASSERT( sizeof(u32_LeaderboardEntry_t_104().m_nGlobalRank) >= 4 ); +C_ASSERT( offsetof(u32_LeaderboardEntry_t_104, m_nScore) == 12 ); +C_ASSERT( sizeof(u32_LeaderboardEntry_t_104().m_nScore) >= 4 ); +C_ASSERT( offsetof(u32_LeaderboardEntry_t_104, m_cDetails) == 16 ); +C_ASSERT( sizeof(u32_LeaderboardEntry_t_104().m_cDetails) >= 4 ); + +C_ASSERT( sizeof(w64_LeaderboardScoreUploaded_t_123) >= 32 ); +C_ASSERT( offsetof(w64_LeaderboardScoreUploaded_t_123, m_bSuccess) == 0 ); +C_ASSERT( sizeof(w64_LeaderboardScoreUploaded_t_123().m_bSuccess) >= 1 ); +C_ASSERT( offsetof(w64_LeaderboardScoreUploaded_t_123, m_hSteamLeaderboard) == 8 ); +C_ASSERT( sizeof(w64_LeaderboardScoreUploaded_t_123().m_hSteamLeaderboard) >= 8 ); +C_ASSERT( offsetof(w64_LeaderboardScoreUploaded_t_123, m_nScore) == 16 ); +C_ASSERT( sizeof(w64_LeaderboardScoreUploaded_t_123().m_nScore) >= 4 ); +C_ASSERT( offsetof(w64_LeaderboardScoreUploaded_t_123, m_bScoreChanged) == 20 ); +C_ASSERT( sizeof(w64_LeaderboardScoreUploaded_t_123().m_bScoreChanged) >= 1 ); +C_ASSERT( offsetof(w64_LeaderboardScoreUploaded_t_123, m_nGlobalRankNew) == 24 ); +C_ASSERT( sizeof(w64_LeaderboardScoreUploaded_t_123().m_nGlobalRankNew) >= 4 ); +C_ASSERT( offsetof(w64_LeaderboardScoreUploaded_t_123, m_nGlobalRankPrevious) == 28 ); +C_ASSERT( sizeof(w64_LeaderboardScoreUploaded_t_123().m_nGlobalRankPrevious) >= 4 ); + +C_ASSERT( sizeof(u64_LeaderboardScoreUploaded_t_123) >= 28 ); +C_ASSERT( offsetof(u64_LeaderboardScoreUploaded_t_123, m_bSuccess) == 0 ); +C_ASSERT( sizeof(u64_LeaderboardScoreUploaded_t_123().m_bSuccess) >= 1 ); +C_ASSERT( offsetof(u64_LeaderboardScoreUploaded_t_123, m_hSteamLeaderboard) == 4 ); +C_ASSERT( sizeof(u64_LeaderboardScoreUploaded_t_123().m_hSteamLeaderboard) >= 8 ); +C_ASSERT( offsetof(u64_LeaderboardScoreUploaded_t_123, m_nScore) == 12 ); +C_ASSERT( sizeof(u64_LeaderboardScoreUploaded_t_123().m_nScore) >= 4 ); +C_ASSERT( offsetof(u64_LeaderboardScoreUploaded_t_123, m_bScoreChanged) == 16 ); +C_ASSERT( sizeof(u64_LeaderboardScoreUploaded_t_123().m_bScoreChanged) >= 1 ); +C_ASSERT( offsetof(u64_LeaderboardScoreUploaded_t_123, m_nGlobalRankNew) == 20 ); +C_ASSERT( sizeof(u64_LeaderboardScoreUploaded_t_123().m_nGlobalRankNew) >= 4 ); +C_ASSERT( offsetof(u64_LeaderboardScoreUploaded_t_123, m_nGlobalRankPrevious) == 24 ); +C_ASSERT( sizeof(u64_LeaderboardScoreUploaded_t_123().m_nGlobalRankPrevious) >= 4 ); + +C_ASSERT( sizeof(w32_LeaderboardScoreUploaded_t_123) >= 32 ); +C_ASSERT( offsetof(w32_LeaderboardScoreUploaded_t_123, m_bSuccess) == 0 ); +C_ASSERT( sizeof(w32_LeaderboardScoreUploaded_t_123().m_bSuccess) >= 1 ); +C_ASSERT( offsetof(w32_LeaderboardScoreUploaded_t_123, m_hSteamLeaderboard) == 8 ); +C_ASSERT( sizeof(w32_LeaderboardScoreUploaded_t_123().m_hSteamLeaderboard) >= 8 ); +C_ASSERT( offsetof(w32_LeaderboardScoreUploaded_t_123, m_nScore) == 16 ); +C_ASSERT( sizeof(w32_LeaderboardScoreUploaded_t_123().m_nScore) >= 4 ); +C_ASSERT( offsetof(w32_LeaderboardScoreUploaded_t_123, m_bScoreChanged) == 20 ); +C_ASSERT( sizeof(w32_LeaderboardScoreUploaded_t_123().m_bScoreChanged) >= 1 ); +C_ASSERT( offsetof(w32_LeaderboardScoreUploaded_t_123, m_nGlobalRankNew) == 24 ); +C_ASSERT( sizeof(w32_LeaderboardScoreUploaded_t_123().m_nGlobalRankNew) >= 4 ); +C_ASSERT( offsetof(w32_LeaderboardScoreUploaded_t_123, m_nGlobalRankPrevious) == 28 ); +C_ASSERT( sizeof(w32_LeaderboardScoreUploaded_t_123().m_nGlobalRankPrevious) >= 4 ); + +C_ASSERT( sizeof(u32_LeaderboardScoreUploaded_t_123) >= 28 ); +C_ASSERT( offsetof(u32_LeaderboardScoreUploaded_t_123, m_bSuccess) == 0 ); +C_ASSERT( sizeof(u32_LeaderboardScoreUploaded_t_123().m_bSuccess) >= 1 ); +C_ASSERT( offsetof(u32_LeaderboardScoreUploaded_t_123, m_hSteamLeaderboard) == 4 ); +C_ASSERT( sizeof(u32_LeaderboardScoreUploaded_t_123().m_hSteamLeaderboard) >= 8 ); +C_ASSERT( offsetof(u32_LeaderboardScoreUploaded_t_123, m_nScore) == 12 ); +C_ASSERT( sizeof(u32_LeaderboardScoreUploaded_t_123().m_nScore) >= 4 ); +C_ASSERT( offsetof(u32_LeaderboardScoreUploaded_t_123, m_bScoreChanged) == 16 ); +C_ASSERT( sizeof(u32_LeaderboardScoreUploaded_t_123().m_bScoreChanged) >= 1 ); +C_ASSERT( offsetof(u32_LeaderboardScoreUploaded_t_123, m_nGlobalRankNew) == 20 ); +C_ASSERT( sizeof(u32_LeaderboardScoreUploaded_t_123().m_nGlobalRankNew) >= 4 ); +C_ASSERT( offsetof(u32_LeaderboardScoreUploaded_t_123, m_nGlobalRankPrevious) == 24 ); +C_ASSERT( sizeof(u32_LeaderboardScoreUploaded_t_123().m_nGlobalRankPrevious) >= 4 ); + +C_ASSERT( sizeof(w64_LeaderboardScoreUploaded_t_104) >= 32 ); +C_ASSERT( offsetof(w64_LeaderboardScoreUploaded_t_104, m_bSuccess) == 0 ); +C_ASSERT( sizeof(w64_LeaderboardScoreUploaded_t_104().m_bSuccess) >= 1 ); +C_ASSERT( offsetof(w64_LeaderboardScoreUploaded_t_104, m_hSteamLeaderboard) == 8 ); +C_ASSERT( sizeof(w64_LeaderboardScoreUploaded_t_104().m_hSteamLeaderboard) >= 8 ); +C_ASSERT( offsetof(w64_LeaderboardScoreUploaded_t_104, m_nScore) == 16 ); +C_ASSERT( sizeof(w64_LeaderboardScoreUploaded_t_104().m_nScore) >= 4 ); +C_ASSERT( offsetof(w64_LeaderboardScoreUploaded_t_104, m_bScoreChanged) == 20 ); +C_ASSERT( sizeof(w64_LeaderboardScoreUploaded_t_104().m_bScoreChanged) >= 1 ); +C_ASSERT( offsetof(w64_LeaderboardScoreUploaded_t_104, m_nGlobalRankNew) == 24 ); +C_ASSERT( sizeof(w64_LeaderboardScoreUploaded_t_104().m_nGlobalRankNew) >= 4 ); +C_ASSERT( offsetof(w64_LeaderboardScoreUploaded_t_104, m_nGlobalRankPrevious) == 28 ); +C_ASSERT( sizeof(w64_LeaderboardScoreUploaded_t_104().m_nGlobalRankPrevious) >= 4 ); + +C_ASSERT( sizeof(u64_LeaderboardScoreUploaded_t_104) >= 32 ); +C_ASSERT( offsetof(u64_LeaderboardScoreUploaded_t_104, m_bSuccess) == 0 ); +C_ASSERT( sizeof(u64_LeaderboardScoreUploaded_t_104().m_bSuccess) >= 1 ); +C_ASSERT( offsetof(u64_LeaderboardScoreUploaded_t_104, m_hSteamLeaderboard) == 8 ); +C_ASSERT( sizeof(u64_LeaderboardScoreUploaded_t_104().m_hSteamLeaderboard) >= 8 ); +C_ASSERT( offsetof(u64_LeaderboardScoreUploaded_t_104, m_nScore) == 16 ); +C_ASSERT( sizeof(u64_LeaderboardScoreUploaded_t_104().m_nScore) >= 4 ); +C_ASSERT( offsetof(u64_LeaderboardScoreUploaded_t_104, m_bScoreChanged) == 20 ); +C_ASSERT( sizeof(u64_LeaderboardScoreUploaded_t_104().m_bScoreChanged) >= 1 ); +C_ASSERT( offsetof(u64_LeaderboardScoreUploaded_t_104, m_nGlobalRankNew) == 24 ); +C_ASSERT( sizeof(u64_LeaderboardScoreUploaded_t_104().m_nGlobalRankNew) >= 4 ); +C_ASSERT( offsetof(u64_LeaderboardScoreUploaded_t_104, m_nGlobalRankPrevious) == 28 ); +C_ASSERT( sizeof(u64_LeaderboardScoreUploaded_t_104().m_nGlobalRankPrevious) >= 4 ); + +C_ASSERT( sizeof(w32_LeaderboardScoreUploaded_t_104) >= 32 ); +C_ASSERT( offsetof(w32_LeaderboardScoreUploaded_t_104, m_bSuccess) == 0 ); +C_ASSERT( sizeof(w32_LeaderboardScoreUploaded_t_104().m_bSuccess) >= 1 ); +C_ASSERT( offsetof(w32_LeaderboardScoreUploaded_t_104, m_hSteamLeaderboard) == 8 ); +C_ASSERT( sizeof(w32_LeaderboardScoreUploaded_t_104().m_hSteamLeaderboard) >= 8 ); +C_ASSERT( offsetof(w32_LeaderboardScoreUploaded_t_104, m_nScore) == 16 ); +C_ASSERT( sizeof(w32_LeaderboardScoreUploaded_t_104().m_nScore) >= 4 ); +C_ASSERT( offsetof(w32_LeaderboardScoreUploaded_t_104, m_bScoreChanged) == 20 ); +C_ASSERT( sizeof(w32_LeaderboardScoreUploaded_t_104().m_bScoreChanged) >= 1 ); +C_ASSERT( offsetof(w32_LeaderboardScoreUploaded_t_104, m_nGlobalRankNew) == 24 ); +C_ASSERT( sizeof(w32_LeaderboardScoreUploaded_t_104().m_nGlobalRankNew) >= 4 ); +C_ASSERT( offsetof(w32_LeaderboardScoreUploaded_t_104, m_nGlobalRankPrevious) == 28 ); +C_ASSERT( sizeof(w32_LeaderboardScoreUploaded_t_104().m_nGlobalRankPrevious) >= 4 ); + +C_ASSERT( sizeof(u32_LeaderboardScoreUploaded_t_104) >= 28 ); +C_ASSERT( offsetof(u32_LeaderboardScoreUploaded_t_104, m_bSuccess) == 0 ); +C_ASSERT( sizeof(u32_LeaderboardScoreUploaded_t_104().m_bSuccess) >= 1 ); +C_ASSERT( offsetof(u32_LeaderboardScoreUploaded_t_104, m_hSteamLeaderboard) == 4 ); +C_ASSERT( sizeof(u32_LeaderboardScoreUploaded_t_104().m_hSteamLeaderboard) >= 8 ); +C_ASSERT( offsetof(u32_LeaderboardScoreUploaded_t_104, m_nScore) == 12 ); +C_ASSERT( sizeof(u32_LeaderboardScoreUploaded_t_104().m_nScore) >= 4 ); +C_ASSERT( offsetof(u32_LeaderboardScoreUploaded_t_104, m_bScoreChanged) == 16 ); +C_ASSERT( sizeof(u32_LeaderboardScoreUploaded_t_104().m_bScoreChanged) >= 1 ); +C_ASSERT( offsetof(u32_LeaderboardScoreUploaded_t_104, m_nGlobalRankNew) == 20 ); +C_ASSERT( sizeof(u32_LeaderboardScoreUploaded_t_104().m_nGlobalRankNew) >= 4 ); +C_ASSERT( offsetof(u32_LeaderboardScoreUploaded_t_104, m_nGlobalRankPrevious) == 24 ); +C_ASSERT( sizeof(u32_LeaderboardScoreUploaded_t_104().m_nGlobalRankPrevious) >= 4 ); + +C_ASSERT( sizeof(w64_LeaderboardUGCSet_t_123) >= 16 ); +C_ASSERT( offsetof(w64_LeaderboardUGCSet_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_LeaderboardUGCSet_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_LeaderboardUGCSet_t_123, m_hSteamLeaderboard) == 8 ); +C_ASSERT( sizeof(w64_LeaderboardUGCSet_t_123().m_hSteamLeaderboard) >= 8 ); + +C_ASSERT( sizeof(u64_LeaderboardUGCSet_t_123) >= 12 ); +C_ASSERT( offsetof(u64_LeaderboardUGCSet_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_LeaderboardUGCSet_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_LeaderboardUGCSet_t_123, m_hSteamLeaderboard) == 4 ); +C_ASSERT( sizeof(u64_LeaderboardUGCSet_t_123().m_hSteamLeaderboard) >= 8 ); + +C_ASSERT( sizeof(w32_LeaderboardUGCSet_t_123) >= 16 ); +C_ASSERT( offsetof(w32_LeaderboardUGCSet_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_LeaderboardUGCSet_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_LeaderboardUGCSet_t_123, m_hSteamLeaderboard) == 8 ); +C_ASSERT( sizeof(w32_LeaderboardUGCSet_t_123().m_hSteamLeaderboard) >= 8 ); + +C_ASSERT( sizeof(u32_LeaderboardUGCSet_t_123) >= 12 ); +C_ASSERT( offsetof(u32_LeaderboardUGCSet_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_LeaderboardUGCSet_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_LeaderboardUGCSet_t_123, m_hSteamLeaderboard) == 4 ); +C_ASSERT( sizeof(u32_LeaderboardUGCSet_t_123().m_hSteamLeaderboard) >= 8 ); + +C_ASSERT( sizeof(w64_LeaderboardUGCSet_t_111x) >= 16 ); +C_ASSERT( offsetof(w64_LeaderboardUGCSet_t_111x, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_LeaderboardUGCSet_t_111x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_LeaderboardUGCSet_t_111x, m_hSteamLeaderboard) == 8 ); +C_ASSERT( sizeof(w64_LeaderboardUGCSet_t_111x().m_hSteamLeaderboard) >= 8 ); + +C_ASSERT( sizeof(u64_LeaderboardUGCSet_t_111x) >= 16 ); +C_ASSERT( offsetof(u64_LeaderboardUGCSet_t_111x, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_LeaderboardUGCSet_t_111x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_LeaderboardUGCSet_t_111x, m_hSteamLeaderboard) == 8 ); +C_ASSERT( sizeof(u64_LeaderboardUGCSet_t_111x().m_hSteamLeaderboard) >= 8 ); + +C_ASSERT( sizeof(w32_LeaderboardUGCSet_t_111x) >= 16 ); +C_ASSERT( offsetof(w32_LeaderboardUGCSet_t_111x, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_LeaderboardUGCSet_t_111x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_LeaderboardUGCSet_t_111x, m_hSteamLeaderboard) == 8 ); +C_ASSERT( sizeof(w32_LeaderboardUGCSet_t_111x().m_hSteamLeaderboard) >= 8 ); + +C_ASSERT( sizeof(u32_LeaderboardUGCSet_t_111x) >= 12 ); +C_ASSERT( offsetof(u32_LeaderboardUGCSet_t_111x, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_LeaderboardUGCSet_t_111x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_LeaderboardUGCSet_t_111x, m_hSteamLeaderboard) == 4 ); +C_ASSERT( sizeof(u32_LeaderboardUGCSet_t_111x().m_hSteamLeaderboard) >= 8 ); + +C_ASSERT( sizeof(w64_LobbyCreated_t_123) >= 16 ); +C_ASSERT( offsetof(w64_LobbyCreated_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_LobbyCreated_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_LobbyCreated_t_123, m_ulSteamIDLobby) == 8 ); +C_ASSERT( sizeof(w64_LobbyCreated_t_123().m_ulSteamIDLobby) >= 8 ); + +C_ASSERT( sizeof(u64_LobbyCreated_t_123) >= 12 ); +C_ASSERT( offsetof(u64_LobbyCreated_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_LobbyCreated_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_LobbyCreated_t_123, m_ulSteamIDLobby) == 4 ); +C_ASSERT( sizeof(u64_LobbyCreated_t_123().m_ulSteamIDLobby) >= 8 ); + +C_ASSERT( sizeof(w32_LobbyCreated_t_123) >= 16 ); +C_ASSERT( offsetof(w32_LobbyCreated_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_LobbyCreated_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_LobbyCreated_t_123, m_ulSteamIDLobby) == 8 ); +C_ASSERT( sizeof(w32_LobbyCreated_t_123().m_ulSteamIDLobby) >= 8 ); + +C_ASSERT( sizeof(u32_LobbyCreated_t_123) >= 12 ); +C_ASSERT( offsetof(u32_LobbyCreated_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_LobbyCreated_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_LobbyCreated_t_123, m_ulSteamIDLobby) == 4 ); +C_ASSERT( sizeof(u32_LobbyCreated_t_123().m_ulSteamIDLobby) >= 8 ); + +C_ASSERT( sizeof(w64_LobbyCreated_t_099u) >= 16 ); +C_ASSERT( offsetof(w64_LobbyCreated_t_099u, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_LobbyCreated_t_099u().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_LobbyCreated_t_099u, m_ulSteamIDLobby) == 8 ); +C_ASSERT( sizeof(w64_LobbyCreated_t_099u().m_ulSteamIDLobby) >= 8 ); + +C_ASSERT( sizeof(u64_LobbyCreated_t_099u) >= 16 ); +C_ASSERT( offsetof(u64_LobbyCreated_t_099u, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_LobbyCreated_t_099u().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_LobbyCreated_t_099u, m_ulSteamIDLobby) == 8 ); +C_ASSERT( sizeof(u64_LobbyCreated_t_099u().m_ulSteamIDLobby) >= 8 ); + +C_ASSERT( sizeof(w32_LobbyCreated_t_099u) >= 16 ); +C_ASSERT( offsetof(w32_LobbyCreated_t_099u, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_LobbyCreated_t_099u().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_LobbyCreated_t_099u, m_ulSteamIDLobby) == 8 ); +C_ASSERT( sizeof(w32_LobbyCreated_t_099u().m_ulSteamIDLobby) >= 8 ); + +C_ASSERT( sizeof(u32_LobbyCreated_t_099u) >= 12 ); +C_ASSERT( offsetof(u32_LobbyCreated_t_099u, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_LobbyCreated_t_099u().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_LobbyCreated_t_099u, m_ulSteamIDLobby) == 4 ); +C_ASSERT( sizeof(u32_LobbyCreated_t_099u().m_ulSteamIDLobby) >= 8 ); + +C_ASSERT( sizeof(w64_MicroTxnAuthorizationResponse_t_123) >= 24 ); +C_ASSERT( offsetof(w64_MicroTxnAuthorizationResponse_t_123, m_unAppID) == 0 ); +C_ASSERT( sizeof(w64_MicroTxnAuthorizationResponse_t_123().m_unAppID) >= 4 ); +C_ASSERT( offsetof(w64_MicroTxnAuthorizationResponse_t_123, m_ulOrderID) == 8 ); +C_ASSERT( sizeof(w64_MicroTxnAuthorizationResponse_t_123().m_ulOrderID) >= 8 ); +C_ASSERT( offsetof(w64_MicroTxnAuthorizationResponse_t_123, m_bAuthorized) == 16 ); +C_ASSERT( sizeof(w64_MicroTxnAuthorizationResponse_t_123().m_bAuthorized) >= 1 ); + +C_ASSERT( sizeof(u64_MicroTxnAuthorizationResponse_t_123) >= 16 ); +C_ASSERT( offsetof(u64_MicroTxnAuthorizationResponse_t_123, m_unAppID) == 0 ); +C_ASSERT( sizeof(u64_MicroTxnAuthorizationResponse_t_123().m_unAppID) >= 4 ); +C_ASSERT( offsetof(u64_MicroTxnAuthorizationResponse_t_123, m_ulOrderID) == 4 ); +C_ASSERT( sizeof(u64_MicroTxnAuthorizationResponse_t_123().m_ulOrderID) >= 8 ); +C_ASSERT( offsetof(u64_MicroTxnAuthorizationResponse_t_123, m_bAuthorized) == 12 ); +C_ASSERT( sizeof(u64_MicroTxnAuthorizationResponse_t_123().m_bAuthorized) >= 1 ); + +C_ASSERT( sizeof(w32_MicroTxnAuthorizationResponse_t_123) >= 24 ); +C_ASSERT( offsetof(w32_MicroTxnAuthorizationResponse_t_123, m_unAppID) == 0 ); +C_ASSERT( sizeof(w32_MicroTxnAuthorizationResponse_t_123().m_unAppID) >= 4 ); +C_ASSERT( offsetof(w32_MicroTxnAuthorizationResponse_t_123, m_ulOrderID) == 8 ); +C_ASSERT( sizeof(w32_MicroTxnAuthorizationResponse_t_123().m_ulOrderID) >= 8 ); +C_ASSERT( offsetof(w32_MicroTxnAuthorizationResponse_t_123, m_bAuthorized) == 16 ); +C_ASSERT( sizeof(w32_MicroTxnAuthorizationResponse_t_123().m_bAuthorized) >= 1 ); + +C_ASSERT( sizeof(u32_MicroTxnAuthorizationResponse_t_123) >= 16 ); +C_ASSERT( offsetof(u32_MicroTxnAuthorizationResponse_t_123, m_unAppID) == 0 ); +C_ASSERT( sizeof(u32_MicroTxnAuthorizationResponse_t_123().m_unAppID) >= 4 ); +C_ASSERT( offsetof(u32_MicroTxnAuthorizationResponse_t_123, m_ulOrderID) == 4 ); +C_ASSERT( sizeof(u32_MicroTxnAuthorizationResponse_t_123().m_ulOrderID) >= 8 ); +C_ASSERT( offsetof(u32_MicroTxnAuthorizationResponse_t_123, m_bAuthorized) == 12 ); +C_ASSERT( sizeof(u32_MicroTxnAuthorizationResponse_t_123().m_bAuthorized) >= 1 ); + +C_ASSERT( sizeof(w64_MicroTxnAuthorizationResponse_t_109) >= 24 ); +C_ASSERT( offsetof(w64_MicroTxnAuthorizationResponse_t_109, m_unAppID) == 0 ); +C_ASSERT( sizeof(w64_MicroTxnAuthorizationResponse_t_109().m_unAppID) >= 4 ); +C_ASSERT( offsetof(w64_MicroTxnAuthorizationResponse_t_109, m_ulOrderID) == 8 ); +C_ASSERT( sizeof(w64_MicroTxnAuthorizationResponse_t_109().m_ulOrderID) >= 8 ); +C_ASSERT( offsetof(w64_MicroTxnAuthorizationResponse_t_109, m_bAuthorized) == 16 ); +C_ASSERT( sizeof(w64_MicroTxnAuthorizationResponse_t_109().m_bAuthorized) >= 1 ); + +C_ASSERT( sizeof(u64_MicroTxnAuthorizationResponse_t_109) >= 24 ); +C_ASSERT( offsetof(u64_MicroTxnAuthorizationResponse_t_109, m_unAppID) == 0 ); +C_ASSERT( sizeof(u64_MicroTxnAuthorizationResponse_t_109().m_unAppID) >= 4 ); +C_ASSERT( offsetof(u64_MicroTxnAuthorizationResponse_t_109, m_ulOrderID) == 8 ); +C_ASSERT( sizeof(u64_MicroTxnAuthorizationResponse_t_109().m_ulOrderID) >= 8 ); +C_ASSERT( offsetof(u64_MicroTxnAuthorizationResponse_t_109, m_bAuthorized) == 16 ); +C_ASSERT( sizeof(u64_MicroTxnAuthorizationResponse_t_109().m_bAuthorized) >= 1 ); + +C_ASSERT( sizeof(w32_MicroTxnAuthorizationResponse_t_109) >= 24 ); +C_ASSERT( offsetof(w32_MicroTxnAuthorizationResponse_t_109, m_unAppID) == 0 ); +C_ASSERT( sizeof(w32_MicroTxnAuthorizationResponse_t_109().m_unAppID) >= 4 ); +C_ASSERT( offsetof(w32_MicroTxnAuthorizationResponse_t_109, m_ulOrderID) == 8 ); +C_ASSERT( sizeof(w32_MicroTxnAuthorizationResponse_t_109().m_ulOrderID) >= 8 ); +C_ASSERT( offsetof(w32_MicroTxnAuthorizationResponse_t_109, m_bAuthorized) == 16 ); +C_ASSERT( sizeof(w32_MicroTxnAuthorizationResponse_t_109().m_bAuthorized) >= 1 ); + +C_ASSERT( sizeof(u32_MicroTxnAuthorizationResponse_t_109) >= 16 ); +C_ASSERT( offsetof(u32_MicroTxnAuthorizationResponse_t_109, m_unAppID) == 0 ); +C_ASSERT( sizeof(u32_MicroTxnAuthorizationResponse_t_109().m_unAppID) >= 4 ); +C_ASSERT( offsetof(u32_MicroTxnAuthorizationResponse_t_109, m_ulOrderID) == 4 ); +C_ASSERT( sizeof(u32_MicroTxnAuthorizationResponse_t_109().m_ulOrderID) >= 8 ); +C_ASSERT( offsetof(u32_MicroTxnAuthorizationResponse_t_109, m_bAuthorized) == 12 ); +C_ASSERT( sizeof(u32_MicroTxnAuthorizationResponse_t_109().m_bAuthorized) >= 1 ); + +C_ASSERT( sizeof(w64_PS3TrophiesInstalled_t_123) >= 24 ); +C_ASSERT( offsetof(w64_PS3TrophiesInstalled_t_123, m_nGameID) == 0 ); +C_ASSERT( sizeof(w64_PS3TrophiesInstalled_t_123().m_nGameID) >= 8 ); +C_ASSERT( offsetof(w64_PS3TrophiesInstalled_t_123, m_eResult) == 8 ); +C_ASSERT( sizeof(w64_PS3TrophiesInstalled_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_PS3TrophiesInstalled_t_123, m_ulRequiredDiskSpace) == 16 ); +C_ASSERT( sizeof(w64_PS3TrophiesInstalled_t_123().m_ulRequiredDiskSpace) >= 8 ); + +C_ASSERT( sizeof(u64_PS3TrophiesInstalled_t_123) >= 20 ); +C_ASSERT( offsetof(u64_PS3TrophiesInstalled_t_123, m_nGameID) == 0 ); +C_ASSERT( sizeof(u64_PS3TrophiesInstalled_t_123().m_nGameID) >= 8 ); +C_ASSERT( offsetof(u64_PS3TrophiesInstalled_t_123, m_eResult) == 8 ); +C_ASSERT( sizeof(u64_PS3TrophiesInstalled_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_PS3TrophiesInstalled_t_123, m_ulRequiredDiskSpace) == 12 ); +C_ASSERT( sizeof(u64_PS3TrophiesInstalled_t_123().m_ulRequiredDiskSpace) >= 8 ); + +C_ASSERT( sizeof(w32_PS3TrophiesInstalled_t_123) >= 24 ); +C_ASSERT( offsetof(w32_PS3TrophiesInstalled_t_123, m_nGameID) == 0 ); +C_ASSERT( sizeof(w32_PS3TrophiesInstalled_t_123().m_nGameID) >= 8 ); +C_ASSERT( offsetof(w32_PS3TrophiesInstalled_t_123, m_eResult) == 8 ); +C_ASSERT( sizeof(w32_PS3TrophiesInstalled_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_PS3TrophiesInstalled_t_123, m_ulRequiredDiskSpace) == 16 ); +C_ASSERT( sizeof(w32_PS3TrophiesInstalled_t_123().m_ulRequiredDiskSpace) >= 8 ); + +C_ASSERT( sizeof(u32_PS3TrophiesInstalled_t_123) >= 20 ); +C_ASSERT( offsetof(u32_PS3TrophiesInstalled_t_123, m_nGameID) == 0 ); +C_ASSERT( sizeof(u32_PS3TrophiesInstalled_t_123().m_nGameID) >= 8 ); +C_ASSERT( offsetof(u32_PS3TrophiesInstalled_t_123, m_eResult) == 8 ); +C_ASSERT( sizeof(u32_PS3TrophiesInstalled_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_PS3TrophiesInstalled_t_123, m_ulRequiredDiskSpace) == 12 ); +C_ASSERT( sizeof(u32_PS3TrophiesInstalled_t_123().m_ulRequiredDiskSpace) >= 8 ); + +C_ASSERT( sizeof(w64_PS3TrophiesInstalled_t_112x) >= 24 ); +C_ASSERT( offsetof(w64_PS3TrophiesInstalled_t_112x, m_nGameID) == 0 ); +C_ASSERT( sizeof(w64_PS3TrophiesInstalled_t_112x().m_nGameID) >= 8 ); +C_ASSERT( offsetof(w64_PS3TrophiesInstalled_t_112x, m_eResult) == 8 ); +C_ASSERT( sizeof(w64_PS3TrophiesInstalled_t_112x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_PS3TrophiesInstalled_t_112x, m_ulRequiredDiskSpace) == 16 ); +C_ASSERT( sizeof(w64_PS3TrophiesInstalled_t_112x().m_ulRequiredDiskSpace) >= 8 ); + +C_ASSERT( sizeof(u64_PS3TrophiesInstalled_t_112x) >= 24 ); +C_ASSERT( offsetof(u64_PS3TrophiesInstalled_t_112x, m_nGameID) == 0 ); +C_ASSERT( sizeof(u64_PS3TrophiesInstalled_t_112x().m_nGameID) >= 8 ); +C_ASSERT( offsetof(u64_PS3TrophiesInstalled_t_112x, m_eResult) == 8 ); +C_ASSERT( sizeof(u64_PS3TrophiesInstalled_t_112x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_PS3TrophiesInstalled_t_112x, m_ulRequiredDiskSpace) == 16 ); +C_ASSERT( sizeof(u64_PS3TrophiesInstalled_t_112x().m_ulRequiredDiskSpace) >= 8 ); + +C_ASSERT( sizeof(w32_PS3TrophiesInstalled_t_112x) >= 24 ); +C_ASSERT( offsetof(w32_PS3TrophiesInstalled_t_112x, m_nGameID) == 0 ); +C_ASSERT( sizeof(w32_PS3TrophiesInstalled_t_112x().m_nGameID) >= 8 ); +C_ASSERT( offsetof(w32_PS3TrophiesInstalled_t_112x, m_eResult) == 8 ); +C_ASSERT( sizeof(w32_PS3TrophiesInstalled_t_112x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_PS3TrophiesInstalled_t_112x, m_ulRequiredDiskSpace) == 16 ); +C_ASSERT( sizeof(w32_PS3TrophiesInstalled_t_112x().m_ulRequiredDiskSpace) >= 8 ); + +C_ASSERT( sizeof(u32_PS3TrophiesInstalled_t_112x) >= 20 ); +C_ASSERT( offsetof(u32_PS3TrophiesInstalled_t_112x, m_nGameID) == 0 ); +C_ASSERT( sizeof(u32_PS3TrophiesInstalled_t_112x().m_nGameID) >= 8 ); +C_ASSERT( offsetof(u32_PS3TrophiesInstalled_t_112x, m_eResult) == 8 ); +C_ASSERT( sizeof(u32_PS3TrophiesInstalled_t_112x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_PS3TrophiesInstalled_t_112x, m_ulRequiredDiskSpace) == 12 ); +C_ASSERT( sizeof(u32_PS3TrophiesInstalled_t_112x().m_ulRequiredDiskSpace) >= 8 ); + +C_ASSERT( sizeof(w64_RemoteStorageAppSyncProgress_t_123) >= 288 ); +C_ASSERT( offsetof(w64_RemoteStorageAppSyncProgress_t_123, m_rgchCurrentFile) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageAppSyncProgress_t_123().m_rgchCurrentFile) >= 260 ); +C_ASSERT( offsetof(w64_RemoteStorageAppSyncProgress_t_123, m_nAppID) == 260 ); +C_ASSERT( sizeof(w64_RemoteStorageAppSyncProgress_t_123().m_nAppID) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageAppSyncProgress_t_123, m_uBytesTransferredThisChunk) == 264 ); +C_ASSERT( sizeof(w64_RemoteStorageAppSyncProgress_t_123().m_uBytesTransferredThisChunk) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageAppSyncProgress_t_123, m_dAppPercentComplete) == 272 ); +C_ASSERT( sizeof(w64_RemoteStorageAppSyncProgress_t_123().m_dAppPercentComplete) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageAppSyncProgress_t_123, m_bUploading) == 280 ); +C_ASSERT( sizeof(w64_RemoteStorageAppSyncProgress_t_123().m_bUploading) >= 1 ); + +C_ASSERT( sizeof(u64_RemoteStorageAppSyncProgress_t_123) >= 280 ); +C_ASSERT( offsetof(u64_RemoteStorageAppSyncProgress_t_123, m_rgchCurrentFile) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageAppSyncProgress_t_123().m_rgchCurrentFile) >= 260 ); +C_ASSERT( offsetof(u64_RemoteStorageAppSyncProgress_t_123, m_nAppID) == 260 ); +C_ASSERT( sizeof(u64_RemoteStorageAppSyncProgress_t_123().m_nAppID) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageAppSyncProgress_t_123, m_uBytesTransferredThisChunk) == 264 ); +C_ASSERT( sizeof(u64_RemoteStorageAppSyncProgress_t_123().m_uBytesTransferredThisChunk) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageAppSyncProgress_t_123, m_dAppPercentComplete) == 268 ); +C_ASSERT( sizeof(u64_RemoteStorageAppSyncProgress_t_123().m_dAppPercentComplete) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageAppSyncProgress_t_123, m_bUploading) == 276 ); +C_ASSERT( sizeof(u64_RemoteStorageAppSyncProgress_t_123().m_bUploading) >= 1 ); + +C_ASSERT( sizeof(w32_RemoteStorageAppSyncProgress_t_123) >= 288 ); +C_ASSERT( offsetof(w32_RemoteStorageAppSyncProgress_t_123, m_rgchCurrentFile) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageAppSyncProgress_t_123().m_rgchCurrentFile) >= 260 ); +C_ASSERT( offsetof(w32_RemoteStorageAppSyncProgress_t_123, m_nAppID) == 260 ); +C_ASSERT( sizeof(w32_RemoteStorageAppSyncProgress_t_123().m_nAppID) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageAppSyncProgress_t_123, m_uBytesTransferredThisChunk) == 264 ); +C_ASSERT( sizeof(w32_RemoteStorageAppSyncProgress_t_123().m_uBytesTransferredThisChunk) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageAppSyncProgress_t_123, m_dAppPercentComplete) == 272 ); +C_ASSERT( sizeof(w32_RemoteStorageAppSyncProgress_t_123().m_dAppPercentComplete) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageAppSyncProgress_t_123, m_bUploading) == 280 ); +C_ASSERT( sizeof(w32_RemoteStorageAppSyncProgress_t_123().m_bUploading) >= 1 ); + +C_ASSERT( sizeof(u32_RemoteStorageAppSyncProgress_t_123) >= 280 ); +C_ASSERT( offsetof(u32_RemoteStorageAppSyncProgress_t_123, m_rgchCurrentFile) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageAppSyncProgress_t_123().m_rgchCurrentFile) >= 260 ); +C_ASSERT( offsetof(u32_RemoteStorageAppSyncProgress_t_123, m_nAppID) == 260 ); +C_ASSERT( sizeof(u32_RemoteStorageAppSyncProgress_t_123().m_nAppID) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageAppSyncProgress_t_123, m_uBytesTransferredThisChunk) == 264 ); +C_ASSERT( sizeof(u32_RemoteStorageAppSyncProgress_t_123().m_uBytesTransferredThisChunk) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageAppSyncProgress_t_123, m_dAppPercentComplete) == 268 ); +C_ASSERT( sizeof(u32_RemoteStorageAppSyncProgress_t_123().m_dAppPercentComplete) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageAppSyncProgress_t_123, m_bUploading) == 276 ); +C_ASSERT( sizeof(u32_RemoteStorageAppSyncProgress_t_123().m_bUploading) >= 1 ); + +C_ASSERT( sizeof(w64_RemoteStorageAppSyncProgress_t_111x) >= 288 ); +C_ASSERT( offsetof(w64_RemoteStorageAppSyncProgress_t_111x, m_rgchCurrentFile) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageAppSyncProgress_t_111x().m_rgchCurrentFile) >= 260 ); +C_ASSERT( offsetof(w64_RemoteStorageAppSyncProgress_t_111x, m_nAppID) == 260 ); +C_ASSERT( sizeof(w64_RemoteStorageAppSyncProgress_t_111x().m_nAppID) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageAppSyncProgress_t_111x, m_uBytesTransferredThisChunk) == 264 ); +C_ASSERT( sizeof(w64_RemoteStorageAppSyncProgress_t_111x().m_uBytesTransferredThisChunk) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageAppSyncProgress_t_111x, m_dAppPercentComplete) == 272 ); +C_ASSERT( sizeof(w64_RemoteStorageAppSyncProgress_t_111x().m_dAppPercentComplete) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageAppSyncProgress_t_111x, m_bUploading) == 280 ); +C_ASSERT( sizeof(w64_RemoteStorageAppSyncProgress_t_111x().m_bUploading) >= 1 ); + +C_ASSERT( sizeof(u64_RemoteStorageAppSyncProgress_t_111x) >= 288 ); +C_ASSERT( offsetof(u64_RemoteStorageAppSyncProgress_t_111x, m_rgchCurrentFile) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageAppSyncProgress_t_111x().m_rgchCurrentFile) >= 260 ); +C_ASSERT( offsetof(u64_RemoteStorageAppSyncProgress_t_111x, m_nAppID) == 260 ); +C_ASSERT( sizeof(u64_RemoteStorageAppSyncProgress_t_111x().m_nAppID) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageAppSyncProgress_t_111x, m_uBytesTransferredThisChunk) == 264 ); +C_ASSERT( sizeof(u64_RemoteStorageAppSyncProgress_t_111x().m_uBytesTransferredThisChunk) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageAppSyncProgress_t_111x, m_dAppPercentComplete) == 272 ); +C_ASSERT( sizeof(u64_RemoteStorageAppSyncProgress_t_111x().m_dAppPercentComplete) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageAppSyncProgress_t_111x, m_bUploading) == 280 ); +C_ASSERT( sizeof(u64_RemoteStorageAppSyncProgress_t_111x().m_bUploading) >= 1 ); + +C_ASSERT( sizeof(w32_RemoteStorageAppSyncProgress_t_111x) >= 288 ); +C_ASSERT( offsetof(w32_RemoteStorageAppSyncProgress_t_111x, m_rgchCurrentFile) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageAppSyncProgress_t_111x().m_rgchCurrentFile) >= 260 ); +C_ASSERT( offsetof(w32_RemoteStorageAppSyncProgress_t_111x, m_nAppID) == 260 ); +C_ASSERT( sizeof(w32_RemoteStorageAppSyncProgress_t_111x().m_nAppID) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageAppSyncProgress_t_111x, m_uBytesTransferredThisChunk) == 264 ); +C_ASSERT( sizeof(w32_RemoteStorageAppSyncProgress_t_111x().m_uBytesTransferredThisChunk) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageAppSyncProgress_t_111x, m_dAppPercentComplete) == 272 ); +C_ASSERT( sizeof(w32_RemoteStorageAppSyncProgress_t_111x().m_dAppPercentComplete) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageAppSyncProgress_t_111x, m_bUploading) == 280 ); +C_ASSERT( sizeof(w32_RemoteStorageAppSyncProgress_t_111x().m_bUploading) >= 1 ); + +C_ASSERT( sizeof(u32_RemoteStorageAppSyncProgress_t_111x) >= 280 ); +C_ASSERT( offsetof(u32_RemoteStorageAppSyncProgress_t_111x, m_rgchCurrentFile) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageAppSyncProgress_t_111x().m_rgchCurrentFile) >= 260 ); +C_ASSERT( offsetof(u32_RemoteStorageAppSyncProgress_t_111x, m_nAppID) == 260 ); +C_ASSERT( sizeof(u32_RemoteStorageAppSyncProgress_t_111x().m_nAppID) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageAppSyncProgress_t_111x, m_uBytesTransferredThisChunk) == 264 ); +C_ASSERT( sizeof(u32_RemoteStorageAppSyncProgress_t_111x().m_uBytesTransferredThisChunk) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageAppSyncProgress_t_111x, m_dAppPercentComplete) == 268 ); +C_ASSERT( sizeof(u32_RemoteStorageAppSyncProgress_t_111x().m_dAppPercentComplete) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageAppSyncProgress_t_111x, m_bUploading) == 276 ); +C_ASSERT( sizeof(u32_RemoteStorageAppSyncProgress_t_111x().m_bUploading) >= 1 ); + +C_ASSERT( sizeof(w64_RemoteStorageDeletePublishedFileResult_t_123) >= 16 ); +C_ASSERT( offsetof(w64_RemoteStorageDeletePublishedFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageDeletePublishedFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageDeletePublishedFileResult_t_123, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageDeletePublishedFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u64_RemoteStorageDeletePublishedFileResult_t_123) >= 12 ); +C_ASSERT( offsetof(u64_RemoteStorageDeletePublishedFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageDeletePublishedFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageDeletePublishedFileResult_t_123, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageDeletePublishedFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w32_RemoteStorageDeletePublishedFileResult_t_123) >= 16 ); +C_ASSERT( offsetof(w32_RemoteStorageDeletePublishedFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageDeletePublishedFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageDeletePublishedFileResult_t_123, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageDeletePublishedFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u32_RemoteStorageDeletePublishedFileResult_t_123) >= 12 ); +C_ASSERT( offsetof(u32_RemoteStorageDeletePublishedFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageDeletePublishedFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageDeletePublishedFileResult_t_123, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageDeletePublishedFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w64_RemoteStorageDeletePublishedFileResult_t_116x) >= 16 ); +C_ASSERT( offsetof(w64_RemoteStorageDeletePublishedFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageDeletePublishedFileResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageDeletePublishedFileResult_t_116x, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageDeletePublishedFileResult_t_116x().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u64_RemoteStorageDeletePublishedFileResult_t_116x) >= 16 ); +C_ASSERT( offsetof(u64_RemoteStorageDeletePublishedFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageDeletePublishedFileResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageDeletePublishedFileResult_t_116x, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageDeletePublishedFileResult_t_116x().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w32_RemoteStorageDeletePublishedFileResult_t_116x) >= 16 ); +C_ASSERT( offsetof(w32_RemoteStorageDeletePublishedFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageDeletePublishedFileResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageDeletePublishedFileResult_t_116x, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageDeletePublishedFileResult_t_116x().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u32_RemoteStorageDeletePublishedFileResult_t_116x) >= 12 ); +C_ASSERT( offsetof(u32_RemoteStorageDeletePublishedFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageDeletePublishedFileResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageDeletePublishedFileResult_t_116x, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageDeletePublishedFileResult_t_116x().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_123) >= 296 ); +C_ASSERT( offsetof(w64_RemoteStorageDownloadUGCResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageDownloadUGCResult_t_123, m_hFile) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_123().m_hFile) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageDownloadUGCResult_t_123, m_nAppID) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_123().m_nAppID) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageDownloadUGCResult_t_123, m_nSizeInBytes) == 20 ); +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_123().m_nSizeInBytes) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageDownloadUGCResult_t_123, m_pchFileName) == 24 ); +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_123().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w64_RemoteStorageDownloadUGCResult_t_123, m_ulSteamIDOwner) == 288 ); +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_123().m_ulSteamIDOwner) >= 8 ); + +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_123) >= 288 ); +C_ASSERT( offsetof(u64_RemoteStorageDownloadUGCResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageDownloadUGCResult_t_123, m_hFile) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_123().m_hFile) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageDownloadUGCResult_t_123, m_nAppID) == 12 ); +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_123().m_nAppID) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageDownloadUGCResult_t_123, m_nSizeInBytes) == 16 ); +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_123().m_nSizeInBytes) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageDownloadUGCResult_t_123, m_pchFileName) == 20 ); +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_123().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u64_RemoteStorageDownloadUGCResult_t_123, m_ulSteamIDOwner) == 280 ); +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_123().m_ulSteamIDOwner) >= 8 ); + +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_123) >= 296 ); +C_ASSERT( offsetof(w32_RemoteStorageDownloadUGCResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageDownloadUGCResult_t_123, m_hFile) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_123().m_hFile) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageDownloadUGCResult_t_123, m_nAppID) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_123().m_nAppID) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageDownloadUGCResult_t_123, m_nSizeInBytes) == 20 ); +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_123().m_nSizeInBytes) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageDownloadUGCResult_t_123, m_pchFileName) == 24 ); +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_123().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w32_RemoteStorageDownloadUGCResult_t_123, m_ulSteamIDOwner) == 288 ); +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_123().m_ulSteamIDOwner) >= 8 ); + +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_123) >= 288 ); +C_ASSERT( offsetof(u32_RemoteStorageDownloadUGCResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageDownloadUGCResult_t_123, m_hFile) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_123().m_hFile) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageDownloadUGCResult_t_123, m_nAppID) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_123().m_nAppID) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageDownloadUGCResult_t_123, m_nSizeInBytes) == 16 ); +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_123().m_nSizeInBytes) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageDownloadUGCResult_t_123, m_pchFileName) == 20 ); +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_123().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u32_RemoteStorageDownloadUGCResult_t_123, m_ulSteamIDOwner) == 280 ); +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_123().m_ulSteamIDOwner) >= 8 ); + +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_116x) >= 296 ); +C_ASSERT( offsetof(w64_RemoteStorageDownloadUGCResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageDownloadUGCResult_t_116x, m_hFile) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_116x().m_hFile) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageDownloadUGCResult_t_116x, m_nAppID) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_116x().m_nAppID) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageDownloadUGCResult_t_116x, m_nSizeInBytes) == 20 ); +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_116x().m_nSizeInBytes) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageDownloadUGCResult_t_116x, m_pchFileName) == 24 ); +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_116x().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w64_RemoteStorageDownloadUGCResult_t_116x, m_ulSteamIDOwner) == 288 ); +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_116x().m_ulSteamIDOwner) >= 8 ); + +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_116x) >= 296 ); +C_ASSERT( offsetof(u64_RemoteStorageDownloadUGCResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageDownloadUGCResult_t_116x, m_hFile) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_116x().m_hFile) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageDownloadUGCResult_t_116x, m_nAppID) == 16 ); +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_116x().m_nAppID) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageDownloadUGCResult_t_116x, m_nSizeInBytes) == 20 ); +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_116x().m_nSizeInBytes) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageDownloadUGCResult_t_116x, m_pchFileName) == 24 ); +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_116x().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u64_RemoteStorageDownloadUGCResult_t_116x, m_ulSteamIDOwner) == 288 ); +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_116x().m_ulSteamIDOwner) >= 8 ); + +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_116x) >= 296 ); +C_ASSERT( offsetof(w32_RemoteStorageDownloadUGCResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageDownloadUGCResult_t_116x, m_hFile) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_116x().m_hFile) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageDownloadUGCResult_t_116x, m_nAppID) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_116x().m_nAppID) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageDownloadUGCResult_t_116x, m_nSizeInBytes) == 20 ); +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_116x().m_nSizeInBytes) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageDownloadUGCResult_t_116x, m_pchFileName) == 24 ); +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_116x().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w32_RemoteStorageDownloadUGCResult_t_116x, m_ulSteamIDOwner) == 288 ); +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_116x().m_ulSteamIDOwner) >= 8 ); + +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_116x) >= 288 ); +C_ASSERT( offsetof(u32_RemoteStorageDownloadUGCResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageDownloadUGCResult_t_116x, m_hFile) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_116x().m_hFile) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageDownloadUGCResult_t_116x, m_nAppID) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_116x().m_nAppID) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageDownloadUGCResult_t_116x, m_nSizeInBytes) == 16 ); +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_116x().m_nSizeInBytes) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageDownloadUGCResult_t_116x, m_pchFileName) == 20 ); +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_116x().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u32_RemoteStorageDownloadUGCResult_t_116x, m_ulSteamIDOwner) == 280 ); +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_116x().m_ulSteamIDOwner) >= 8 ); + +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_111x) >= 40 ); +C_ASSERT( offsetof(w64_RemoteStorageDownloadUGCResult_t_111x, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_111x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageDownloadUGCResult_t_111x, m_hFile) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_111x().m_hFile) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageDownloadUGCResult_t_111x, m_nAppID) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_111x().m_nAppID) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageDownloadUGCResult_t_111x, m_nSizeInBytes) == 20 ); +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_111x().m_nSizeInBytes) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageDownloadUGCResult_t_111x, m_pchFileName) == 24 ); +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_111x().m_pchFileName) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageDownloadUGCResult_t_111x, m_ulSteamIDOwner) == 32 ); +C_ASSERT( sizeof(w64_RemoteStorageDownloadUGCResult_t_111x().m_ulSteamIDOwner) >= 8 ); + +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_111x) >= 40 ); +C_ASSERT( offsetof(u64_RemoteStorageDownloadUGCResult_t_111x, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_111x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageDownloadUGCResult_t_111x, m_hFile) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_111x().m_hFile) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageDownloadUGCResult_t_111x, m_nAppID) == 16 ); +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_111x().m_nAppID) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageDownloadUGCResult_t_111x, m_nSizeInBytes) == 20 ); +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_111x().m_nSizeInBytes) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageDownloadUGCResult_t_111x, m_pchFileName) == 24 ); +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_111x().m_pchFileName) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageDownloadUGCResult_t_111x, m_ulSteamIDOwner) == 32 ); +C_ASSERT( sizeof(u64_RemoteStorageDownloadUGCResult_t_111x().m_ulSteamIDOwner) >= 8 ); + +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_111x) >= 40 ); +C_ASSERT( offsetof(w32_RemoteStorageDownloadUGCResult_t_111x, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_111x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageDownloadUGCResult_t_111x, m_hFile) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_111x().m_hFile) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageDownloadUGCResult_t_111x, m_nAppID) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_111x().m_nAppID) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageDownloadUGCResult_t_111x, m_nSizeInBytes) == 20 ); +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_111x().m_nSizeInBytes) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageDownloadUGCResult_t_111x, m_pchFileName) == 24 ); +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_111x().m_pchFileName) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageDownloadUGCResult_t_111x, m_ulSteamIDOwner) == 32 ); +C_ASSERT( sizeof(w32_RemoteStorageDownloadUGCResult_t_111x().m_ulSteamIDOwner) >= 8 ); + +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_111x) >= 32 ); +C_ASSERT( offsetof(u32_RemoteStorageDownloadUGCResult_t_111x, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_111x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageDownloadUGCResult_t_111x, m_hFile) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_111x().m_hFile) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageDownloadUGCResult_t_111x, m_nAppID) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_111x().m_nAppID) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageDownloadUGCResult_t_111x, m_nSizeInBytes) == 16 ); +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_111x().m_nSizeInBytes) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageDownloadUGCResult_t_111x, m_pchFileName) == 20 ); +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_111x().m_pchFileName) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageDownloadUGCResult_t_111x, m_ulSteamIDOwner) == 24 ); +C_ASSERT( sizeof(u32_RemoteStorageDownloadUGCResult_t_111x().m_ulSteamIDOwner) >= 8 ); + +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserPublishedFilesResult_t_123) >= 416 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserPublishedFilesResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserPublishedFilesResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserPublishedFilesResult_t_123, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserPublishedFilesResult_t_123().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserPublishedFilesResult_t_123, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserPublishedFilesResult_t_123().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserPublishedFilesResult_t_123, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserPublishedFilesResult_t_123().m_rgPublishedFileId) >= 400 ); + +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserPublishedFilesResult_t_123) >= 412 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserPublishedFilesResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserPublishedFilesResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserPublishedFilesResult_t_123, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserPublishedFilesResult_t_123().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserPublishedFilesResult_t_123, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserPublishedFilesResult_t_123().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserPublishedFilesResult_t_123, m_rgPublishedFileId) == 12 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserPublishedFilesResult_t_123().m_rgPublishedFileId) >= 400 ); + +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserPublishedFilesResult_t_123) >= 416 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserPublishedFilesResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserPublishedFilesResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserPublishedFilesResult_t_123, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserPublishedFilesResult_t_123().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserPublishedFilesResult_t_123, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserPublishedFilesResult_t_123().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserPublishedFilesResult_t_123, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserPublishedFilesResult_t_123().m_rgPublishedFileId) >= 400 ); + +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserPublishedFilesResult_t_123) >= 412 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserPublishedFilesResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserPublishedFilesResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserPublishedFilesResult_t_123, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserPublishedFilesResult_t_123().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserPublishedFilesResult_t_123, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserPublishedFilesResult_t_123().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserPublishedFilesResult_t_123, m_rgPublishedFileId) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserPublishedFilesResult_t_123().m_rgPublishedFileId) >= 400 ); + +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x) >= 416 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x().m_rgPublishedFileId) >= 400 ); + +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x) >= 416 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserPublishedFilesResult_t_116x().m_rgPublishedFileId) >= 400 ); + +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x) >= 416 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x().m_rgPublishedFileId) >= 400 ); + +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x) >= 412 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x, m_rgPublishedFileId) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserPublishedFilesResult_t_116x().m_rgPublishedFileId) >= 400 ); + +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123) >= 416 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123().m_rgPublishedFileId) >= 400 ); + +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123) >= 412 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123, m_rgPublishedFileId) == 12 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123().m_rgPublishedFileId) >= 400 ); + +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123) >= 416 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123().m_rgPublishedFileId) >= 400 ); + +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123) >= 412 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123, m_rgPublishedFileId) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_123().m_rgPublishedFileId) >= 400 ); + +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119) >= 416 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119().m_rgPublishedFileId) >= 400 ); + +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119) >= 416 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119().m_rgPublishedFileId) >= 400 ); + +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119) >= 416 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119().m_rgPublishedFileId) >= 400 ); + +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119) >= 412 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119, m_rgPublishedFileId) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_119().m_rgPublishedFileId) >= 400 ); + +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123) >= 616 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_rgRTimeSubscribed) == 416 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_rgRTimeSubscribed) >= 200 ); + +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123) >= 612 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_rgPublishedFileId) == 12 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_rgRTimeSubscribed) == 412 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_rgRTimeSubscribed) >= 200 ); + +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123) >= 616 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_rgRTimeSubscribed) == 416 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_rgRTimeSubscribed) >= 200 ); + +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123) >= 612 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_rgPublishedFileId) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123, m_rgRTimeSubscribed) == 412 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_123().m_rgRTimeSubscribed) >= 200 ); + +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x) >= 616 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_rgRTimeSubscribed) == 416 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_rgRTimeSubscribed) >= 200 ); + +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x) >= 616 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_rgRTimeSubscribed) == 416 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_rgRTimeSubscribed) >= 200 ); + +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x) >= 616 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_rgRTimeSubscribed) == 416 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_rgRTimeSubscribed) >= 200 ); + +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x) >= 612 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_rgPublishedFileId) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x, m_rgRTimeSubscribed) == 412 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateUserSubscribedFilesResult_t_116x().m_rgRTimeSubscribed) >= 200 ); + +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_125) >= 624 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_rgScore) == 416 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_rgScore) >= 200 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_nAppId) == 616 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_nAppId) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_unStartIndex) == 620 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_unStartIndex) >= 4 ); + +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_125) >= 620 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_rgPublishedFileId) == 12 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_rgScore) == 412 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_rgScore) >= 200 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_nAppId) == 612 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_nAppId) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_unStartIndex) == 616 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_unStartIndex) >= 4 ); + +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_125) >= 624 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_rgScore) == 416 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_rgScore) >= 200 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_nAppId) == 616 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_nAppId) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_unStartIndex) == 620 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_unStartIndex) >= 4 ); + +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_125) >= 620 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_rgPublishedFileId) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_rgScore) == 412 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_rgScore) >= 200 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_nAppId) == 612 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_nAppId) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_125, m_unStartIndex) == 616 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_125().m_unStartIndex) >= 4 ); + +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_123) >= 616 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_rgScore) == 416 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_rgScore) >= 200 ); + +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_123) >= 612 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_rgPublishedFileId) == 12 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_rgScore) == 412 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_rgScore) >= 200 ); + +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_123) >= 616 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_rgScore) == 416 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_rgScore) >= 200 ); + +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_123) >= 612 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_rgPublishedFileId) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_123, m_rgScore) == 412 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_123().m_rgScore) >= 200 ); + +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_119) >= 616 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_rgScore) == 416 ); +C_ASSERT( sizeof(w64_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_rgScore) >= 200 ); + +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_119) >= 616 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_rgScore) == 416 ); +C_ASSERT( sizeof(u64_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_rgScore) >= 200 ); + +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_119) >= 616 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_rgPublishedFileId) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_rgScore) == 416 ); +C_ASSERT( sizeof(w32_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_rgScore) >= 200 ); + +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_119) >= 612 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_nResultsReturned) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_nResultsReturned) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_nTotalResultCount) == 8 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_nTotalResultCount) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_rgPublishedFileId) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_rgPublishedFileId) >= 400 ); +C_ASSERT( offsetof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_119, m_rgScore) == 412 ); +C_ASSERT( sizeof(u32_RemoteStorageEnumerateWorkshopFilesResult_t_119().m_rgScore) >= 200 ); + +C_ASSERT( sizeof(w64_RemoteStorageFileShareResult_t_128x) >= 280 ); +C_ASSERT( offsetof(w64_RemoteStorageFileShareResult_t_128x, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageFileShareResult_t_128x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageFileShareResult_t_128x, m_hFile) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageFileShareResult_t_128x().m_hFile) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageFileShareResult_t_128x, m_rgchFilename) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageFileShareResult_t_128x().m_rgchFilename) >= 260 ); + +C_ASSERT( sizeof(u64_RemoteStorageFileShareResult_t_128x) >= 272 ); +C_ASSERT( offsetof(u64_RemoteStorageFileShareResult_t_128x, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageFileShareResult_t_128x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageFileShareResult_t_128x, m_hFile) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageFileShareResult_t_128x().m_hFile) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageFileShareResult_t_128x, m_rgchFilename) == 12 ); +C_ASSERT( sizeof(u64_RemoteStorageFileShareResult_t_128x().m_rgchFilename) >= 260 ); + +C_ASSERT( sizeof(w32_RemoteStorageFileShareResult_t_128x) >= 280 ); +C_ASSERT( offsetof(w32_RemoteStorageFileShareResult_t_128x, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageFileShareResult_t_128x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageFileShareResult_t_128x, m_hFile) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageFileShareResult_t_128x().m_hFile) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageFileShareResult_t_128x, m_rgchFilename) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageFileShareResult_t_128x().m_rgchFilename) >= 260 ); + +C_ASSERT( sizeof(u32_RemoteStorageFileShareResult_t_128x) >= 272 ); +C_ASSERT( offsetof(u32_RemoteStorageFileShareResult_t_128x, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageFileShareResult_t_128x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageFileShareResult_t_128x, m_hFile) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageFileShareResult_t_128x().m_hFile) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageFileShareResult_t_128x, m_rgchFilename) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageFileShareResult_t_128x().m_rgchFilename) >= 260 ); + +C_ASSERT( sizeof(w64_RemoteStorageFileShareResult_t_123) >= 16 ); +C_ASSERT( offsetof(w64_RemoteStorageFileShareResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageFileShareResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageFileShareResult_t_123, m_hFile) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageFileShareResult_t_123().m_hFile) >= 8 ); + +C_ASSERT( sizeof(u64_RemoteStorageFileShareResult_t_123) >= 12 ); +C_ASSERT( offsetof(u64_RemoteStorageFileShareResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageFileShareResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageFileShareResult_t_123, m_hFile) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageFileShareResult_t_123().m_hFile) >= 8 ); + +C_ASSERT( sizeof(w32_RemoteStorageFileShareResult_t_123) >= 16 ); +C_ASSERT( offsetof(w32_RemoteStorageFileShareResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageFileShareResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageFileShareResult_t_123, m_hFile) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageFileShareResult_t_123().m_hFile) >= 8 ); + +C_ASSERT( sizeof(u32_RemoteStorageFileShareResult_t_123) >= 12 ); +C_ASSERT( offsetof(u32_RemoteStorageFileShareResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageFileShareResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageFileShareResult_t_123, m_hFile) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageFileShareResult_t_123().m_hFile) >= 8 ); + +C_ASSERT( sizeof(w64_RemoteStorageFileShareResult_t_111x) >= 16 ); +C_ASSERT( offsetof(w64_RemoteStorageFileShareResult_t_111x, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageFileShareResult_t_111x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageFileShareResult_t_111x, m_hFile) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageFileShareResult_t_111x().m_hFile) >= 8 ); + +C_ASSERT( sizeof(u64_RemoteStorageFileShareResult_t_111x) >= 16 ); +C_ASSERT( offsetof(u64_RemoteStorageFileShareResult_t_111x, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageFileShareResult_t_111x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageFileShareResult_t_111x, m_hFile) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageFileShareResult_t_111x().m_hFile) >= 8 ); + +C_ASSERT( sizeof(w32_RemoteStorageFileShareResult_t_111x) >= 16 ); +C_ASSERT( offsetof(w32_RemoteStorageFileShareResult_t_111x, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageFileShareResult_t_111x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageFileShareResult_t_111x, m_hFile) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageFileShareResult_t_111x().m_hFile) >= 8 ); + +C_ASSERT( sizeof(u32_RemoteStorageFileShareResult_t_111x) >= 12 ); +C_ASSERT( offsetof(u32_RemoteStorageFileShareResult_t_111x, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageFileShareResult_t_111x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageFileShareResult_t_111x, m_hFile) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageFileShareResult_t_111x().m_hFile) >= 8 ); + +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126) >= 9760 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_hFile) == 8160 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_hFile) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_hPreviewFile) == 8168 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_ulSteamIDOwner) == 8176 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rtimeCreated) == 8184 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rtimeUpdated) == 8188 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_eVisibility) == 8192 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_bBanned) == 8196 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rgchTags) == 8197 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_bTagsTruncated) == 9222 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_pchFileName) == 9223 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nFileSize) == 9484 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nPreviewFileSize) == 9488 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rgchURL) == 9492 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_eFileType) == 9748 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_eFileType) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_bAcceptedForUse) == 9752 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_bAcceptedForUse) >= 1 ); + +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126) >= 9748 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nCreatorAppID) == 12 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nConsumerAppID) == 16 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rgchTitle) == 20 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rgchDescription) == 149 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_hFile) == 8152 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_hFile) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_hPreviewFile) == 8160 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_ulSteamIDOwner) == 8168 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rtimeCreated) == 8176 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rtimeUpdated) == 8180 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_eVisibility) == 8184 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_bBanned) == 8188 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rgchTags) == 8189 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_bTagsTruncated) == 9214 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_pchFileName) == 9215 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nFileSize) == 9476 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nPreviewFileSize) == 9480 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rgchURL) == 9484 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_eFileType) == 9740 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_eFileType) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126, m_bAcceptedForUse) == 9744 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_126().m_bAcceptedForUse) >= 1 ); + +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126) >= 9760 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_hFile) == 8160 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_hFile) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_hPreviewFile) == 8168 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_ulSteamIDOwner) == 8176 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rtimeCreated) == 8184 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rtimeUpdated) == 8188 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_eVisibility) == 8192 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_bBanned) == 8196 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rgchTags) == 8197 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_bTagsTruncated) == 9222 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_pchFileName) == 9223 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nFileSize) == 9484 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nPreviewFileSize) == 9488 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rgchURL) == 9492 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_eFileType) == 9748 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_eFileType) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_bAcceptedForUse) == 9752 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_bAcceptedForUse) >= 1 ); + +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126) >= 9748 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nCreatorAppID) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nConsumerAppID) == 16 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rgchTitle) == 20 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rgchDescription) == 149 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_hFile) == 8152 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_hFile) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_hPreviewFile) == 8160 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_ulSteamIDOwner) == 8168 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rtimeCreated) == 8176 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rtimeUpdated) == 8180 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_eVisibility) == 8184 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_bBanned) == 8188 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rgchTags) == 8189 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_bTagsTruncated) == 9214 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_pchFileName) == 9215 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nFileSize) == 9476 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_nPreviewFileSize) == 9480 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_rgchURL) == 9484 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_eFileType) == 9740 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_eFileType) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126, m_bAcceptedForUse) == 9744 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_126().m_bAcceptedForUse) >= 1 ); + +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123) >= 9752 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_hFile) == 8160 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_hFile) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_hPreviewFile) == 8168 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_ulSteamIDOwner) == 8176 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rtimeCreated) == 8184 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rtimeUpdated) == 8188 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_eVisibility) == 8192 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_bBanned) == 8196 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rgchTags) == 8197 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_bTagsTruncated) == 9222 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_pchFileName) == 9223 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nFileSize) == 9484 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nPreviewFileSize) == 9488 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rgchURL) == 9492 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_eFileType) == 9748 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_eFileType) >= 4 ); + +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123) >= 9744 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nCreatorAppID) == 12 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nConsumerAppID) == 16 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rgchTitle) == 20 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rgchDescription) == 149 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_hFile) == 8152 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_hFile) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_hPreviewFile) == 8160 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_ulSteamIDOwner) == 8168 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rtimeCreated) == 8176 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rtimeUpdated) == 8180 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_eVisibility) == 8184 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_bBanned) == 8188 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rgchTags) == 8189 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_bTagsTruncated) == 9214 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_pchFileName) == 9215 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nFileSize) == 9476 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nPreviewFileSize) == 9480 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rgchURL) == 9484 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123, m_eFileType) == 9740 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_123().m_eFileType) >= 4 ); + +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123) >= 9752 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_hFile) == 8160 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_hFile) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_hPreviewFile) == 8168 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_ulSteamIDOwner) == 8176 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rtimeCreated) == 8184 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rtimeUpdated) == 8188 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_eVisibility) == 8192 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_bBanned) == 8196 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rgchTags) == 8197 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_bTagsTruncated) == 9222 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_pchFileName) == 9223 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nFileSize) == 9484 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nPreviewFileSize) == 9488 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rgchURL) == 9492 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_eFileType) == 9748 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_eFileType) >= 4 ); + +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123) >= 9744 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nCreatorAppID) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nConsumerAppID) == 16 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rgchTitle) == 20 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rgchDescription) == 149 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_hFile) == 8152 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_hFile) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_hPreviewFile) == 8160 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_ulSteamIDOwner) == 8168 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rtimeCreated) == 8176 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rtimeUpdated) == 8180 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_eVisibility) == 8184 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_bBanned) == 8188 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rgchTags) == 8189 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_bTagsTruncated) == 9214 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_pchFileName) == 9215 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nFileSize) == 9476 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_nPreviewFileSize) == 9480 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_rgchURL) == 9484 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123, m_eFileType) == 9740 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_123().m_eFileType) >= 4 ); + +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x) >= 9752 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_hFile) == 8160 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_hFile) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_hPreviewFile) == 8168 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_ulSteamIDOwner) == 8176 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rtimeCreated) == 8184 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rtimeUpdated) == 8188 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_eVisibility) == 8192 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_bBanned) == 8196 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rgchTags) == 8197 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_bTagsTruncated) == 9222 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_pchFileName) == 9223 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nFileSize) == 9484 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nPreviewFileSize) == 9488 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rgchURL) == 9492 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_eFileType) == 9748 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_eFileType) >= 4 ); + +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x) >= 9752 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_hFile) == 8160 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_hFile) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_hPreviewFile) == 8168 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_ulSteamIDOwner) == 8176 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rtimeCreated) == 8184 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rtimeUpdated) == 8188 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_eVisibility) == 8192 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_bBanned) == 8196 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rgchTags) == 8197 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_bTagsTruncated) == 9222 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_pchFileName) == 9223 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nFileSize) == 9484 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nPreviewFileSize) == 9488 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rgchURL) == 9492 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_eFileType) == 9748 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_eFileType) >= 4 ); + +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x) >= 9752 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_hFile) == 8160 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_hFile) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_hPreviewFile) == 8168 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_ulSteamIDOwner) == 8176 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rtimeCreated) == 8184 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rtimeUpdated) == 8188 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_eVisibility) == 8192 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_bBanned) == 8196 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rgchTags) == 8197 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_bTagsTruncated) == 9222 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_pchFileName) == 9223 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nFileSize) == 9484 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nPreviewFileSize) == 9488 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rgchURL) == 9492 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_eFileType) == 9748 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_eFileType) >= 4 ); + +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x) >= 9744 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nCreatorAppID) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nConsumerAppID) == 16 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rgchTitle) == 20 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rgchDescription) == 149 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_hFile) == 8152 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_hFile) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_hPreviewFile) == 8160 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_ulSteamIDOwner) == 8168 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rtimeCreated) == 8176 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rtimeUpdated) == 8180 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_eVisibility) == 8184 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_bBanned) == 8188 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rgchTags) == 8189 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_bTagsTruncated) == 9214 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_pchFileName) == 9215 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nFileSize) == 9476 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_nPreviewFileSize) == 9480 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_rgchURL) == 9484 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_rgchURL) >= 256 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x, m_eFileType) == 9740 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119x().m_eFileType) >= 4 ); + +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119) >= 9752 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_hFile) == 8160 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_hFile) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_hPreviewFile) == 8168 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_ulSteamIDOwner) == 8176 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rtimeCreated) == 8184 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rtimeUpdated) == 8188 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_eVisibility) == 8192 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_bBanned) == 8196 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rgchTags) == 8197 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_bTagsTruncated) == 9222 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_pchFileName) == 9223 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nFileSize) == 9484 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nPreviewFileSize) == 9488 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rgchURL) == 9492 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rgchURL) >= 256 ); + +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119) >= 9752 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_hFile) == 8160 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_hFile) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_hPreviewFile) == 8168 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_ulSteamIDOwner) == 8176 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rtimeCreated) == 8184 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rtimeUpdated) == 8188 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_eVisibility) == 8192 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_bBanned) == 8196 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rgchTags) == 8197 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_bTagsTruncated) == 9222 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_pchFileName) == 9223 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nFileSize) == 9484 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nPreviewFileSize) == 9488 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rgchURL) == 9492 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rgchURL) >= 256 ); + +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119) >= 9752 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_hFile) == 8160 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_hFile) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_hPreviewFile) == 8168 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_ulSteamIDOwner) == 8176 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rtimeCreated) == 8184 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rtimeUpdated) == 8188 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_eVisibility) == 8192 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_bBanned) == 8196 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rgchTags) == 8197 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_bTagsTruncated) == 9222 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_pchFileName) == 9223 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nFileSize) == 9484 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nPreviewFileSize) == 9488 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rgchURL) == 9492 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rgchURL) >= 256 ); + +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119) >= 9740 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nCreatorAppID) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nConsumerAppID) == 16 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rgchTitle) == 20 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rgchDescription) == 149 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_hFile) == 8152 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_hFile) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_hPreviewFile) == 8160 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_ulSteamIDOwner) == 8168 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rtimeCreated) == 8176 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rtimeUpdated) == 8180 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_eVisibility) == 8184 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_bBanned) == 8188 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rgchTags) == 8189 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_bTagsTruncated) == 9214 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_pchFileName) == 9215 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nFileSize) == 9476 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_nPreviewFileSize) == 9480 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_nPreviewFileSize) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119, m_rgchURL) == 9484 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_119().m_rgchURL) >= 256 ); + +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118) >= 9496 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_hFile) == 8160 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_hFile) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_hPreviewFile) == 8168 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_ulSteamIDOwner) == 8176 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rtimeCreated) == 8184 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rtimeUpdated) == 8188 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_eVisibility) == 8192 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_bBanned) == 8196 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rgchTags) == 8197 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_bTagsTruncated) == 9222 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_pchFileName) == 9223 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nFileSize) == 9484 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nPreviewFileSize) == 9488 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nPreviewFileSize) >= 4 ); + +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118) >= 9496 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_hFile) == 8160 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_hFile) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_hPreviewFile) == 8168 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_ulSteamIDOwner) == 8176 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rtimeCreated) == 8184 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rtimeUpdated) == 8188 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_eVisibility) == 8192 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_bBanned) == 8196 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rgchTags) == 8197 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_bTagsTruncated) == 9222 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_pchFileName) == 9223 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nFileSize) == 9484 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nPreviewFileSize) == 9488 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nPreviewFileSize) >= 4 ); + +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118) >= 9496 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_hFile) == 8160 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_hFile) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_hPreviewFile) == 8168 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_ulSteamIDOwner) == 8176 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rtimeCreated) == 8184 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rtimeUpdated) == 8188 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_eVisibility) == 8192 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_bBanned) == 8196 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rgchTags) == 8197 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_bTagsTruncated) == 9222 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_pchFileName) == 9223 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nFileSize) == 9484 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nPreviewFileSize) == 9488 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nPreviewFileSize) >= 4 ); + +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118) >= 9484 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nCreatorAppID) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nConsumerAppID) == 16 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rgchTitle) == 20 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rgchDescription) == 149 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rgchDescription) >= 8000 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_hFile) == 8152 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_hFile) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_hPreviewFile) == 8160 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_ulSteamIDOwner) == 8168 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rtimeCreated) == 8176 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rtimeUpdated) == 8180 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_eVisibility) == 8184 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_bBanned) == 8188 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_rgchTags) == 8189 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_bTagsTruncated) == 9214 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_pchFileName) == 9215 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_pchFileName) >= 260 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nFileSize) == 9476 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nFileSize) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118, m_nPreviewFileSize) == 9480 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_118().m_nPreviewFileSize) >= 4 ); + +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x) >= 1744 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rgchDescription) >= 257 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_hFile) == 416 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_hFile) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_hPreviewFile) == 424 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_ulSteamIDOwner) == 432 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rtimeCreated) == 440 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rtimeUpdated) == 444 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_eVisibility) == 448 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_bBanned) == 452 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rgchTags) == 453 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_bTagsTruncated) == 1478 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_pchFileName) == 1479 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_pchFileName) >= 260 ); + +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x) >= 1744 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rgchDescription) >= 257 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_hFile) == 416 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_hFile) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_hPreviewFile) == 424 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_ulSteamIDOwner) == 432 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rtimeCreated) == 440 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rtimeUpdated) == 444 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_eVisibility) == 448 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_bBanned) == 452 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rgchTags) == 453 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_bTagsTruncated) == 1478 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_pchFileName) == 1479 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_pchFileName) >= 260 ); + +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x) >= 1744 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_nCreatorAppID) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_nConsumerAppID) == 20 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rgchTitle) == 24 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rgchDescription) == 153 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rgchDescription) >= 257 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_hFile) == 416 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_hFile) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_hPreviewFile) == 424 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_ulSteamIDOwner) == 432 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rtimeCreated) == 440 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rtimeUpdated) == 444 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_eVisibility) == 448 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_bBanned) == 452 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_bBanned) >= 1 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rgchTags) == 453 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_bTagsTruncated) == 1478 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_pchFileName) == 1479 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_pchFileName) >= 260 ); + +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x) >= 1732 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_nCreatorAppID) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_nCreatorAppID) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_nConsumerAppID) == 16 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_nConsumerAppID) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rgchTitle) == 20 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rgchTitle) >= 129 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rgchDescription) == 149 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rgchDescription) >= 257 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_hFile) == 408 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_hFile) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_hPreviewFile) == 416 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_hPreviewFile) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_ulSteamIDOwner) == 424 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_ulSteamIDOwner) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rtimeCreated) == 432 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rtimeCreated) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rtimeUpdated) == 436 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rtimeUpdated) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_eVisibility) == 440 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_bBanned) == 444 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_bBanned) >= 1 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_rgchTags) == 445 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_rgchTags) >= 1025 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_bTagsTruncated) == 1470 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_bTagsTruncated) >= 1 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x, m_pchFileName) == 1471 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedFileDetailsResult_t_116x().m_pchFileName) >= 260 ); + +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123) >= 32 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_unPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_unPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_nVotesFor) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_nVotesFor) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_nVotesAgainst) == 20 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_nVotesAgainst) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_nReports) == 24 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_nReports) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_fScore) == 28 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_fScore) >= 4 ); + +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123) >= 28 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_unPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_unPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_nVotesFor) == 12 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_nVotesFor) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_nVotesAgainst) == 16 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_nVotesAgainst) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_nReports) == 20 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_nReports) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_fScore) == 24 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_fScore) >= 4 ); + +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123) >= 32 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_unPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_unPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_nVotesFor) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_nVotesFor) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_nVotesAgainst) == 20 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_nVotesAgainst) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_nReports) == 24 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_nReports) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_fScore) == 28 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_fScore) >= 4 ); + +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123) >= 28 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_unPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_unPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_nVotesFor) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_nVotesFor) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_nVotesAgainst) == 16 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_nVotesAgainst) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_nReports) == 20 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_nReports) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123, m_fScore) == 24 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_123().m_fScore) >= 4 ); + +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119) >= 32 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_unPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_unPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_nVotesFor) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_nVotesFor) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_nVotesAgainst) == 20 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_nVotesAgainst) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_nReports) == 24 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_nReports) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_fScore) == 28 ); +C_ASSERT( sizeof(w64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_fScore) >= 4 ); + +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119) >= 32 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_unPublishedFileId) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_unPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_nVotesFor) == 16 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_nVotesFor) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_nVotesAgainst) == 20 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_nVotesAgainst) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_nReports) == 24 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_nReports) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_fScore) == 28 ); +C_ASSERT( sizeof(u64_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_fScore) >= 4 ); + +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119) >= 32 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_unPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_unPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_nVotesFor) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_nVotesFor) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_nVotesAgainst) == 20 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_nVotesAgainst) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_nReports) == 24 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_nReports) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_fScore) == 28 ); +C_ASSERT( sizeof(w32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_fScore) >= 4 ); + +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119) >= 28 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_unPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_unPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_nVotesFor) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_nVotesFor) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_nVotesAgainst) == 16 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_nVotesAgainst) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_nReports) == 20 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_nReports) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119, m_fScore) == 24 ); +C_ASSERT( sizeof(u32_RemoteStorageGetPublishedItemVoteDetailsResult_t_119().m_fScore) >= 4 ); + +C_ASSERT( sizeof(w64_RemoteStoragePublishFileResult_t_125) >= 24 ); +C_ASSERT( offsetof(w64_RemoteStoragePublishFileResult_t_125, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStoragePublishFileResult_t_125().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStoragePublishFileResult_t_125, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStoragePublishFileResult_t_125().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStoragePublishFileResult_t_125, m_bUserNeedsToAcceptWorkshopLegalAgreement) == 16 ); +C_ASSERT( sizeof(w64_RemoteStoragePublishFileResult_t_125().m_bUserNeedsToAcceptWorkshopLegalAgreement) >= 1 ); + +C_ASSERT( sizeof(u64_RemoteStoragePublishFileResult_t_125) >= 16 ); +C_ASSERT( offsetof(u64_RemoteStoragePublishFileResult_t_125, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStoragePublishFileResult_t_125().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStoragePublishFileResult_t_125, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_RemoteStoragePublishFileResult_t_125().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStoragePublishFileResult_t_125, m_bUserNeedsToAcceptWorkshopLegalAgreement) == 12 ); +C_ASSERT( sizeof(u64_RemoteStoragePublishFileResult_t_125().m_bUserNeedsToAcceptWorkshopLegalAgreement) >= 1 ); + +C_ASSERT( sizeof(w32_RemoteStoragePublishFileResult_t_125) >= 24 ); +C_ASSERT( offsetof(w32_RemoteStoragePublishFileResult_t_125, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStoragePublishFileResult_t_125().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStoragePublishFileResult_t_125, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStoragePublishFileResult_t_125().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStoragePublishFileResult_t_125, m_bUserNeedsToAcceptWorkshopLegalAgreement) == 16 ); +C_ASSERT( sizeof(w32_RemoteStoragePublishFileResult_t_125().m_bUserNeedsToAcceptWorkshopLegalAgreement) >= 1 ); + +C_ASSERT( sizeof(u32_RemoteStoragePublishFileResult_t_125) >= 16 ); +C_ASSERT( offsetof(u32_RemoteStoragePublishFileResult_t_125, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStoragePublishFileResult_t_125().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStoragePublishFileResult_t_125, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStoragePublishFileResult_t_125().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStoragePublishFileResult_t_125, m_bUserNeedsToAcceptWorkshopLegalAgreement) == 12 ); +C_ASSERT( sizeof(u32_RemoteStoragePublishFileResult_t_125().m_bUserNeedsToAcceptWorkshopLegalAgreement) >= 1 ); + +C_ASSERT( sizeof(w64_RemoteStoragePublishFileResult_t_123) >= 16 ); +C_ASSERT( offsetof(w64_RemoteStoragePublishFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStoragePublishFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStoragePublishFileResult_t_123, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStoragePublishFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u64_RemoteStoragePublishFileResult_t_123) >= 12 ); +C_ASSERT( offsetof(u64_RemoteStoragePublishFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStoragePublishFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStoragePublishFileResult_t_123, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_RemoteStoragePublishFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w32_RemoteStoragePublishFileResult_t_123) >= 16 ); +C_ASSERT( offsetof(w32_RemoteStoragePublishFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStoragePublishFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStoragePublishFileResult_t_123, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStoragePublishFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u32_RemoteStoragePublishFileResult_t_123) >= 12 ); +C_ASSERT( offsetof(u32_RemoteStoragePublishFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStoragePublishFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStoragePublishFileResult_t_123, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStoragePublishFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w64_RemoteStoragePublishFileResult_t_116x) >= 16 ); +C_ASSERT( offsetof(w64_RemoteStoragePublishFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStoragePublishFileResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStoragePublishFileResult_t_116x, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStoragePublishFileResult_t_116x().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u64_RemoteStoragePublishFileResult_t_116x) >= 16 ); +C_ASSERT( offsetof(u64_RemoteStoragePublishFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStoragePublishFileResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStoragePublishFileResult_t_116x, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(u64_RemoteStoragePublishFileResult_t_116x().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w32_RemoteStoragePublishFileResult_t_116x) >= 16 ); +C_ASSERT( offsetof(w32_RemoteStoragePublishFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStoragePublishFileResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStoragePublishFileResult_t_116x, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStoragePublishFileResult_t_116x().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u32_RemoteStoragePublishFileResult_t_116x) >= 12 ); +C_ASSERT( offsetof(u32_RemoteStoragePublishFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStoragePublishFileResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStoragePublishFileResult_t_116x, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStoragePublishFileResult_t_116x().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w64_RemoteStoragePublishedFileUpdated_t) >= 24 ); +C_ASSERT( offsetof(w64_RemoteStoragePublishedFileUpdated_t, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(w64_RemoteStoragePublishedFileUpdated_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStoragePublishedFileUpdated_t, m_nAppID) == 8 ); +C_ASSERT( sizeof(w64_RemoteStoragePublishedFileUpdated_t().m_nAppID) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStoragePublishedFileUpdated_t, m_ulUnused) == 16 ); +C_ASSERT( sizeof(w64_RemoteStoragePublishedFileUpdated_t().m_ulUnused) >= 8 ); + +C_ASSERT( sizeof(u64_RemoteStoragePublishedFileUpdated_t) >= 20 ); +C_ASSERT( offsetof(u64_RemoteStoragePublishedFileUpdated_t, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(u64_RemoteStoragePublishedFileUpdated_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStoragePublishedFileUpdated_t, m_nAppID) == 8 ); +C_ASSERT( sizeof(u64_RemoteStoragePublishedFileUpdated_t().m_nAppID) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStoragePublishedFileUpdated_t, m_ulUnused) == 12 ); +C_ASSERT( sizeof(u64_RemoteStoragePublishedFileUpdated_t().m_ulUnused) >= 8 ); + +C_ASSERT( sizeof(w32_RemoteStoragePublishedFileUpdated_t) >= 24 ); +C_ASSERT( offsetof(w32_RemoteStoragePublishedFileUpdated_t, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(w32_RemoteStoragePublishedFileUpdated_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStoragePublishedFileUpdated_t, m_nAppID) == 8 ); +C_ASSERT( sizeof(w32_RemoteStoragePublishedFileUpdated_t().m_nAppID) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStoragePublishedFileUpdated_t, m_ulUnused) == 16 ); +C_ASSERT( sizeof(w32_RemoteStoragePublishedFileUpdated_t().m_ulUnused) >= 8 ); + +C_ASSERT( sizeof(u32_RemoteStoragePublishedFileUpdated_t) >= 20 ); +C_ASSERT( offsetof(u32_RemoteStoragePublishedFileUpdated_t, m_nPublishedFileId) == 0 ); +C_ASSERT( sizeof(u32_RemoteStoragePublishedFileUpdated_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStoragePublishedFileUpdated_t, m_nAppID) == 8 ); +C_ASSERT( sizeof(u32_RemoteStoragePublishedFileUpdated_t().m_nAppID) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStoragePublishedFileUpdated_t, m_ulUnused) == 12 ); +C_ASSERT( sizeof(u32_RemoteStoragePublishedFileUpdated_t().m_ulUnused) >= 8 ); + +C_ASSERT( sizeof(w64_RemoteStorageSetUserPublishedFileActionResult_t_123) >= 24 ); +C_ASSERT( offsetof(w64_RemoteStorageSetUserPublishedFileActionResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageSetUserPublishedFileActionResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageSetUserPublishedFileActionResult_t_123, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageSetUserPublishedFileActionResult_t_123().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageSetUserPublishedFileActionResult_t_123, m_eAction) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageSetUserPublishedFileActionResult_t_123().m_eAction) >= 4 ); + +C_ASSERT( sizeof(u64_RemoteStorageSetUserPublishedFileActionResult_t_123) >= 16 ); +C_ASSERT( offsetof(u64_RemoteStorageSetUserPublishedFileActionResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageSetUserPublishedFileActionResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageSetUserPublishedFileActionResult_t_123, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageSetUserPublishedFileActionResult_t_123().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageSetUserPublishedFileActionResult_t_123, m_eAction) == 12 ); +C_ASSERT( sizeof(u64_RemoteStorageSetUserPublishedFileActionResult_t_123().m_eAction) >= 4 ); + +C_ASSERT( sizeof(w32_RemoteStorageSetUserPublishedFileActionResult_t_123) >= 24 ); +C_ASSERT( offsetof(w32_RemoteStorageSetUserPublishedFileActionResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageSetUserPublishedFileActionResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageSetUserPublishedFileActionResult_t_123, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageSetUserPublishedFileActionResult_t_123().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageSetUserPublishedFileActionResult_t_123, m_eAction) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageSetUserPublishedFileActionResult_t_123().m_eAction) >= 4 ); + +C_ASSERT( sizeof(u32_RemoteStorageSetUserPublishedFileActionResult_t_123) >= 16 ); +C_ASSERT( offsetof(u32_RemoteStorageSetUserPublishedFileActionResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageSetUserPublishedFileActionResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageSetUserPublishedFileActionResult_t_123, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageSetUserPublishedFileActionResult_t_123().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageSetUserPublishedFileActionResult_t_123, m_eAction) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageSetUserPublishedFileActionResult_t_123().m_eAction) >= 4 ); + +C_ASSERT( sizeof(w64_RemoteStorageSetUserPublishedFileActionResult_t_119) >= 24 ); +C_ASSERT( offsetof(w64_RemoteStorageSetUserPublishedFileActionResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageSetUserPublishedFileActionResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageSetUserPublishedFileActionResult_t_119, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageSetUserPublishedFileActionResult_t_119().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageSetUserPublishedFileActionResult_t_119, m_eAction) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageSetUserPublishedFileActionResult_t_119().m_eAction) >= 4 ); + +C_ASSERT( sizeof(u64_RemoteStorageSetUserPublishedFileActionResult_t_119) >= 24 ); +C_ASSERT( offsetof(u64_RemoteStorageSetUserPublishedFileActionResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageSetUserPublishedFileActionResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageSetUserPublishedFileActionResult_t_119, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageSetUserPublishedFileActionResult_t_119().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageSetUserPublishedFileActionResult_t_119, m_eAction) == 16 ); +C_ASSERT( sizeof(u64_RemoteStorageSetUserPublishedFileActionResult_t_119().m_eAction) >= 4 ); + +C_ASSERT( sizeof(w32_RemoteStorageSetUserPublishedFileActionResult_t_119) >= 24 ); +C_ASSERT( offsetof(w32_RemoteStorageSetUserPublishedFileActionResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageSetUserPublishedFileActionResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageSetUserPublishedFileActionResult_t_119, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageSetUserPublishedFileActionResult_t_119().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageSetUserPublishedFileActionResult_t_119, m_eAction) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageSetUserPublishedFileActionResult_t_119().m_eAction) >= 4 ); + +C_ASSERT( sizeof(u32_RemoteStorageSetUserPublishedFileActionResult_t_119) >= 16 ); +C_ASSERT( offsetof(u32_RemoteStorageSetUserPublishedFileActionResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageSetUserPublishedFileActionResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageSetUserPublishedFileActionResult_t_119, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageSetUserPublishedFileActionResult_t_119().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageSetUserPublishedFileActionResult_t_119, m_eAction) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageSetUserPublishedFileActionResult_t_119().m_eAction) >= 4 ); + +C_ASSERT( sizeof(w64_RemoteStorageSubscribePublishedFileResult_t_123) >= 16 ); +C_ASSERT( offsetof(w64_RemoteStorageSubscribePublishedFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageSubscribePublishedFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageSubscribePublishedFileResult_t_123, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageSubscribePublishedFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u64_RemoteStorageSubscribePublishedFileResult_t_123) >= 12 ); +C_ASSERT( offsetof(u64_RemoteStorageSubscribePublishedFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageSubscribePublishedFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageSubscribePublishedFileResult_t_123, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageSubscribePublishedFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w32_RemoteStorageSubscribePublishedFileResult_t_123) >= 16 ); +C_ASSERT( offsetof(w32_RemoteStorageSubscribePublishedFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageSubscribePublishedFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageSubscribePublishedFileResult_t_123, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageSubscribePublishedFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u32_RemoteStorageSubscribePublishedFileResult_t_123) >= 12 ); +C_ASSERT( offsetof(u32_RemoteStorageSubscribePublishedFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageSubscribePublishedFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageSubscribePublishedFileResult_t_123, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageSubscribePublishedFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w64_RemoteStorageSubscribePublishedFileResult_t_116x) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageSubscribePublishedFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageSubscribePublishedFileResult_t_116x().m_eResult) >= 4 ); + +C_ASSERT( sizeof(u64_RemoteStorageSubscribePublishedFileResult_t_116x) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageSubscribePublishedFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageSubscribePublishedFileResult_t_116x().m_eResult) >= 4 ); + +C_ASSERT( sizeof(w32_RemoteStorageSubscribePublishedFileResult_t_116x) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageSubscribePublishedFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageSubscribePublishedFileResult_t_116x().m_eResult) >= 4 ); + +C_ASSERT( sizeof(u32_RemoteStorageSubscribePublishedFileResult_t_116x) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageSubscribePublishedFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageSubscribePublishedFileResult_t_116x().m_eResult) >= 4 ); + +C_ASSERT( sizeof(w64_RemoteStorageUnsubscribePublishedFileResult_t_123) >= 16 ); +C_ASSERT( offsetof(w64_RemoteStorageUnsubscribePublishedFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageUnsubscribePublishedFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageUnsubscribePublishedFileResult_t_123, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageUnsubscribePublishedFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u64_RemoteStorageUnsubscribePublishedFileResult_t_123) >= 12 ); +C_ASSERT( offsetof(u64_RemoteStorageUnsubscribePublishedFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageUnsubscribePublishedFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageUnsubscribePublishedFileResult_t_123, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageUnsubscribePublishedFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w32_RemoteStorageUnsubscribePublishedFileResult_t_123) >= 16 ); +C_ASSERT( offsetof(w32_RemoteStorageUnsubscribePublishedFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageUnsubscribePublishedFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageUnsubscribePublishedFileResult_t_123, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageUnsubscribePublishedFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u32_RemoteStorageUnsubscribePublishedFileResult_t_123) >= 12 ); +C_ASSERT( offsetof(u32_RemoteStorageUnsubscribePublishedFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageUnsubscribePublishedFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageUnsubscribePublishedFileResult_t_123, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageUnsubscribePublishedFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w64_RemoteStorageUnsubscribePublishedFileResult_t_116x) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageUnsubscribePublishedFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageUnsubscribePublishedFileResult_t_116x().m_eResult) >= 4 ); + +C_ASSERT( sizeof(u64_RemoteStorageUnsubscribePublishedFileResult_t_116x) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageUnsubscribePublishedFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageUnsubscribePublishedFileResult_t_116x().m_eResult) >= 4 ); + +C_ASSERT( sizeof(w32_RemoteStorageUnsubscribePublishedFileResult_t_116x) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageUnsubscribePublishedFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageUnsubscribePublishedFileResult_t_116x().m_eResult) >= 4 ); + +C_ASSERT( sizeof(u32_RemoteStorageUnsubscribePublishedFileResult_t_116x) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageUnsubscribePublishedFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageUnsubscribePublishedFileResult_t_116x().m_eResult) >= 4 ); + +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileRequest_t) >= 64 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileRequest_t, m_unPublishedFileId) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileRequest_t().m_unPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileRequest_t, m_pchFile) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileRequest_t().m_pchFile) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileRequest_t, m_pchPreviewFile) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileRequest_t().m_pchPreviewFile) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileRequest_t, m_pchTitle) == 24 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileRequest_t().m_pchTitle) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileRequest_t, m_pchDescription) == 32 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileRequest_t().m_pchDescription) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileRequest_t, m_eVisibility) == 40 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileRequest_t().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileRequest_t, m_pTags) == 48 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileRequest_t().m_pTags) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateFile) == 56 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateFile) >= 1 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdatePreviewFile) == 57 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdatePreviewFile) >= 1 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateTitle) == 58 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateTitle) >= 1 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateDescription) == 59 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateDescription) >= 1 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateVisibility) == 60 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateVisibility) >= 1 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateTags) == 61 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateTags) >= 1 ); + +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileRequest_t) >= 64 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileRequest_t, m_unPublishedFileId) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileRequest_t().m_unPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileRequest_t, m_pchFile) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileRequest_t().m_pchFile) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileRequest_t, m_pchPreviewFile) == 16 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileRequest_t().m_pchPreviewFile) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileRequest_t, m_pchTitle) == 24 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileRequest_t().m_pchTitle) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileRequest_t, m_pchDescription) == 32 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileRequest_t().m_pchDescription) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileRequest_t, m_eVisibility) == 40 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileRequest_t().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileRequest_t, m_pTags) == 48 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileRequest_t().m_pTags) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateFile) == 56 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateFile) >= 1 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdatePreviewFile) == 57 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdatePreviewFile) >= 1 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateTitle) == 58 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateTitle) >= 1 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateDescription) == 59 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateDescription) >= 1 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateVisibility) == 60 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateVisibility) >= 1 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateTags) == 61 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateTags) >= 1 ); + +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileRequest_t) >= 40 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileRequest_t, m_unPublishedFileId) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileRequest_t().m_unPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileRequest_t, m_pchFile) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileRequest_t().m_pchFile) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileRequest_t, m_pchPreviewFile) == 12 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileRequest_t().m_pchPreviewFile) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileRequest_t, m_pchTitle) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileRequest_t().m_pchTitle) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileRequest_t, m_pchDescription) == 20 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileRequest_t().m_pchDescription) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileRequest_t, m_eVisibility) == 24 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileRequest_t().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileRequest_t, m_pTags) == 28 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileRequest_t().m_pTags) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateFile) == 32 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateFile) >= 1 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdatePreviewFile) == 33 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdatePreviewFile) >= 1 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateTitle) == 34 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateTitle) >= 1 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateDescription) == 35 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateDescription) >= 1 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateVisibility) == 36 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateVisibility) >= 1 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateTags) == 37 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateTags) >= 1 ); + +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileRequest_t) >= 40 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileRequest_t, m_unPublishedFileId) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileRequest_t().m_unPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileRequest_t, m_pchFile) == 8 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileRequest_t().m_pchFile) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileRequest_t, m_pchPreviewFile) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileRequest_t().m_pchPreviewFile) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileRequest_t, m_pchTitle) == 16 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileRequest_t().m_pchTitle) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileRequest_t, m_pchDescription) == 20 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileRequest_t().m_pchDescription) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileRequest_t, m_eVisibility) == 24 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileRequest_t().m_eVisibility) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileRequest_t, m_pTags) == 28 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileRequest_t().m_pTags) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateFile) == 32 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateFile) >= 1 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdatePreviewFile) == 33 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdatePreviewFile) >= 1 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateTitle) == 34 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateTitle) >= 1 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateDescription) == 35 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateDescription) >= 1 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateVisibility) == 36 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateVisibility) >= 1 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileRequest_t, m_bUpdateTags) == 37 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileRequest_t().m_bUpdateTags) >= 1 ); + +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileResult_t_125) >= 24 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileResult_t_125, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileResult_t_125().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileResult_t_125, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileResult_t_125().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileResult_t_125, m_bUserNeedsToAcceptWorkshopLegalAgreement) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileResult_t_125().m_bUserNeedsToAcceptWorkshopLegalAgreement) >= 1 ); + +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileResult_t_125) >= 16 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileResult_t_125, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileResult_t_125().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileResult_t_125, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileResult_t_125().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileResult_t_125, m_bUserNeedsToAcceptWorkshopLegalAgreement) == 12 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileResult_t_125().m_bUserNeedsToAcceptWorkshopLegalAgreement) >= 1 ); + +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileResult_t_125) >= 24 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileResult_t_125, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileResult_t_125().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileResult_t_125, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileResult_t_125().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileResult_t_125, m_bUserNeedsToAcceptWorkshopLegalAgreement) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileResult_t_125().m_bUserNeedsToAcceptWorkshopLegalAgreement) >= 1 ); + +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileResult_t_125) >= 16 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileResult_t_125, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileResult_t_125().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileResult_t_125, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileResult_t_125().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileResult_t_125, m_bUserNeedsToAcceptWorkshopLegalAgreement) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileResult_t_125().m_bUserNeedsToAcceptWorkshopLegalAgreement) >= 1 ); + +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileResult_t_123) >= 16 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileResult_t_123, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileResult_t_123) >= 12 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileResult_t_123, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileResult_t_123) >= 16 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileResult_t_123, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileResult_t_123) >= 12 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileResult_t_123, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileResult_t_116x) >= 16 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdatePublishedFileResult_t_116x, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdatePublishedFileResult_t_116x().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileResult_t_116x) >= 16 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdatePublishedFileResult_t_116x, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdatePublishedFileResult_t_116x().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileResult_t_116x) >= 16 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdatePublishedFileResult_t_116x, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdatePublishedFileResult_t_116x().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileResult_t_116x) >= 12 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileResult_t_116x, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileResult_t_116x().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdatePublishedFileResult_t_116x, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdatePublishedFileResult_t_116x().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w64_RemoteStorageUpdateUserPublishedItemVoteResult_t_123) >= 16 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdateUserPublishedItemVoteResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdateUserPublishedItemVoteResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdateUserPublishedItemVoteResult_t_123, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdateUserPublishedItemVoteResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u64_RemoteStorageUpdateUserPublishedItemVoteResult_t_123) >= 12 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdateUserPublishedItemVoteResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdateUserPublishedItemVoteResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdateUserPublishedItemVoteResult_t_123, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdateUserPublishedItemVoteResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w32_RemoteStorageUpdateUserPublishedItemVoteResult_t_123) >= 16 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdateUserPublishedItemVoteResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdateUserPublishedItemVoteResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdateUserPublishedItemVoteResult_t_123, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdateUserPublishedItemVoteResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u32_RemoteStorageUpdateUserPublishedItemVoteResult_t_123) >= 12 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdateUserPublishedItemVoteResult_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdateUserPublishedItemVoteResult_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdateUserPublishedItemVoteResult_t_123, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdateUserPublishedItemVoteResult_t_123().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w64_RemoteStorageUpdateUserPublishedItemVoteResult_t_119) >= 16 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdateUserPublishedItemVoteResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdateUserPublishedItemVoteResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageUpdateUserPublishedItemVoteResult_t_119, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageUpdateUserPublishedItemVoteResult_t_119().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u64_RemoteStorageUpdateUserPublishedItemVoteResult_t_119) >= 16 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdateUserPublishedItemVoteResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdateUserPublishedItemVoteResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageUpdateUserPublishedItemVoteResult_t_119, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageUpdateUserPublishedItemVoteResult_t_119().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w32_RemoteStorageUpdateUserPublishedItemVoteResult_t_119) >= 16 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdateUserPublishedItemVoteResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdateUserPublishedItemVoteResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageUpdateUserPublishedItemVoteResult_t_119, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageUpdateUserPublishedItemVoteResult_t_119().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u32_RemoteStorageUpdateUserPublishedItemVoteResult_t_119) >= 12 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdateUserPublishedItemVoteResult_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdateUserPublishedItemVoteResult_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageUpdateUserPublishedItemVoteResult_t_119, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageUpdateUserPublishedItemVoteResult_t_119().m_nPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w64_RemoteStorageUserVoteDetails_t_123) >= 24 ); +C_ASSERT( offsetof(w64_RemoteStorageUserVoteDetails_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageUserVoteDetails_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageUserVoteDetails_t_123, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageUserVoteDetails_t_123().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageUserVoteDetails_t_123, m_eVote) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageUserVoteDetails_t_123().m_eVote) >= 4 ); + +C_ASSERT( sizeof(u64_RemoteStorageUserVoteDetails_t_123) >= 16 ); +C_ASSERT( offsetof(u64_RemoteStorageUserVoteDetails_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageUserVoteDetails_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageUserVoteDetails_t_123, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_RemoteStorageUserVoteDetails_t_123().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageUserVoteDetails_t_123, m_eVote) == 12 ); +C_ASSERT( sizeof(u64_RemoteStorageUserVoteDetails_t_123().m_eVote) >= 4 ); + +C_ASSERT( sizeof(w32_RemoteStorageUserVoteDetails_t_123) >= 24 ); +C_ASSERT( offsetof(w32_RemoteStorageUserVoteDetails_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageUserVoteDetails_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageUserVoteDetails_t_123, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageUserVoteDetails_t_123().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageUserVoteDetails_t_123, m_eVote) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageUserVoteDetails_t_123().m_eVote) >= 4 ); + +C_ASSERT( sizeof(u32_RemoteStorageUserVoteDetails_t_123) >= 16 ); +C_ASSERT( offsetof(u32_RemoteStorageUserVoteDetails_t_123, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageUserVoteDetails_t_123().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageUserVoteDetails_t_123, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageUserVoteDetails_t_123().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageUserVoteDetails_t_123, m_eVote) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageUserVoteDetails_t_123().m_eVote) >= 4 ); + +C_ASSERT( sizeof(w64_RemoteStorageUserVoteDetails_t_119) >= 24 ); +C_ASSERT( offsetof(w64_RemoteStorageUserVoteDetails_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoteStorageUserVoteDetails_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoteStorageUserVoteDetails_t_119, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoteStorageUserVoteDetails_t_119().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_RemoteStorageUserVoteDetails_t_119, m_eVote) == 16 ); +C_ASSERT( sizeof(w64_RemoteStorageUserVoteDetails_t_119().m_eVote) >= 4 ); + +C_ASSERT( sizeof(u64_RemoteStorageUserVoteDetails_t_119) >= 24 ); +C_ASSERT( offsetof(u64_RemoteStorageUserVoteDetails_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoteStorageUserVoteDetails_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoteStorageUserVoteDetails_t_119, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(u64_RemoteStorageUserVoteDetails_t_119().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_RemoteStorageUserVoteDetails_t_119, m_eVote) == 16 ); +C_ASSERT( sizeof(u64_RemoteStorageUserVoteDetails_t_119().m_eVote) >= 4 ); + +C_ASSERT( sizeof(w32_RemoteStorageUserVoteDetails_t_119) >= 24 ); +C_ASSERT( offsetof(w32_RemoteStorageUserVoteDetails_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoteStorageUserVoteDetails_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoteStorageUserVoteDetails_t_119, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoteStorageUserVoteDetails_t_119().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_RemoteStorageUserVoteDetails_t_119, m_eVote) == 16 ); +C_ASSERT( sizeof(w32_RemoteStorageUserVoteDetails_t_119().m_eVote) >= 4 ); + +C_ASSERT( sizeof(u32_RemoteStorageUserVoteDetails_t_119) >= 16 ); +C_ASSERT( offsetof(u32_RemoteStorageUserVoteDetails_t_119, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoteStorageUserVoteDetails_t_119().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoteStorageUserVoteDetails_t_119, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoteStorageUserVoteDetails_t_119().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_RemoteStorageUserVoteDetails_t_119, m_eVote) == 12 ); +C_ASSERT( sizeof(u32_RemoteStorageUserVoteDetails_t_119().m_eVote) >= 4 ); + +C_ASSERT( sizeof(w64_RemoveAppDependencyResult_t) >= 24 ); +C_ASSERT( offsetof(w64_RemoveAppDependencyResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoveAppDependencyResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoveAppDependencyResult_t, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoveAppDependencyResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_RemoveAppDependencyResult_t, m_nAppID) == 16 ); +C_ASSERT( sizeof(w64_RemoveAppDependencyResult_t().m_nAppID) >= 4 ); + +C_ASSERT( sizeof(u64_RemoveAppDependencyResult_t) >= 16 ); +C_ASSERT( offsetof(u64_RemoveAppDependencyResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoveAppDependencyResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoveAppDependencyResult_t, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_RemoveAppDependencyResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_RemoveAppDependencyResult_t, m_nAppID) == 12 ); +C_ASSERT( sizeof(u64_RemoveAppDependencyResult_t().m_nAppID) >= 4 ); + +C_ASSERT( sizeof(w32_RemoveAppDependencyResult_t) >= 24 ); +C_ASSERT( offsetof(w32_RemoveAppDependencyResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoveAppDependencyResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoveAppDependencyResult_t, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoveAppDependencyResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_RemoveAppDependencyResult_t, m_nAppID) == 16 ); +C_ASSERT( sizeof(w32_RemoveAppDependencyResult_t().m_nAppID) >= 4 ); + +C_ASSERT( sizeof(u32_RemoveAppDependencyResult_t) >= 16 ); +C_ASSERT( offsetof(u32_RemoveAppDependencyResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoveAppDependencyResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoveAppDependencyResult_t, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoveAppDependencyResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_RemoveAppDependencyResult_t, m_nAppID) == 12 ); +C_ASSERT( sizeof(u32_RemoveAppDependencyResult_t().m_nAppID) >= 4 ); + +C_ASSERT( sizeof(w64_RemoveUGCDependencyResult_t) >= 24 ); +C_ASSERT( offsetof(w64_RemoveUGCDependencyResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RemoveUGCDependencyResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RemoveUGCDependencyResult_t, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w64_RemoveUGCDependencyResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w64_RemoveUGCDependencyResult_t, m_nChildPublishedFileId) == 16 ); +C_ASSERT( sizeof(w64_RemoveUGCDependencyResult_t().m_nChildPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u64_RemoveUGCDependencyResult_t) >= 20 ); +C_ASSERT( offsetof(u64_RemoveUGCDependencyResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RemoveUGCDependencyResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RemoveUGCDependencyResult_t, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u64_RemoveUGCDependencyResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u64_RemoveUGCDependencyResult_t, m_nChildPublishedFileId) == 12 ); +C_ASSERT( sizeof(u64_RemoveUGCDependencyResult_t().m_nChildPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w32_RemoveUGCDependencyResult_t) >= 24 ); +C_ASSERT( offsetof(w32_RemoveUGCDependencyResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RemoveUGCDependencyResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RemoveUGCDependencyResult_t, m_nPublishedFileId) == 8 ); +C_ASSERT( sizeof(w32_RemoveUGCDependencyResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(w32_RemoveUGCDependencyResult_t, m_nChildPublishedFileId) == 16 ); +C_ASSERT( sizeof(w32_RemoveUGCDependencyResult_t().m_nChildPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(u32_RemoveUGCDependencyResult_t) >= 20 ); +C_ASSERT( offsetof(u32_RemoveUGCDependencyResult_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RemoveUGCDependencyResult_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RemoveUGCDependencyResult_t, m_nPublishedFileId) == 4 ); +C_ASSERT( sizeof(u32_RemoveUGCDependencyResult_t().m_nPublishedFileId) >= 8 ); +C_ASSERT( offsetof(u32_RemoveUGCDependencyResult_t, m_nChildPublishedFileId) == 12 ); +C_ASSERT( sizeof(u32_RemoveUGCDependencyResult_t().m_nChildPublishedFileId) >= 8 ); + +C_ASSERT( sizeof(w64_RequestPlayersForGameFinalResultCallback_t) >= 24 ); +C_ASSERT( offsetof(w64_RequestPlayersForGameFinalResultCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RequestPlayersForGameFinalResultCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RequestPlayersForGameFinalResultCallback_t, m_ullSearchID) == 8 ); +C_ASSERT( sizeof(w64_RequestPlayersForGameFinalResultCallback_t().m_ullSearchID) >= 8 ); +C_ASSERT( offsetof(w64_RequestPlayersForGameFinalResultCallback_t, m_ullUniqueGameID) == 16 ); +C_ASSERT( sizeof(w64_RequestPlayersForGameFinalResultCallback_t().m_ullUniqueGameID) >= 8 ); + +C_ASSERT( sizeof(u64_RequestPlayersForGameFinalResultCallback_t) >= 20 ); +C_ASSERT( offsetof(u64_RequestPlayersForGameFinalResultCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RequestPlayersForGameFinalResultCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RequestPlayersForGameFinalResultCallback_t, m_ullSearchID) == 4 ); +C_ASSERT( sizeof(u64_RequestPlayersForGameFinalResultCallback_t().m_ullSearchID) >= 8 ); +C_ASSERT( offsetof(u64_RequestPlayersForGameFinalResultCallback_t, m_ullUniqueGameID) == 12 ); +C_ASSERT( sizeof(u64_RequestPlayersForGameFinalResultCallback_t().m_ullUniqueGameID) >= 8 ); + +C_ASSERT( sizeof(w32_RequestPlayersForGameFinalResultCallback_t) >= 24 ); +C_ASSERT( offsetof(w32_RequestPlayersForGameFinalResultCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RequestPlayersForGameFinalResultCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RequestPlayersForGameFinalResultCallback_t, m_ullSearchID) == 8 ); +C_ASSERT( sizeof(w32_RequestPlayersForGameFinalResultCallback_t().m_ullSearchID) >= 8 ); +C_ASSERT( offsetof(w32_RequestPlayersForGameFinalResultCallback_t, m_ullUniqueGameID) == 16 ); +C_ASSERT( sizeof(w32_RequestPlayersForGameFinalResultCallback_t().m_ullUniqueGameID) >= 8 ); + +C_ASSERT( sizeof(u32_RequestPlayersForGameFinalResultCallback_t) >= 20 ); +C_ASSERT( offsetof(u32_RequestPlayersForGameFinalResultCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RequestPlayersForGameFinalResultCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RequestPlayersForGameFinalResultCallback_t, m_ullSearchID) == 4 ); +C_ASSERT( sizeof(u32_RequestPlayersForGameFinalResultCallback_t().m_ullSearchID) >= 8 ); +C_ASSERT( offsetof(u32_RequestPlayersForGameFinalResultCallback_t, m_ullUniqueGameID) == 12 ); +C_ASSERT( sizeof(u32_RequestPlayersForGameFinalResultCallback_t().m_ullUniqueGameID) >= 8 ); + +C_ASSERT( sizeof(w64_RequestPlayersForGameProgressCallback_t) >= 16 ); +C_ASSERT( offsetof(w64_RequestPlayersForGameProgressCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RequestPlayersForGameProgressCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RequestPlayersForGameProgressCallback_t, m_ullSearchID) == 8 ); +C_ASSERT( sizeof(w64_RequestPlayersForGameProgressCallback_t().m_ullSearchID) >= 8 ); + +C_ASSERT( sizeof(u64_RequestPlayersForGameProgressCallback_t) >= 12 ); +C_ASSERT( offsetof(u64_RequestPlayersForGameProgressCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RequestPlayersForGameProgressCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RequestPlayersForGameProgressCallback_t, m_ullSearchID) == 4 ); +C_ASSERT( sizeof(u64_RequestPlayersForGameProgressCallback_t().m_ullSearchID) >= 8 ); + +C_ASSERT( sizeof(w32_RequestPlayersForGameProgressCallback_t) >= 16 ); +C_ASSERT( offsetof(w32_RequestPlayersForGameProgressCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RequestPlayersForGameProgressCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RequestPlayersForGameProgressCallback_t, m_ullSearchID) == 8 ); +C_ASSERT( sizeof(w32_RequestPlayersForGameProgressCallback_t().m_ullSearchID) >= 8 ); + +C_ASSERT( sizeof(u32_RequestPlayersForGameProgressCallback_t) >= 12 ); +C_ASSERT( offsetof(u32_RequestPlayersForGameProgressCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RequestPlayersForGameProgressCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RequestPlayersForGameProgressCallback_t, m_ullSearchID) == 4 ); +C_ASSERT( sizeof(u32_RequestPlayersForGameProgressCallback_t().m_ullSearchID) >= 8 ); + +C_ASSERT( sizeof(w64_RequestPlayersForGameResultCallback_t) >= 64 ); +C_ASSERT( offsetof(w64_RequestPlayersForGameResultCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_RequestPlayersForGameResultCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_RequestPlayersForGameResultCallback_t, m_ullSearchID) == 8 ); +C_ASSERT( sizeof(w64_RequestPlayersForGameResultCallback_t().m_ullSearchID) >= 8 ); +C_ASSERT( offsetof(w64_RequestPlayersForGameResultCallback_t, m_SteamIDPlayerFound) == 16 ); +C_ASSERT( sizeof(w64_RequestPlayersForGameResultCallback_t().m_SteamIDPlayerFound) >= 8 ); +C_ASSERT( offsetof(w64_RequestPlayersForGameResultCallback_t, m_SteamIDLobby) == 24 ); +C_ASSERT( sizeof(w64_RequestPlayersForGameResultCallback_t().m_SteamIDLobby) >= 8 ); +C_ASSERT( offsetof(w64_RequestPlayersForGameResultCallback_t, m_ePlayerAcceptState) == 32 ); +C_ASSERT( sizeof(w64_RequestPlayersForGameResultCallback_t().m_ePlayerAcceptState) >= 4 ); +C_ASSERT( offsetof(w64_RequestPlayersForGameResultCallback_t, m_nPlayerIndex) == 36 ); +C_ASSERT( sizeof(w64_RequestPlayersForGameResultCallback_t().m_nPlayerIndex) >= 4 ); +C_ASSERT( offsetof(w64_RequestPlayersForGameResultCallback_t, m_nTotalPlayersFound) == 40 ); +C_ASSERT( sizeof(w64_RequestPlayersForGameResultCallback_t().m_nTotalPlayersFound) >= 4 ); +C_ASSERT( offsetof(w64_RequestPlayersForGameResultCallback_t, m_nTotalPlayersAcceptedGame) == 44 ); +C_ASSERT( sizeof(w64_RequestPlayersForGameResultCallback_t().m_nTotalPlayersAcceptedGame) >= 4 ); +C_ASSERT( offsetof(w64_RequestPlayersForGameResultCallback_t, m_nSuggestedTeamIndex) == 48 ); +C_ASSERT( sizeof(w64_RequestPlayersForGameResultCallback_t().m_nSuggestedTeamIndex) >= 4 ); +C_ASSERT( offsetof(w64_RequestPlayersForGameResultCallback_t, m_ullUniqueGameID) == 56 ); +C_ASSERT( sizeof(w64_RequestPlayersForGameResultCallback_t().m_ullUniqueGameID) >= 8 ); + +C_ASSERT( sizeof(u64_RequestPlayersForGameResultCallback_t) >= 56 ); +C_ASSERT( offsetof(u64_RequestPlayersForGameResultCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_RequestPlayersForGameResultCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_RequestPlayersForGameResultCallback_t, m_ullSearchID) == 4 ); +C_ASSERT( sizeof(u64_RequestPlayersForGameResultCallback_t().m_ullSearchID) >= 8 ); +C_ASSERT( offsetof(u64_RequestPlayersForGameResultCallback_t, m_SteamIDPlayerFound) == 12 ); +C_ASSERT( sizeof(u64_RequestPlayersForGameResultCallback_t().m_SteamIDPlayerFound) >= 8 ); +C_ASSERT( offsetof(u64_RequestPlayersForGameResultCallback_t, m_SteamIDLobby) == 20 ); +C_ASSERT( sizeof(u64_RequestPlayersForGameResultCallback_t().m_SteamIDLobby) >= 8 ); +C_ASSERT( offsetof(u64_RequestPlayersForGameResultCallback_t, m_ePlayerAcceptState) == 28 ); +C_ASSERT( sizeof(u64_RequestPlayersForGameResultCallback_t().m_ePlayerAcceptState) >= 4 ); +C_ASSERT( offsetof(u64_RequestPlayersForGameResultCallback_t, m_nPlayerIndex) == 32 ); +C_ASSERT( sizeof(u64_RequestPlayersForGameResultCallback_t().m_nPlayerIndex) >= 4 ); +C_ASSERT( offsetof(u64_RequestPlayersForGameResultCallback_t, m_nTotalPlayersFound) == 36 ); +C_ASSERT( sizeof(u64_RequestPlayersForGameResultCallback_t().m_nTotalPlayersFound) >= 4 ); +C_ASSERT( offsetof(u64_RequestPlayersForGameResultCallback_t, m_nTotalPlayersAcceptedGame) == 40 ); +C_ASSERT( sizeof(u64_RequestPlayersForGameResultCallback_t().m_nTotalPlayersAcceptedGame) >= 4 ); +C_ASSERT( offsetof(u64_RequestPlayersForGameResultCallback_t, m_nSuggestedTeamIndex) == 44 ); +C_ASSERT( sizeof(u64_RequestPlayersForGameResultCallback_t().m_nSuggestedTeamIndex) >= 4 ); +C_ASSERT( offsetof(u64_RequestPlayersForGameResultCallback_t, m_ullUniqueGameID) == 48 ); +C_ASSERT( sizeof(u64_RequestPlayersForGameResultCallback_t().m_ullUniqueGameID) >= 8 ); + +C_ASSERT( sizeof(w32_RequestPlayersForGameResultCallback_t) >= 64 ); +C_ASSERT( offsetof(w32_RequestPlayersForGameResultCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_RequestPlayersForGameResultCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_RequestPlayersForGameResultCallback_t, m_ullSearchID) == 8 ); +C_ASSERT( sizeof(w32_RequestPlayersForGameResultCallback_t().m_ullSearchID) >= 8 ); +C_ASSERT( offsetof(w32_RequestPlayersForGameResultCallback_t, m_SteamIDPlayerFound) == 16 ); +C_ASSERT( sizeof(w32_RequestPlayersForGameResultCallback_t().m_SteamIDPlayerFound) >= 8 ); +C_ASSERT( offsetof(w32_RequestPlayersForGameResultCallback_t, m_SteamIDLobby) == 24 ); +C_ASSERT( sizeof(w32_RequestPlayersForGameResultCallback_t().m_SteamIDLobby) >= 8 ); +C_ASSERT( offsetof(w32_RequestPlayersForGameResultCallback_t, m_ePlayerAcceptState) == 32 ); +C_ASSERT( sizeof(w32_RequestPlayersForGameResultCallback_t().m_ePlayerAcceptState) >= 4 ); +C_ASSERT( offsetof(w32_RequestPlayersForGameResultCallback_t, m_nPlayerIndex) == 36 ); +C_ASSERT( sizeof(w32_RequestPlayersForGameResultCallback_t().m_nPlayerIndex) >= 4 ); +C_ASSERT( offsetof(w32_RequestPlayersForGameResultCallback_t, m_nTotalPlayersFound) == 40 ); +C_ASSERT( sizeof(w32_RequestPlayersForGameResultCallback_t().m_nTotalPlayersFound) >= 4 ); +C_ASSERT( offsetof(w32_RequestPlayersForGameResultCallback_t, m_nTotalPlayersAcceptedGame) == 44 ); +C_ASSERT( sizeof(w32_RequestPlayersForGameResultCallback_t().m_nTotalPlayersAcceptedGame) >= 4 ); +C_ASSERT( offsetof(w32_RequestPlayersForGameResultCallback_t, m_nSuggestedTeamIndex) == 48 ); +C_ASSERT( sizeof(w32_RequestPlayersForGameResultCallback_t().m_nSuggestedTeamIndex) >= 4 ); +C_ASSERT( offsetof(w32_RequestPlayersForGameResultCallback_t, m_ullUniqueGameID) == 56 ); +C_ASSERT( sizeof(w32_RequestPlayersForGameResultCallback_t().m_ullUniqueGameID) >= 8 ); + +C_ASSERT( sizeof(u32_RequestPlayersForGameResultCallback_t) >= 56 ); +C_ASSERT( offsetof(u32_RequestPlayersForGameResultCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_RequestPlayersForGameResultCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_RequestPlayersForGameResultCallback_t, m_ullSearchID) == 4 ); +C_ASSERT( sizeof(u32_RequestPlayersForGameResultCallback_t().m_ullSearchID) >= 8 ); +C_ASSERT( offsetof(u32_RequestPlayersForGameResultCallback_t, m_SteamIDPlayerFound) == 12 ); +C_ASSERT( sizeof(u32_RequestPlayersForGameResultCallback_t().m_SteamIDPlayerFound) >= 8 ); +C_ASSERT( offsetof(u32_RequestPlayersForGameResultCallback_t, m_SteamIDLobby) == 20 ); +C_ASSERT( sizeof(u32_RequestPlayersForGameResultCallback_t().m_SteamIDLobby) >= 8 ); +C_ASSERT( offsetof(u32_RequestPlayersForGameResultCallback_t, m_ePlayerAcceptState) == 28 ); +C_ASSERT( sizeof(u32_RequestPlayersForGameResultCallback_t().m_ePlayerAcceptState) >= 4 ); +C_ASSERT( offsetof(u32_RequestPlayersForGameResultCallback_t, m_nPlayerIndex) == 32 ); +C_ASSERT( sizeof(u32_RequestPlayersForGameResultCallback_t().m_nPlayerIndex) >= 4 ); +C_ASSERT( offsetof(u32_RequestPlayersForGameResultCallback_t, m_nTotalPlayersFound) == 36 ); +C_ASSERT( sizeof(u32_RequestPlayersForGameResultCallback_t().m_nTotalPlayersFound) >= 4 ); +C_ASSERT( offsetof(u32_RequestPlayersForGameResultCallback_t, m_nTotalPlayersAcceptedGame) == 40 ); +C_ASSERT( sizeof(u32_RequestPlayersForGameResultCallback_t().m_nTotalPlayersAcceptedGame) >= 4 ); +C_ASSERT( offsetof(u32_RequestPlayersForGameResultCallback_t, m_nSuggestedTeamIndex) == 44 ); +C_ASSERT( sizeof(u32_RequestPlayersForGameResultCallback_t().m_nSuggestedTeamIndex) >= 4 ); +C_ASSERT( offsetof(u32_RequestPlayersForGameResultCallback_t, m_ullUniqueGameID) == 48 ); +C_ASSERT( sizeof(u32_RequestPlayersForGameResultCallback_t().m_ullUniqueGameID) >= 8 ); + +C_ASSERT( sizeof(w64_SteamInputConfigurationLoaded_t) >= 40 ); +C_ASSERT( offsetof(w64_SteamInputConfigurationLoaded_t, m_unAppID) == 0 ); +C_ASSERT( sizeof(w64_SteamInputConfigurationLoaded_t().m_unAppID) >= 4 ); +C_ASSERT( offsetof(w64_SteamInputConfigurationLoaded_t, m_ulDeviceHandle) == 8 ); +C_ASSERT( sizeof(w64_SteamInputConfigurationLoaded_t().m_ulDeviceHandle) >= 8 ); +C_ASSERT( offsetof(w64_SteamInputConfigurationLoaded_t, m_ulMappingCreator) == 16 ); +C_ASSERT( sizeof(w64_SteamInputConfigurationLoaded_t().m_ulMappingCreator) >= 8 ); +C_ASSERT( offsetof(w64_SteamInputConfigurationLoaded_t, m_unMajorRevision) == 24 ); +C_ASSERT( sizeof(w64_SteamInputConfigurationLoaded_t().m_unMajorRevision) >= 4 ); +C_ASSERT( offsetof(w64_SteamInputConfigurationLoaded_t, m_unMinorRevision) == 28 ); +C_ASSERT( sizeof(w64_SteamInputConfigurationLoaded_t().m_unMinorRevision) >= 4 ); +C_ASSERT( offsetof(w64_SteamInputConfigurationLoaded_t, m_bUsesSteamInputAPI) == 32 ); +C_ASSERT( sizeof(w64_SteamInputConfigurationLoaded_t().m_bUsesSteamInputAPI) >= 1 ); +C_ASSERT( offsetof(w64_SteamInputConfigurationLoaded_t, m_bUsesGamepadAPI) == 33 ); +C_ASSERT( sizeof(w64_SteamInputConfigurationLoaded_t().m_bUsesGamepadAPI) >= 1 ); + +C_ASSERT( sizeof(u64_SteamInputConfigurationLoaded_t) >= 32 ); +C_ASSERT( offsetof(u64_SteamInputConfigurationLoaded_t, m_unAppID) == 0 ); +C_ASSERT( sizeof(u64_SteamInputConfigurationLoaded_t().m_unAppID) >= 4 ); +C_ASSERT( offsetof(u64_SteamInputConfigurationLoaded_t, m_ulDeviceHandle) == 4 ); +C_ASSERT( sizeof(u64_SteamInputConfigurationLoaded_t().m_ulDeviceHandle) >= 8 ); +C_ASSERT( offsetof(u64_SteamInputConfigurationLoaded_t, m_ulMappingCreator) == 12 ); +C_ASSERT( sizeof(u64_SteamInputConfigurationLoaded_t().m_ulMappingCreator) >= 8 ); +C_ASSERT( offsetof(u64_SteamInputConfigurationLoaded_t, m_unMajorRevision) == 20 ); +C_ASSERT( sizeof(u64_SteamInputConfigurationLoaded_t().m_unMajorRevision) >= 4 ); +C_ASSERT( offsetof(u64_SteamInputConfigurationLoaded_t, m_unMinorRevision) == 24 ); +C_ASSERT( sizeof(u64_SteamInputConfigurationLoaded_t().m_unMinorRevision) >= 4 ); +C_ASSERT( offsetof(u64_SteamInputConfigurationLoaded_t, m_bUsesSteamInputAPI) == 28 ); +C_ASSERT( sizeof(u64_SteamInputConfigurationLoaded_t().m_bUsesSteamInputAPI) >= 1 ); +C_ASSERT( offsetof(u64_SteamInputConfigurationLoaded_t, m_bUsesGamepadAPI) == 29 ); +C_ASSERT( sizeof(u64_SteamInputConfigurationLoaded_t().m_bUsesGamepadAPI) >= 1 ); + +C_ASSERT( sizeof(w32_SteamInputConfigurationLoaded_t) >= 40 ); +C_ASSERT( offsetof(w32_SteamInputConfigurationLoaded_t, m_unAppID) == 0 ); +C_ASSERT( sizeof(w32_SteamInputConfigurationLoaded_t().m_unAppID) >= 4 ); +C_ASSERT( offsetof(w32_SteamInputConfigurationLoaded_t, m_ulDeviceHandle) == 8 ); +C_ASSERT( sizeof(w32_SteamInputConfigurationLoaded_t().m_ulDeviceHandle) >= 8 ); +C_ASSERT( offsetof(w32_SteamInputConfigurationLoaded_t, m_ulMappingCreator) == 16 ); +C_ASSERT( sizeof(w32_SteamInputConfigurationLoaded_t().m_ulMappingCreator) >= 8 ); +C_ASSERT( offsetof(w32_SteamInputConfigurationLoaded_t, m_unMajorRevision) == 24 ); +C_ASSERT( sizeof(w32_SteamInputConfigurationLoaded_t().m_unMajorRevision) >= 4 ); +C_ASSERT( offsetof(w32_SteamInputConfigurationLoaded_t, m_unMinorRevision) == 28 ); +C_ASSERT( sizeof(w32_SteamInputConfigurationLoaded_t().m_unMinorRevision) >= 4 ); +C_ASSERT( offsetof(w32_SteamInputConfigurationLoaded_t, m_bUsesSteamInputAPI) == 32 ); +C_ASSERT( sizeof(w32_SteamInputConfigurationLoaded_t().m_bUsesSteamInputAPI) >= 1 ); +C_ASSERT( offsetof(w32_SteamInputConfigurationLoaded_t, m_bUsesGamepadAPI) == 33 ); +C_ASSERT( sizeof(w32_SteamInputConfigurationLoaded_t().m_bUsesGamepadAPI) >= 1 ); + +C_ASSERT( sizeof(u32_SteamInputConfigurationLoaded_t) >= 32 ); +C_ASSERT( offsetof(u32_SteamInputConfigurationLoaded_t, m_unAppID) == 0 ); +C_ASSERT( sizeof(u32_SteamInputConfigurationLoaded_t().m_unAppID) >= 4 ); +C_ASSERT( offsetof(u32_SteamInputConfigurationLoaded_t, m_ulDeviceHandle) == 4 ); +C_ASSERT( sizeof(u32_SteamInputConfigurationLoaded_t().m_ulDeviceHandle) >= 8 ); +C_ASSERT( offsetof(u32_SteamInputConfigurationLoaded_t, m_ulMappingCreator) == 12 ); +C_ASSERT( sizeof(u32_SteamInputConfigurationLoaded_t().m_ulMappingCreator) >= 8 ); +C_ASSERT( offsetof(u32_SteamInputConfigurationLoaded_t, m_unMajorRevision) == 20 ); +C_ASSERT( sizeof(u32_SteamInputConfigurationLoaded_t().m_unMajorRevision) >= 4 ); +C_ASSERT( offsetof(u32_SteamInputConfigurationLoaded_t, m_unMinorRevision) == 24 ); +C_ASSERT( sizeof(u32_SteamInputConfigurationLoaded_t().m_unMinorRevision) >= 4 ); +C_ASSERT( offsetof(u32_SteamInputConfigurationLoaded_t, m_bUsesSteamInputAPI) == 28 ); +C_ASSERT( sizeof(u32_SteamInputConfigurationLoaded_t().m_bUsesSteamInputAPI) >= 1 ); +C_ASSERT( offsetof(u32_SteamInputConfigurationLoaded_t, m_bUsesGamepadAPI) == 29 ); +C_ASSERT( sizeof(u32_SteamInputConfigurationLoaded_t().m_bUsesGamepadAPI) >= 1 ); + +C_ASSERT( sizeof(w64_SteamInputGamepadSlotChange_t) >= 32 ); +C_ASSERT( offsetof(w64_SteamInputGamepadSlotChange_t, m_unAppID) == 0 ); +C_ASSERT( sizeof(w64_SteamInputGamepadSlotChange_t().m_unAppID) >= 4 ); +C_ASSERT( offsetof(w64_SteamInputGamepadSlotChange_t, m_ulDeviceHandle) == 8 ); +C_ASSERT( sizeof(w64_SteamInputGamepadSlotChange_t().m_ulDeviceHandle) >= 8 ); +C_ASSERT( offsetof(w64_SteamInputGamepadSlotChange_t, m_eDeviceType) == 16 ); +C_ASSERT( sizeof(w64_SteamInputGamepadSlotChange_t().m_eDeviceType) >= 4 ); +C_ASSERT( offsetof(w64_SteamInputGamepadSlotChange_t, m_nOldGamepadSlot) == 20 ); +C_ASSERT( sizeof(w64_SteamInputGamepadSlotChange_t().m_nOldGamepadSlot) >= 4 ); +C_ASSERT( offsetof(w64_SteamInputGamepadSlotChange_t, m_nNewGamepadSlot) == 24 ); +C_ASSERT( sizeof(w64_SteamInputGamepadSlotChange_t().m_nNewGamepadSlot) >= 4 ); + +C_ASSERT( sizeof(u64_SteamInputGamepadSlotChange_t) >= 24 ); +C_ASSERT( offsetof(u64_SteamInputGamepadSlotChange_t, m_unAppID) == 0 ); +C_ASSERT( sizeof(u64_SteamInputGamepadSlotChange_t().m_unAppID) >= 4 ); +C_ASSERT( offsetof(u64_SteamInputGamepadSlotChange_t, m_ulDeviceHandle) == 4 ); +C_ASSERT( sizeof(u64_SteamInputGamepadSlotChange_t().m_ulDeviceHandle) >= 8 ); +C_ASSERT( offsetof(u64_SteamInputGamepadSlotChange_t, m_eDeviceType) == 12 ); +C_ASSERT( sizeof(u64_SteamInputGamepadSlotChange_t().m_eDeviceType) >= 4 ); +C_ASSERT( offsetof(u64_SteamInputGamepadSlotChange_t, m_nOldGamepadSlot) == 16 ); +C_ASSERT( sizeof(u64_SteamInputGamepadSlotChange_t().m_nOldGamepadSlot) >= 4 ); +C_ASSERT( offsetof(u64_SteamInputGamepadSlotChange_t, m_nNewGamepadSlot) == 20 ); +C_ASSERT( sizeof(u64_SteamInputGamepadSlotChange_t().m_nNewGamepadSlot) >= 4 ); + +C_ASSERT( sizeof(w32_SteamInputGamepadSlotChange_t) >= 32 ); +C_ASSERT( offsetof(w32_SteamInputGamepadSlotChange_t, m_unAppID) == 0 ); +C_ASSERT( sizeof(w32_SteamInputGamepadSlotChange_t().m_unAppID) >= 4 ); +C_ASSERT( offsetof(w32_SteamInputGamepadSlotChange_t, m_ulDeviceHandle) == 8 ); +C_ASSERT( sizeof(w32_SteamInputGamepadSlotChange_t().m_ulDeviceHandle) >= 8 ); +C_ASSERT( offsetof(w32_SteamInputGamepadSlotChange_t, m_eDeviceType) == 16 ); +C_ASSERT( sizeof(w32_SteamInputGamepadSlotChange_t().m_eDeviceType) >= 4 ); +C_ASSERT( offsetof(w32_SteamInputGamepadSlotChange_t, m_nOldGamepadSlot) == 20 ); +C_ASSERT( sizeof(w32_SteamInputGamepadSlotChange_t().m_nOldGamepadSlot) >= 4 ); +C_ASSERT( offsetof(w32_SteamInputGamepadSlotChange_t, m_nNewGamepadSlot) == 24 ); +C_ASSERT( sizeof(w32_SteamInputGamepadSlotChange_t().m_nNewGamepadSlot) >= 4 ); + +C_ASSERT( sizeof(u32_SteamInputGamepadSlotChange_t) >= 24 ); +C_ASSERT( offsetof(u32_SteamInputGamepadSlotChange_t, m_unAppID) == 0 ); +C_ASSERT( sizeof(u32_SteamInputGamepadSlotChange_t().m_unAppID) >= 4 ); +C_ASSERT( offsetof(u32_SteamInputGamepadSlotChange_t, m_ulDeviceHandle) == 4 ); +C_ASSERT( sizeof(u32_SteamInputGamepadSlotChange_t().m_ulDeviceHandle) >= 8 ); +C_ASSERT( offsetof(u32_SteamInputGamepadSlotChange_t, m_eDeviceType) == 12 ); +C_ASSERT( sizeof(u32_SteamInputGamepadSlotChange_t().m_eDeviceType) >= 4 ); +C_ASSERT( offsetof(u32_SteamInputGamepadSlotChange_t, m_nOldGamepadSlot) == 16 ); +C_ASSERT( sizeof(u32_SteamInputGamepadSlotChange_t().m_nOldGamepadSlot) >= 4 ); +C_ASSERT( offsetof(u32_SteamInputGamepadSlotChange_t, m_nNewGamepadSlot) == 20 ); +C_ASSERT( sizeof(u32_SteamInputGamepadSlotChange_t().m_nNewGamepadSlot) >= 4 ); + +C_ASSERT( sizeof(w64_SteamInventoryStartPurchaseResult_t) >= 24 ); +C_ASSERT( offsetof(w64_SteamInventoryStartPurchaseResult_t, m_result) == 0 ); +C_ASSERT( sizeof(w64_SteamInventoryStartPurchaseResult_t().m_result) >= 4 ); +C_ASSERT( offsetof(w64_SteamInventoryStartPurchaseResult_t, m_ulOrderID) == 8 ); +C_ASSERT( sizeof(w64_SteamInventoryStartPurchaseResult_t().m_ulOrderID) >= 8 ); +C_ASSERT( offsetof(w64_SteamInventoryStartPurchaseResult_t, m_ulTransID) == 16 ); +C_ASSERT( sizeof(w64_SteamInventoryStartPurchaseResult_t().m_ulTransID) >= 8 ); + +C_ASSERT( sizeof(u64_SteamInventoryStartPurchaseResult_t) >= 20 ); +C_ASSERT( offsetof(u64_SteamInventoryStartPurchaseResult_t, m_result) == 0 ); +C_ASSERT( sizeof(u64_SteamInventoryStartPurchaseResult_t().m_result) >= 4 ); +C_ASSERT( offsetof(u64_SteamInventoryStartPurchaseResult_t, m_ulOrderID) == 4 ); +C_ASSERT( sizeof(u64_SteamInventoryStartPurchaseResult_t().m_ulOrderID) >= 8 ); +C_ASSERT( offsetof(u64_SteamInventoryStartPurchaseResult_t, m_ulTransID) == 12 ); +C_ASSERT( sizeof(u64_SteamInventoryStartPurchaseResult_t().m_ulTransID) >= 8 ); + +C_ASSERT( sizeof(w32_SteamInventoryStartPurchaseResult_t) >= 24 ); +C_ASSERT( offsetof(w32_SteamInventoryStartPurchaseResult_t, m_result) == 0 ); +C_ASSERT( sizeof(w32_SteamInventoryStartPurchaseResult_t().m_result) >= 4 ); +C_ASSERT( offsetof(w32_SteamInventoryStartPurchaseResult_t, m_ulOrderID) == 8 ); +C_ASSERT( sizeof(w32_SteamInventoryStartPurchaseResult_t().m_ulOrderID) >= 8 ); +C_ASSERT( offsetof(w32_SteamInventoryStartPurchaseResult_t, m_ulTransID) == 16 ); +C_ASSERT( sizeof(w32_SteamInventoryStartPurchaseResult_t().m_ulTransID) >= 8 ); + +C_ASSERT( sizeof(u32_SteamInventoryStartPurchaseResult_t) >= 20 ); +C_ASSERT( offsetof(u32_SteamInventoryStartPurchaseResult_t, m_result) == 0 ); +C_ASSERT( sizeof(u32_SteamInventoryStartPurchaseResult_t().m_result) >= 4 ); +C_ASSERT( offsetof(u32_SteamInventoryStartPurchaseResult_t, m_ulOrderID) == 4 ); +C_ASSERT( sizeof(u32_SteamInventoryStartPurchaseResult_t().m_ulOrderID) >= 8 ); +C_ASSERT( offsetof(u32_SteamInventoryStartPurchaseResult_t, m_ulTransID) == 12 ); +C_ASSERT( sizeof(u32_SteamInventoryStartPurchaseResult_t().m_ulTransID) >= 8 ); + +C_ASSERT( sizeof(w64_SteamNetConnectionStatusChangedCallback_t_153a) >= 712 ); +C_ASSERT( offsetof(w64_SteamNetConnectionStatusChangedCallback_t_153a, m_hConn) == 0 ); +C_ASSERT( sizeof(w64_SteamNetConnectionStatusChangedCallback_t_153a().m_hConn) >= 4 ); +C_ASSERT( offsetof(w64_SteamNetConnectionStatusChangedCallback_t_153a, m_info) == 8 ); +C_ASSERT( sizeof(w64_SteamNetConnectionStatusChangedCallback_t_153a().m_info) >= 696 ); +C_ASSERT( offsetof(w64_SteamNetConnectionStatusChangedCallback_t_153a, m_eOldState) == 704 ); +C_ASSERT( sizeof(w64_SteamNetConnectionStatusChangedCallback_t_153a().m_eOldState) >= 4 ); + +C_ASSERT( sizeof(u64_SteamNetConnectionStatusChangedCallback_t_153a) >= 704 ); +C_ASSERT( offsetof(u64_SteamNetConnectionStatusChangedCallback_t_153a, m_hConn) == 0 ); +C_ASSERT( sizeof(u64_SteamNetConnectionStatusChangedCallback_t_153a().m_hConn) >= 4 ); +C_ASSERT( offsetof(u64_SteamNetConnectionStatusChangedCallback_t_153a, m_info) == 4 ); +C_ASSERT( sizeof(u64_SteamNetConnectionStatusChangedCallback_t_153a().m_info) >= 696 ); +C_ASSERT( offsetof(u64_SteamNetConnectionStatusChangedCallback_t_153a, m_eOldState) == 700 ); +C_ASSERT( sizeof(u64_SteamNetConnectionStatusChangedCallback_t_153a().m_eOldState) >= 4 ); + +C_ASSERT( sizeof(w32_SteamNetConnectionStatusChangedCallback_t_153a) >= 712 ); +C_ASSERT( offsetof(w32_SteamNetConnectionStatusChangedCallback_t_153a, m_hConn) == 0 ); +C_ASSERT( sizeof(w32_SteamNetConnectionStatusChangedCallback_t_153a().m_hConn) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetConnectionStatusChangedCallback_t_153a, m_info) == 8 ); +C_ASSERT( sizeof(w32_SteamNetConnectionStatusChangedCallback_t_153a().m_info) >= 696 ); +C_ASSERT( offsetof(w32_SteamNetConnectionStatusChangedCallback_t_153a, m_eOldState) == 704 ); +C_ASSERT( sizeof(w32_SteamNetConnectionStatusChangedCallback_t_153a().m_eOldState) >= 4 ); + +C_ASSERT( sizeof(u32_SteamNetConnectionStatusChangedCallback_t_153a) >= 704 ); +C_ASSERT( offsetof(u32_SteamNetConnectionStatusChangedCallback_t_153a, m_hConn) == 0 ); +C_ASSERT( sizeof(u32_SteamNetConnectionStatusChangedCallback_t_153a().m_hConn) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetConnectionStatusChangedCallback_t_153a, m_info) == 4 ); +C_ASSERT( sizeof(u32_SteamNetConnectionStatusChangedCallback_t_153a().m_info) >= 696 ); +C_ASSERT( offsetof(u32_SteamNetConnectionStatusChangedCallback_t_153a, m_eOldState) == 700 ); +C_ASSERT( sizeof(u32_SteamNetConnectionStatusChangedCallback_t_153a().m_eOldState) >= 4 ); + +C_ASSERT( sizeof(w64_SteamNetConnectionStatusChangedCallback_t_144) >= 712 ); +C_ASSERT( offsetof(w64_SteamNetConnectionStatusChangedCallback_t_144, m_hConn) == 0 ); +C_ASSERT( sizeof(w64_SteamNetConnectionStatusChangedCallback_t_144().m_hConn) >= 4 ); +C_ASSERT( offsetof(w64_SteamNetConnectionStatusChangedCallback_t_144, m_info) == 8 ); +C_ASSERT( sizeof(w64_SteamNetConnectionStatusChangedCallback_t_144().m_info) >= 696 ); +C_ASSERT( offsetof(w64_SteamNetConnectionStatusChangedCallback_t_144, m_eOldState) == 704 ); +C_ASSERT( sizeof(w64_SteamNetConnectionStatusChangedCallback_t_144().m_eOldState) >= 4 ); + +C_ASSERT( sizeof(u64_SteamNetConnectionStatusChangedCallback_t_144) >= 704 ); +C_ASSERT( offsetof(u64_SteamNetConnectionStatusChangedCallback_t_144, m_hConn) == 0 ); +C_ASSERT( sizeof(u64_SteamNetConnectionStatusChangedCallback_t_144().m_hConn) >= 4 ); +C_ASSERT( offsetof(u64_SteamNetConnectionStatusChangedCallback_t_144, m_info) == 4 ); +C_ASSERT( sizeof(u64_SteamNetConnectionStatusChangedCallback_t_144().m_info) >= 696 ); +C_ASSERT( offsetof(u64_SteamNetConnectionStatusChangedCallback_t_144, m_eOldState) == 700 ); +C_ASSERT( sizeof(u64_SteamNetConnectionStatusChangedCallback_t_144().m_eOldState) >= 4 ); + +C_ASSERT( sizeof(w32_SteamNetConnectionStatusChangedCallback_t_144) >= 712 ); +C_ASSERT( offsetof(w32_SteamNetConnectionStatusChangedCallback_t_144, m_hConn) == 0 ); +C_ASSERT( sizeof(w32_SteamNetConnectionStatusChangedCallback_t_144().m_hConn) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetConnectionStatusChangedCallback_t_144, m_info) == 8 ); +C_ASSERT( sizeof(w32_SteamNetConnectionStatusChangedCallback_t_144().m_info) >= 696 ); +C_ASSERT( offsetof(w32_SteamNetConnectionStatusChangedCallback_t_144, m_eOldState) == 704 ); +C_ASSERT( sizeof(w32_SteamNetConnectionStatusChangedCallback_t_144().m_eOldState) >= 4 ); + +C_ASSERT( sizeof(u32_SteamNetConnectionStatusChangedCallback_t_144) >= 704 ); +C_ASSERT( offsetof(u32_SteamNetConnectionStatusChangedCallback_t_144, m_hConn) == 0 ); +C_ASSERT( sizeof(u32_SteamNetConnectionStatusChangedCallback_t_144().m_hConn) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetConnectionStatusChangedCallback_t_144, m_info) == 4 ); +C_ASSERT( sizeof(u32_SteamNetConnectionStatusChangedCallback_t_144().m_info) >= 696 ); +C_ASSERT( offsetof(u32_SteamNetConnectionStatusChangedCallback_t_144, m_eOldState) == 700 ); +C_ASSERT( sizeof(u32_SteamNetConnectionStatusChangedCallback_t_144().m_eOldState) >= 4 ); + +C_ASSERT( sizeof(w64_SteamNetConnectionStatusChangedCallback_t_151) >= 584 ); +C_ASSERT( offsetof(w64_SteamNetConnectionStatusChangedCallback_t_151, m_hConn) == 0 ); +C_ASSERT( sizeof(w64_SteamNetConnectionStatusChangedCallback_t_151().m_hConn) >= 4 ); +C_ASSERT( offsetof(w64_SteamNetConnectionStatusChangedCallback_t_151, m_info) == 8 ); +C_ASSERT( sizeof(w64_SteamNetConnectionStatusChangedCallback_t_151().m_info) >= 568 ); +C_ASSERT( offsetof(w64_SteamNetConnectionStatusChangedCallback_t_151, m_eOldState) == 576 ); +C_ASSERT( sizeof(w64_SteamNetConnectionStatusChangedCallback_t_151().m_eOldState) >= 4 ); + +C_ASSERT( sizeof(u64_SteamNetConnectionStatusChangedCallback_t_151) >= 576 ); +C_ASSERT( offsetof(u64_SteamNetConnectionStatusChangedCallback_t_151, m_hConn) == 0 ); +C_ASSERT( sizeof(u64_SteamNetConnectionStatusChangedCallback_t_151().m_hConn) >= 4 ); +C_ASSERT( offsetof(u64_SteamNetConnectionStatusChangedCallback_t_151, m_info) == 4 ); +C_ASSERT( sizeof(u64_SteamNetConnectionStatusChangedCallback_t_151().m_info) >= 568 ); +C_ASSERT( offsetof(u64_SteamNetConnectionStatusChangedCallback_t_151, m_eOldState) == 572 ); +C_ASSERT( sizeof(u64_SteamNetConnectionStatusChangedCallback_t_151().m_eOldState) >= 4 ); + +C_ASSERT( sizeof(w32_SteamNetConnectionStatusChangedCallback_t_151) >= 584 ); +C_ASSERT( offsetof(w32_SteamNetConnectionStatusChangedCallback_t_151, m_hConn) == 0 ); +C_ASSERT( sizeof(w32_SteamNetConnectionStatusChangedCallback_t_151().m_hConn) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetConnectionStatusChangedCallback_t_151, m_info) == 8 ); +C_ASSERT( sizeof(w32_SteamNetConnectionStatusChangedCallback_t_151().m_info) >= 568 ); +C_ASSERT( offsetof(w32_SteamNetConnectionStatusChangedCallback_t_151, m_eOldState) == 576 ); +C_ASSERT( sizeof(w32_SteamNetConnectionStatusChangedCallback_t_151().m_eOldState) >= 4 ); + +C_ASSERT( sizeof(u32_SteamNetConnectionStatusChangedCallback_t_151) >= 576 ); +C_ASSERT( offsetof(u32_SteamNetConnectionStatusChangedCallback_t_151, m_hConn) == 0 ); +C_ASSERT( sizeof(u32_SteamNetConnectionStatusChangedCallback_t_151().m_hConn) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetConnectionStatusChangedCallback_t_151, m_info) == 4 ); +C_ASSERT( sizeof(u32_SteamNetConnectionStatusChangedCallback_t_151().m_info) >= 568 ); +C_ASSERT( offsetof(u32_SteamNetConnectionStatusChangedCallback_t_151, m_eOldState) == 572 ); +C_ASSERT( sizeof(u32_SteamNetConnectionStatusChangedCallback_t_151().m_eOldState) >= 4 ); + +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_153a) >= 216 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_153a, m_pData) == 0 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_153a().m_pData) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_153a, m_cbSize) == 8 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_153a().m_cbSize) >= 4 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_153a, m_conn) == 12 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_153a().m_conn) >= 4 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_153a, m_identityPeer) == 16 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_153a().m_identityPeer) >= 136 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_153a, m_nConnUserData) == 152 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_153a().m_nConnUserData) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_153a, m_usecTimeReceived) == 160 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_153a().m_usecTimeReceived) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_153a, m_nMessageNumber) == 168 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_153a().m_nMessageNumber) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_153a, m_pfnFreeData) == 176 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_153a().m_pfnFreeData) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_153a, m_pfnRelease) == 184 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_153a().m_pfnRelease) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_153a, m_nChannel) == 192 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_153a().m_nChannel) >= 4 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_153a, m_nFlags) == 196 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_153a().m_nFlags) >= 4 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_153a, m_nUserData) == 200 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_153a().m_nUserData) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_153a, m_idxLane) == 208 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_153a().m_idxLane) >= 2 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_153a, _pad1__) == 210 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_153a()._pad1__) >= 2 ); + +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_153a) >= 216 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_153a, m_pData) == 0 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_153a().m_pData) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_153a, m_cbSize) == 8 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_153a().m_cbSize) >= 4 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_153a, m_conn) == 12 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_153a().m_conn) >= 4 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_153a, m_identityPeer) == 16 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_153a().m_identityPeer) >= 136 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_153a, m_nConnUserData) == 152 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_153a().m_nConnUserData) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_153a, m_usecTimeReceived) == 160 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_153a().m_usecTimeReceived) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_153a, m_nMessageNumber) == 168 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_153a().m_nMessageNumber) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_153a, m_pfnFreeData) == 176 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_153a().m_pfnFreeData) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_153a, m_pfnRelease) == 184 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_153a().m_pfnRelease) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_153a, m_nChannel) == 192 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_153a().m_nChannel) >= 4 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_153a, m_nFlags) == 196 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_153a().m_nFlags) >= 4 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_153a, m_nUserData) == 200 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_153a().m_nUserData) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_153a, m_idxLane) == 208 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_153a().m_idxLane) >= 2 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_153a, _pad1__) == 210 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_153a()._pad1__) >= 2 ); + +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_153a) >= 208 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_153a, m_pData) == 0 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_153a().m_pData) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_153a, m_cbSize) == 4 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_153a().m_cbSize) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_153a, m_conn) == 8 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_153a().m_conn) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_153a, m_identityPeer) == 12 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_153a().m_identityPeer) >= 136 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_153a, m_nConnUserData) == 152 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_153a().m_nConnUserData) >= 8 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_153a, m_usecTimeReceived) == 160 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_153a().m_usecTimeReceived) >= 8 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_153a, m_nMessageNumber) == 168 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_153a().m_nMessageNumber) >= 8 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_153a, m_pfnFreeData) == 176 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_153a().m_pfnFreeData) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_153a, m_pfnRelease) == 180 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_153a().m_pfnRelease) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_153a, m_nChannel) == 184 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_153a().m_nChannel) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_153a, m_nFlags) == 188 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_153a().m_nFlags) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_153a, m_nUserData) == 192 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_153a().m_nUserData) >= 8 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_153a, m_idxLane) == 200 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_153a().m_idxLane) >= 2 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_153a, _pad1__) == 202 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_153a()._pad1__) >= 2 ); + +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_153a) >= 200 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_153a, m_pData) == 0 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_153a().m_pData) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_153a, m_cbSize) == 4 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_153a().m_cbSize) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_153a, m_conn) == 8 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_153a().m_conn) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_153a, m_identityPeer) == 12 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_153a().m_identityPeer) >= 136 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_153a, m_nConnUserData) == 148 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_153a().m_nConnUserData) >= 8 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_153a, m_usecTimeReceived) == 156 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_153a().m_usecTimeReceived) >= 8 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_153a, m_nMessageNumber) == 164 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_153a().m_nMessageNumber) >= 8 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_153a, m_pfnFreeData) == 172 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_153a().m_pfnFreeData) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_153a, m_pfnRelease) == 176 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_153a().m_pfnRelease) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_153a, m_nChannel) == 180 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_153a().m_nChannel) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_153a, m_nFlags) == 184 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_153a().m_nFlags) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_153a, m_nUserData) == 188 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_153a().m_nUserData) >= 8 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_153a, m_idxLane) == 196 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_153a().m_idxLane) >= 2 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_153a, _pad1__) == 198 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_153a()._pad1__) >= 2 ); + +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_147) >= 208 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_147, m_pData) == 0 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_147().m_pData) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_147, m_cbSize) == 8 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_147().m_cbSize) >= 4 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_147, m_conn) == 12 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_147().m_conn) >= 4 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_147, m_identityPeer) == 16 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_147().m_identityPeer) >= 136 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_147, m_nConnUserData) == 152 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_147().m_nConnUserData) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_147, m_usecTimeReceived) == 160 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_147().m_usecTimeReceived) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_147, m_nMessageNumber) == 168 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_147().m_nMessageNumber) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_147, m_pfnFreeData) == 176 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_147().m_pfnFreeData) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_147, m_pfnRelease) == 184 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_147().m_pfnRelease) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_147, m_nChannel) == 192 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_147().m_nChannel) >= 4 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_147, m_nFlags) == 196 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_147().m_nFlags) >= 4 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_147, m_nUserData) == 200 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_147().m_nUserData) >= 8 ); + +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_147) >= 208 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_147, m_pData) == 0 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_147().m_pData) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_147, m_cbSize) == 8 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_147().m_cbSize) >= 4 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_147, m_conn) == 12 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_147().m_conn) >= 4 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_147, m_identityPeer) == 16 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_147().m_identityPeer) >= 136 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_147, m_nConnUserData) == 152 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_147().m_nConnUserData) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_147, m_usecTimeReceived) == 160 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_147().m_usecTimeReceived) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_147, m_nMessageNumber) == 168 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_147().m_nMessageNumber) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_147, m_pfnFreeData) == 176 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_147().m_pfnFreeData) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_147, m_pfnRelease) == 184 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_147().m_pfnRelease) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_147, m_nChannel) == 192 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_147().m_nChannel) >= 4 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_147, m_nFlags) == 196 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_147().m_nFlags) >= 4 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_147, m_nUserData) == 200 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_147().m_nUserData) >= 8 ); + +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_147) >= 200 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_147, m_pData) == 0 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_147().m_pData) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_147, m_cbSize) == 4 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_147().m_cbSize) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_147, m_conn) == 8 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_147().m_conn) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_147, m_identityPeer) == 12 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_147().m_identityPeer) >= 136 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_147, m_nConnUserData) == 152 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_147().m_nConnUserData) >= 8 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_147, m_usecTimeReceived) == 160 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_147().m_usecTimeReceived) >= 8 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_147, m_nMessageNumber) == 168 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_147().m_nMessageNumber) >= 8 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_147, m_pfnFreeData) == 176 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_147().m_pfnFreeData) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_147, m_pfnRelease) == 180 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_147().m_pfnRelease) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_147, m_nChannel) == 184 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_147().m_nChannel) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_147, m_nFlags) == 188 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_147().m_nFlags) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_147, m_nUserData) == 192 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_147().m_nUserData) >= 8 ); + +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_147) >= 196 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_147, m_pData) == 0 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_147().m_pData) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_147, m_cbSize) == 4 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_147().m_cbSize) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_147, m_conn) == 8 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_147().m_conn) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_147, m_identityPeer) == 12 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_147().m_identityPeer) >= 136 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_147, m_nConnUserData) == 148 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_147().m_nConnUserData) >= 8 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_147, m_usecTimeReceived) == 156 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_147().m_usecTimeReceived) >= 8 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_147, m_nMessageNumber) == 164 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_147().m_nMessageNumber) >= 8 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_147, m_pfnFreeData) == 172 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_147().m_pfnFreeData) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_147, m_pfnRelease) == 176 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_147().m_pfnRelease) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_147, m_nChannel) == 180 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_147().m_nChannel) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_147, m_nFlags) == 184 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_147().m_nFlags) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_147, m_nUserData) == 188 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_147().m_nUserData) >= 8 ); + +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_151) >= 80 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_151, m_pData) == 0 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_151().m_pData) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_151, m_cbSize) == 8 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_151().m_cbSize) >= 4 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_151, m_conn) == 12 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_151().m_conn) >= 4 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_151, m_identityPeer) == 16 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_151().m_identityPeer) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_151, m_nConnUserData) == 24 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_151().m_nConnUserData) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_151, m_usecTimeReceived) == 32 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_151().m_usecTimeReceived) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_151, m_nMessageNumber) == 40 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_151().m_nMessageNumber) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_151, m_pfnFreeData) == 48 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_151().m_pfnFreeData) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_151, m_pfnRelease) == 56 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_151().m_pfnRelease) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_151, m_nChannel) == 64 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_151().m_nChannel) >= 4 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_151, m_nFlags) == 68 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_151().m_nFlags) >= 4 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_151, m_nUserData) == 72 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_151().m_nUserData) >= 8 ); + +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_151) >= 80 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_151, m_pData) == 0 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_151().m_pData) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_151, m_cbSize) == 8 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_151().m_cbSize) >= 4 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_151, m_conn) == 12 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_151().m_conn) >= 4 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_151, m_identityPeer) == 16 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_151().m_identityPeer) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_151, m_nConnUserData) == 24 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_151().m_nConnUserData) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_151, m_usecTimeReceived) == 32 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_151().m_usecTimeReceived) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_151, m_nMessageNumber) == 40 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_151().m_nMessageNumber) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_151, m_pfnFreeData) == 48 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_151().m_pfnFreeData) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_151, m_pfnRelease) == 56 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_151().m_pfnRelease) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_151, m_nChannel) == 64 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_151().m_nChannel) >= 4 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_151, m_nFlags) == 68 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_151().m_nFlags) >= 4 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_151, m_nUserData) == 72 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_151().m_nUserData) >= 8 ); + +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_151) >= 72 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_151, m_pData) == 0 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_151().m_pData) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_151, m_cbSize) == 4 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_151().m_cbSize) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_151, m_conn) == 8 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_151().m_conn) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_151, m_identityPeer) == 12 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_151().m_identityPeer) >= 8 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_151, m_nConnUserData) == 24 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_151().m_nConnUserData) >= 8 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_151, m_usecTimeReceived) == 32 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_151().m_usecTimeReceived) >= 8 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_151, m_nMessageNumber) == 40 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_151().m_nMessageNumber) >= 8 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_151, m_pfnFreeData) == 48 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_151().m_pfnFreeData) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_151, m_pfnRelease) == 52 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_151().m_pfnRelease) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_151, m_nChannel) == 56 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_151().m_nChannel) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_151, m_nFlags) == 60 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_151().m_nFlags) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_151, m_nUserData) == 64 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_151().m_nUserData) >= 8 ); + +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_151) >= 68 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_151, m_pData) == 0 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_151().m_pData) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_151, m_cbSize) == 4 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_151().m_cbSize) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_151, m_conn) == 8 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_151().m_conn) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_151, m_identityPeer) == 12 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_151().m_identityPeer) >= 8 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_151, m_nConnUserData) == 20 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_151().m_nConnUserData) >= 8 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_151, m_usecTimeReceived) == 28 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_151().m_usecTimeReceived) >= 8 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_151, m_nMessageNumber) == 36 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_151().m_nMessageNumber) >= 8 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_151, m_pfnFreeData) == 44 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_151().m_pfnFreeData) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_151, m_pfnRelease) == 48 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_151().m_pfnRelease) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_151, m_nChannel) == 52 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_151().m_nChannel) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_151, m_nFlags) == 56 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_151().m_nFlags) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_151, m_nUserData) == 60 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_151().m_nUserData) >= 8 ); + +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_144) >= 200 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_144, m_pData) == 0 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_144().m_pData) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_144, m_cbSize) == 8 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_144().m_cbSize) >= 4 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_144, m_conn) == 12 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_144().m_conn) >= 4 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_144, m_sender) == 16 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_144().m_sender) >= 136 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_144, m_nConnUserData) == 152 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_144().m_nConnUserData) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_144, m_usecTimeReceived) == 160 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_144().m_usecTimeReceived) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_144, m_nMessageNumber) == 168 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_144().m_nMessageNumber) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_144, m_pfnFreeData) == 176 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_144().m_pfnFreeData) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_144, m_pfnRelease) == 184 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_144().m_pfnRelease) >= 8 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_144, m_nChannel) == 192 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_144().m_nChannel) >= 4 ); +C_ASSERT( offsetof(w64_SteamNetworkingMessage_t_144, m___nPadDummy) == 196 ); +C_ASSERT( sizeof(w64_SteamNetworkingMessage_t_144().m___nPadDummy) >= 4 ); + +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_144) >= 200 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_144, m_pData) == 0 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_144().m_pData) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_144, m_cbSize) == 8 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_144().m_cbSize) >= 4 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_144, m_conn) == 12 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_144().m_conn) >= 4 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_144, m_sender) == 16 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_144().m_sender) >= 136 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_144, m_nConnUserData) == 152 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_144().m_nConnUserData) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_144, m_usecTimeReceived) == 160 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_144().m_usecTimeReceived) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_144, m_nMessageNumber) == 168 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_144().m_nMessageNumber) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_144, m_pfnFreeData) == 176 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_144().m_pfnFreeData) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_144, m_pfnRelease) == 184 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_144().m_pfnRelease) >= 8 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_144, m_nChannel) == 192 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_144().m_nChannel) >= 4 ); +C_ASSERT( offsetof(u64_SteamNetworkingMessage_t_144, m___nPadDummy) == 196 ); +C_ASSERT( sizeof(u64_SteamNetworkingMessage_t_144().m___nPadDummy) >= 4 ); + +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_144) >= 192 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_144, m_pData) == 0 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_144().m_pData) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_144, m_cbSize) == 4 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_144().m_cbSize) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_144, m_conn) == 8 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_144().m_conn) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_144, m_sender) == 12 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_144().m_sender) >= 136 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_144, m_nConnUserData) == 152 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_144().m_nConnUserData) >= 8 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_144, m_usecTimeReceived) == 160 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_144().m_usecTimeReceived) >= 8 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_144, m_nMessageNumber) == 168 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_144().m_nMessageNumber) >= 8 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_144, m_pfnFreeData) == 176 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_144().m_pfnFreeData) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_144, m_pfnRelease) == 180 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_144().m_pfnRelease) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_144, m_nChannel) == 184 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_144().m_nChannel) >= 4 ); +C_ASSERT( offsetof(w32_SteamNetworkingMessage_t_144, m___nPadDummy) == 188 ); +C_ASSERT( sizeof(w32_SteamNetworkingMessage_t_144().m___nPadDummy) >= 4 ); + +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_144) >= 188 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_144, m_pData) == 0 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_144().m_pData) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_144, m_cbSize) == 4 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_144().m_cbSize) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_144, m_conn) == 8 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_144().m_conn) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_144, m_sender) == 12 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_144().m_sender) >= 136 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_144, m_nConnUserData) == 148 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_144().m_nConnUserData) >= 8 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_144, m_usecTimeReceived) == 156 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_144().m_usecTimeReceived) >= 8 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_144, m_nMessageNumber) == 164 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_144().m_nMessageNumber) >= 8 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_144, m_pfnFreeData) == 172 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_144().m_pfnFreeData) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_144, m_pfnRelease) == 176 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_144().m_pfnRelease) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_144, m_nChannel) == 180 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_144().m_nChannel) >= 4 ); +C_ASSERT( offsetof(u32_SteamNetworkingMessage_t_144, m___nPadDummy) == 184 ); +C_ASSERT( sizeof(u32_SteamNetworkingMessage_t_144().m___nPadDummy) >= 4 ); + +C_ASSERT( sizeof(w64_SteamParamStringArray_t) >= 16 ); +C_ASSERT( offsetof(w64_SteamParamStringArray_t, m_ppStrings) == 0 ); +C_ASSERT( sizeof(w64_SteamParamStringArray_t().m_ppStrings) >= 8 ); +C_ASSERT( offsetof(w64_SteamParamStringArray_t, m_nNumStrings) == 8 ); +C_ASSERT( sizeof(w64_SteamParamStringArray_t().m_nNumStrings) >= 4 ); + +C_ASSERT( sizeof(u64_SteamParamStringArray_t) >= 12 ); +C_ASSERT( offsetof(u64_SteamParamStringArray_t, m_ppStrings) == 0 ); +C_ASSERT( sizeof(u64_SteamParamStringArray_t().m_ppStrings) >= 8 ); +C_ASSERT( offsetof(u64_SteamParamStringArray_t, m_nNumStrings) == 8 ); +C_ASSERT( sizeof(u64_SteamParamStringArray_t().m_nNumStrings) >= 4 ); + +C_ASSERT( sizeof(w32_SteamParamStringArray_t) >= 8 ); +C_ASSERT( offsetof(w32_SteamParamStringArray_t, m_ppStrings) == 0 ); +C_ASSERT( sizeof(w32_SteamParamStringArray_t().m_ppStrings) >= 4 ); +C_ASSERT( offsetof(w32_SteamParamStringArray_t, m_nNumStrings) == 4 ); +C_ASSERT( sizeof(w32_SteamParamStringArray_t().m_nNumStrings) >= 4 ); + +C_ASSERT( sizeof(u32_SteamParamStringArray_t) >= 8 ); +C_ASSERT( offsetof(u32_SteamParamStringArray_t, m_ppStrings) == 0 ); +C_ASSERT( sizeof(u32_SteamParamStringArray_t().m_ppStrings) >= 4 ); +C_ASSERT( offsetof(u32_SteamParamStringArray_t, m_nNumStrings) == 4 ); +C_ASSERT( sizeof(u32_SteamParamStringArray_t().m_nNumStrings) >= 4 ); + +C_ASSERT( sizeof(w64_SteamPartyBeaconLocation_t) >= 16 ); +C_ASSERT( offsetof(w64_SteamPartyBeaconLocation_t, m_eType) == 0 ); +C_ASSERT( sizeof(w64_SteamPartyBeaconLocation_t().m_eType) >= 4 ); +C_ASSERT( offsetof(w64_SteamPartyBeaconLocation_t, m_ulLocationID) == 8 ); +C_ASSERT( sizeof(w64_SteamPartyBeaconLocation_t().m_ulLocationID) >= 8 ); + +C_ASSERT( sizeof(u64_SteamPartyBeaconLocation_t) >= 12 ); +C_ASSERT( offsetof(u64_SteamPartyBeaconLocation_t, m_eType) == 0 ); +C_ASSERT( sizeof(u64_SteamPartyBeaconLocation_t().m_eType) >= 4 ); +C_ASSERT( offsetof(u64_SteamPartyBeaconLocation_t, m_ulLocationID) == 4 ); +C_ASSERT( sizeof(u64_SteamPartyBeaconLocation_t().m_ulLocationID) >= 8 ); + +C_ASSERT( sizeof(w32_SteamPartyBeaconLocation_t) >= 16 ); +C_ASSERT( offsetof(w32_SteamPartyBeaconLocation_t, m_eType) == 0 ); +C_ASSERT( sizeof(w32_SteamPartyBeaconLocation_t().m_eType) >= 4 ); +C_ASSERT( offsetof(w32_SteamPartyBeaconLocation_t, m_ulLocationID) == 8 ); +C_ASSERT( sizeof(w32_SteamPartyBeaconLocation_t().m_ulLocationID) >= 8 ); + +C_ASSERT( sizeof(u32_SteamPartyBeaconLocation_t) >= 12 ); +C_ASSERT( offsetof(u32_SteamPartyBeaconLocation_t, m_eType) == 0 ); +C_ASSERT( sizeof(u32_SteamPartyBeaconLocation_t().m_eType) >= 4 ); +C_ASSERT( offsetof(u32_SteamPartyBeaconLocation_t, m_ulLocationID) == 4 ); +C_ASSERT( sizeof(u32_SteamPartyBeaconLocation_t().m_ulLocationID) >= 8 ); + +C_ASSERT( sizeof(w64_SteamUGCRequestUGCDetailsResult_t_128x) >= 9784 ); +C_ASSERT( offsetof(w64_SteamUGCRequestUGCDetailsResult_t_128x, m_details) == 0 ); +C_ASSERT( sizeof(w64_SteamUGCRequestUGCDetailsResult_t_128x().m_details) >= 9776 ); +C_ASSERT( offsetof(w64_SteamUGCRequestUGCDetailsResult_t_128x, m_bCachedData) == 9776 ); +C_ASSERT( sizeof(w64_SteamUGCRequestUGCDetailsResult_t_128x().m_bCachedData) >= 1 ); + +C_ASSERT( sizeof(u64_SteamUGCRequestUGCDetailsResult_t_128x) >= 9768 ); +C_ASSERT( offsetof(u64_SteamUGCRequestUGCDetailsResult_t_128x, m_details) == 0 ); +C_ASSERT( sizeof(u64_SteamUGCRequestUGCDetailsResult_t_128x().m_details) >= 9764 ); +C_ASSERT( offsetof(u64_SteamUGCRequestUGCDetailsResult_t_128x, m_bCachedData) == 9764 ); +C_ASSERT( sizeof(u64_SteamUGCRequestUGCDetailsResult_t_128x().m_bCachedData) >= 1 ); + +C_ASSERT( sizeof(w32_SteamUGCRequestUGCDetailsResult_t_128x) >= 9784 ); +C_ASSERT( offsetof(w32_SteamUGCRequestUGCDetailsResult_t_128x, m_details) == 0 ); +C_ASSERT( sizeof(w32_SteamUGCRequestUGCDetailsResult_t_128x().m_details) >= 9776 ); +C_ASSERT( offsetof(w32_SteamUGCRequestUGCDetailsResult_t_128x, m_bCachedData) == 9776 ); +C_ASSERT( sizeof(w32_SteamUGCRequestUGCDetailsResult_t_128x().m_bCachedData) >= 1 ); + +C_ASSERT( sizeof(u32_SteamUGCRequestUGCDetailsResult_t_128x) >= 9768 ); +C_ASSERT( offsetof(u32_SteamUGCRequestUGCDetailsResult_t_128x, m_details) == 0 ); +C_ASSERT( sizeof(u32_SteamUGCRequestUGCDetailsResult_t_128x().m_details) >= 9764 ); +C_ASSERT( offsetof(u32_SteamUGCRequestUGCDetailsResult_t_128x, m_bCachedData) == 9764 ); +C_ASSERT( sizeof(u32_SteamUGCRequestUGCDetailsResult_t_128x().m_bCachedData) >= 1 ); + +C_ASSERT( sizeof(w64_SteamUGCRequestUGCDetailsResult_t_129) >= 9776 ); +C_ASSERT( offsetof(w64_SteamUGCRequestUGCDetailsResult_t_129, m_details) == 0 ); +C_ASSERT( sizeof(w64_SteamUGCRequestUGCDetailsResult_t_129().m_details) >= 9768 ); +C_ASSERT( offsetof(w64_SteamUGCRequestUGCDetailsResult_t_129, m_bCachedData) == 9768 ); +C_ASSERT( sizeof(w64_SteamUGCRequestUGCDetailsResult_t_129().m_bCachedData) >= 1 ); + +C_ASSERT( sizeof(u64_SteamUGCRequestUGCDetailsResult_t_129) >= 9764 ); +C_ASSERT( offsetof(u64_SteamUGCRequestUGCDetailsResult_t_129, m_details) == 0 ); +C_ASSERT( sizeof(u64_SteamUGCRequestUGCDetailsResult_t_129().m_details) >= 9760 ); +C_ASSERT( offsetof(u64_SteamUGCRequestUGCDetailsResult_t_129, m_bCachedData) == 9760 ); +C_ASSERT( sizeof(u64_SteamUGCRequestUGCDetailsResult_t_129().m_bCachedData) >= 1 ); + +C_ASSERT( sizeof(w32_SteamUGCRequestUGCDetailsResult_t_129) >= 9776 ); +C_ASSERT( offsetof(w32_SteamUGCRequestUGCDetailsResult_t_129, m_details) == 0 ); +C_ASSERT( sizeof(w32_SteamUGCRequestUGCDetailsResult_t_129().m_details) >= 9768 ); +C_ASSERT( offsetof(w32_SteamUGCRequestUGCDetailsResult_t_129, m_bCachedData) == 9768 ); +C_ASSERT( sizeof(w32_SteamUGCRequestUGCDetailsResult_t_129().m_bCachedData) >= 1 ); + +C_ASSERT( sizeof(u32_SteamUGCRequestUGCDetailsResult_t_129) >= 9764 ); +C_ASSERT( offsetof(u32_SteamUGCRequestUGCDetailsResult_t_129, m_details) == 0 ); +C_ASSERT( sizeof(u32_SteamUGCRequestUGCDetailsResult_t_129().m_details) >= 9760 ); +C_ASSERT( offsetof(u32_SteamUGCRequestUGCDetailsResult_t_129, m_bCachedData) == 9760 ); +C_ASSERT( sizeof(u32_SteamUGCRequestUGCDetailsResult_t_129().m_bCachedData) >= 1 ); + +C_ASSERT( sizeof(w64_SteamUGCRequestUGCDetailsResult_t_126) >= 9768 ); +C_ASSERT( offsetof(w64_SteamUGCRequestUGCDetailsResult_t_126, m_details) == 0 ); +C_ASSERT( sizeof(w64_SteamUGCRequestUGCDetailsResult_t_126().m_details) >= 9768 ); + +C_ASSERT( sizeof(u64_SteamUGCRequestUGCDetailsResult_t_126) >= 9760 ); +C_ASSERT( offsetof(u64_SteamUGCRequestUGCDetailsResult_t_126, m_details) == 0 ); +C_ASSERT( sizeof(u64_SteamUGCRequestUGCDetailsResult_t_126().m_details) >= 9760 ); + +C_ASSERT( sizeof(w32_SteamUGCRequestUGCDetailsResult_t_126) >= 9768 ); +C_ASSERT( offsetof(w32_SteamUGCRequestUGCDetailsResult_t_126, m_details) == 0 ); +C_ASSERT( sizeof(w32_SteamUGCRequestUGCDetailsResult_t_126().m_details) >= 9768 ); + +C_ASSERT( sizeof(u32_SteamUGCRequestUGCDetailsResult_t_126) >= 9760 ); +C_ASSERT( offsetof(u32_SteamUGCRequestUGCDetailsResult_t_126, m_details) == 0 ); +C_ASSERT( sizeof(u32_SteamUGCRequestUGCDetailsResult_t_126().m_details) >= 9760 ); + +C_ASSERT( sizeof(w64_SubmitPlayerResultResultCallback_t) >= 24 ); +C_ASSERT( offsetof(w64_SubmitPlayerResultResultCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w64_SubmitPlayerResultResultCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w64_SubmitPlayerResultResultCallback_t, ullUniqueGameID) == 8 ); +C_ASSERT( sizeof(w64_SubmitPlayerResultResultCallback_t().ullUniqueGameID) >= 8 ); +C_ASSERT( offsetof(w64_SubmitPlayerResultResultCallback_t, steamIDPlayer) == 16 ); +C_ASSERT( sizeof(w64_SubmitPlayerResultResultCallback_t().steamIDPlayer) >= 8 ); + +C_ASSERT( sizeof(u64_SubmitPlayerResultResultCallback_t) >= 20 ); +C_ASSERT( offsetof(u64_SubmitPlayerResultResultCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u64_SubmitPlayerResultResultCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u64_SubmitPlayerResultResultCallback_t, ullUniqueGameID) == 4 ); +C_ASSERT( sizeof(u64_SubmitPlayerResultResultCallback_t().ullUniqueGameID) >= 8 ); +C_ASSERT( offsetof(u64_SubmitPlayerResultResultCallback_t, steamIDPlayer) == 12 ); +C_ASSERT( sizeof(u64_SubmitPlayerResultResultCallback_t().steamIDPlayer) >= 8 ); + +C_ASSERT( sizeof(w32_SubmitPlayerResultResultCallback_t) >= 24 ); +C_ASSERT( offsetof(w32_SubmitPlayerResultResultCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(w32_SubmitPlayerResultResultCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(w32_SubmitPlayerResultResultCallback_t, ullUniqueGameID) == 8 ); +C_ASSERT( sizeof(w32_SubmitPlayerResultResultCallback_t().ullUniqueGameID) >= 8 ); +C_ASSERT( offsetof(w32_SubmitPlayerResultResultCallback_t, steamIDPlayer) == 16 ); +C_ASSERT( sizeof(w32_SubmitPlayerResultResultCallback_t().steamIDPlayer) >= 8 ); + +C_ASSERT( sizeof(u32_SubmitPlayerResultResultCallback_t) >= 20 ); +C_ASSERT( offsetof(u32_SubmitPlayerResultResultCallback_t, m_eResult) == 0 ); +C_ASSERT( sizeof(u32_SubmitPlayerResultResultCallback_t().m_eResult) >= 4 ); +C_ASSERT( offsetof(u32_SubmitPlayerResultResultCallback_t, ullUniqueGameID) == 4 ); +C_ASSERT( sizeof(u32_SubmitPlayerResultResultCallback_t().ullUniqueGameID) >= 8 ); +C_ASSERT( offsetof(u32_SubmitPlayerResultResultCallback_t, steamIDPlayer) == 12 ); +C_ASSERT( sizeof(u32_SubmitPlayerResultResultCallback_t().steamIDPlayer) >= 8 ); +