Generate the char server protocol

12 files changed, 4852 insertions, 43 deletions

diff --git a/src/proto2/any-user.hpp b/src/proto2/any-user.hpp
index d704233..da9b1bc 100644
--- a/src/proto2/any-user.hpp
+++ b/src/proto2/any-user.hpp
@@ -27,6 +27,19 @@
 
 // This is a public protocol, and changes require client cooperation
 
+// this is only needed for the payload packet right now, and that needs to die
+#pragma pack(push, 1)
+
+template<>
+struct Packet_Fixed<0x0081>
+{
+    static const uint16_t PACKET_ID = 0x0081;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    uint8_t error_code = {};
+};
+
 template<>
 struct Packet_Fixed<0x7530>
 {
@@ -57,6 +70,16 @@ struct Packet_Fixed<0x7532>
 
 
 template<>
+struct NetPacket_Fixed<0x0081>
+{
+    Little16 magic_packet_id;
+    Byte error_code;
+};
+static_assert(offsetof(NetPacket_Fixed<0x0081>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0081>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x0081>, error_code) == 2, "offsetof(NetPacket_Fixed<0x0081>, error_code) == 2");
+static_assert(sizeof(NetPacket_Fixed<0x0081>) == 3, "sizeof(NetPacket_Fixed<0x0081>) == 3");
+
+template<>
 struct NetPacket_Fixed<0x7530>
 {
     Little16 magic_packet_id;
@@ -84,6 +107,23 @@ static_assert(sizeof(NetPacket_Fixed<0x7532>) == 2, "sizeof(NetPacket_Fixed<0x75
 
 
 inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x0081> *network, Packet_Fixed<0x0081> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->error_code, native.error_code);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x0081> *native, NetPacket_Fixed<0x0081> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->error_code, network.error_code);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
 bool native_to_network(NetPacket_Fixed<0x7530> *network, Packet_Fixed<0x7530> native)
 {
     bool rv = true;
@@ -131,4 +171,6 @@ bool network_to_native(Packet_Fixed<0x7532> *native, NetPacket_Fixed<0x7532> net
 }
 
 
+#pragma pack(pop)
+
 #endif // TMWA_PROTO2_ANY_USER_HPP
diff --git a/src/proto2/char-map.hpp b/src/proto2/char-map.hpp
index 83f13a7..333c948 100644
--- a/src/proto2/char-map.hpp
+++ b/src/proto2/char-map.hpp
@@ -27,7 +27,3435 @@
 
 // This is an internal protocol, and can be changed without notice
 
+// this is only needed for the payload packet right now, and that needs to die
+#pragma pack(push, 1)
 
+template<>
+struct Packet_Fixed<0x2af7>
+{
+    static const uint16_t PACKET_ID = 0x2af7;
 
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+};
+
+template<>
+struct Packet_Fixed<0x2af8>
+{
+    static const uint16_t PACKET_ID = 0x2af8;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountName account_name = {};
+    AccountPass account_pass = {};
+    uint32_t unused = {};
+    IP4Address ip = {};
+    uint16_t port = {};
+};
+
+template<>
+struct Packet_Fixed<0x2af9>
+{
+    static const uint16_t PACKET_ID = 0x2af9;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    uint8_t code = {};
+};
+
+template<>
+struct Packet_Head<0x2afa>
+{
+    static const uint16_t PACKET_ID = 0x2afa;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+};
+template<>
+struct Packet_Repeat<0x2afa>
+{
+    static const uint16_t PACKET_ID = 0x2afa;
+
+    MapName map_name = {};
+};
+
+template<>
+struct Packet_Fixed<0x2afa>
+{
+    static const uint16_t PACKET_ID = 0x2afa;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    ItemNameId source_item_id = {};
+    ItemNameId dest_item_id = {};
+};
+
+template<>
+struct Packet_Fixed<0x2afb>
+{
+    static const uint16_t PACKET_ID = 0x2afb;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    uint8_t unknown = {};
+    CharName whisper_name = {};
+};
+
+template<>
+struct Packet_Fixed<0x2afc>
+{
+    static const uint16_t PACKET_ID = 0x2afc;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountId account_id = {};
+    CharId char_id = {};
+    uint32_t login_id1 = {};
+    uint32_t login_id2 = {};
+    IP4Address ip = {};
+};
+
+template<>
+struct Packet_Payload<0x2afd>
+{
+    static const uint16_t PACKET_ID = 0x2afd;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+    AccountId account_id = {};
+    uint32_t login_id2 = {};
+    TimeT connect_until = {};
+    uint16_t packet_tmw_version = {};
+    CharKey char_key = {};
+    CharData char_data = {};
+};
+
+template<>
+struct Packet_Fixed<0x2afe>
+{
+    static const uint16_t PACKET_ID = 0x2afe;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountId account_id = {};
+};
+
+template<>
+struct Packet_Head<0x2aff>
+{
+    static const uint16_t PACKET_ID = 0x2aff;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+    uint16_t users = {};
+};
+template<>
+struct Packet_Repeat<0x2aff>
+{
+    static const uint16_t PACKET_ID = 0x2aff;
+
+    CharId char_id = {};
+};
+
+template<>
+struct Packet_Fixed<0x2b00>
+{
+    static const uint16_t PACKET_ID = 0x2b00;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    uint32_t users = {};
+};
+
+template<>
+struct Packet_Payload<0x2b01>
+{
+    static const uint16_t PACKET_ID = 0x2b01;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+    AccountId account_id = {};
+    CharId char_id = {};
+    CharKey char_key = {};
+    CharData char_data = {};
+};
+
+template<>
+struct Packet_Fixed<0x2b02>
+{
+    static const uint16_t PACKET_ID = 0x2b02;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountId account_id = {};
+    uint32_t login_id1 = {};
+    uint32_t login_id2 = {};
+    IP4Address ip = {};
+};
+
+template<>
+struct Packet_Fixed<0x2b03>
+{
+    static const uint16_t PACKET_ID = 0x2b03;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountId account_id = {};
+    uint8_t unknown = {};
+};
+
+template<>
+struct Packet_Head<0x2b04>
+{
+    static const uint16_t PACKET_ID = 0x2b04;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+    IP4Address ip = {};
+    uint16_t port = {};
+};
+template<>
+struct Packet_Repeat<0x2b04>
+{
+    static const uint16_t PACKET_ID = 0x2b04;
+
+    MapName map_name = {};
+};
+
+template<>
+struct Packet_Fixed<0x2b05>
+{
+    static const uint16_t PACKET_ID = 0x2b05;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountId account_id = {};
+    uint32_t login_id1 = {};
+    uint32_t login_id2 = {};
+    CharId char_id = {};
+    MapName map_name = {};
+    uint16_t x = {};
+    uint16_t y = {};
+    IP4Address map_ip = {};
+    uint16_t map_port = {};
+    SEX sex = {};
+    IP4Address client_ip = {};
+};
+
+template<>
+struct Packet_Fixed<0x2b06>
+{
+    static const uint16_t PACKET_ID = 0x2b06;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountId account_id = {};
+    uint32_t error = {};
+    uint32_t unknown = {};
+    CharId char_id = {};
+    MapName map_name = {};
+    uint16_t x = {};
+    uint16_t y = {};
+    IP4Address map_ip = {};
+    uint16_t map_port = {};
+};
+
+template<>
+struct Packet_Head<0x2b0a>
+{
+    static const uint16_t PACKET_ID = 0x2b0a;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+    AccountId account_id = {};
+};
+template<>
+struct Packet_Repeat<0x2b0a>
+{
+    static const uint16_t PACKET_ID = 0x2b0a;
+
+    uint8_t c = {};
+};
+
+template<>
+struct Packet_Fixed<0x2b0b>
+{
+    static const uint16_t PACKET_ID = 0x2b0b;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountId account_id = {};
+    GmLevel gm_level = {};
+};
+
+template<>
+struct Packet_Fixed<0x2b0c>
+{
+    static const uint16_t PACKET_ID = 0x2b0c;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountId account_id = {};
+    AccountEmail old_email = {};
+    AccountEmail new_email = {};
+};
+
+template<>
+struct Packet_Fixed<0x2b0d>
+{
+    static const uint16_t PACKET_ID = 0x2b0d;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountId account_id = {};
+    SEX sex = {};
+};
+
+template<>
+struct Packet_Fixed<0x2b0e>
+{
+    static const uint16_t PACKET_ID = 0x2b0e;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountId account_id = {};
+    CharName char_name = {};
+    uint16_t operation = {};
+    HumanTimeDiff ban_add = {};
+};
+
+template<>
+struct Packet_Fixed<0x2b0f>
+{
+    static const uint16_t PACKET_ID = 0x2b0f;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountId account_id = {};
+    CharName char_name = {};
+    uint16_t operation = {};
+    uint16_t error = {};
+};
+
+template<>
+struct Packet_Head<0x2b10>
+{
+    static const uint16_t PACKET_ID = 0x2b10;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+    AccountId account_id = {};
+};
+template<>
+struct Packet_Repeat<0x2b10>
+{
+    static const uint16_t PACKET_ID = 0x2b10;
+
+    VarName name = {};
+    uint32_t value = {};
+};
+
+template<>
+struct Packet_Head<0x2b11>
+{
+    static const uint16_t PACKET_ID = 0x2b11;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+    AccountId account_id = {};
+};
+template<>
+struct Packet_Repeat<0x2b11>
+{
+    static const uint16_t PACKET_ID = 0x2b11;
+
+    VarName name = {};
+    uint32_t value = {};
+};
+
+template<>
+struct Packet_Fixed<0x2b12>
+{
+    static const uint16_t PACKET_ID = 0x2b12;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    CharId char_id = {};
+    CharId partner_id = {};
+};
+
+template<>
+struct Packet_Fixed<0x2b13>
+{
+    static const uint16_t PACKET_ID = 0x2b13;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountId account_id = {};
+};
+
+template<>
+struct Packet_Fixed<0x2b14>
+{
+    static const uint16_t PACKET_ID = 0x2b14;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountId account_id = {};
+    uint8_t ban_not_status = {};
+    TimeT status_or_ban_until = {};
+};
+
+template<>
+struct Packet_Head<0x2b15>
+{
+    static const uint16_t PACKET_ID = 0x2b15;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+};
+template<>
+struct Packet_Repeat<0x2b15>
+{
+    static const uint16_t PACKET_ID = 0x2b15;
+
+    AccountId account_id = {};
+    GmLevel gm_level = {};
+};
+
+template<>
+struct Packet_Fixed<0x2b16>
+{
+    static const uint16_t PACKET_ID = 0x2b16;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    CharId char_id = {};
+};
+
+template<>
+struct Packet_Head<0x3000>
+{
+    static const uint16_t PACKET_ID = 0x3000;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+};
+template<>
+struct Packet_Repeat<0x3000>
+{
+    static const uint16_t PACKET_ID = 0x3000;
+
+    uint8_t c = {};
+};
+
+template<>
+struct Packet_Head<0x3001>
+{
+    static const uint16_t PACKET_ID = 0x3001;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+    CharName from_char_name = {};
+    CharName to_char_name = {};
+};
+template<>
+struct Packet_Repeat<0x3001>
+{
+    static const uint16_t PACKET_ID = 0x3001;
+
+    uint8_t c = {};
+};
+
+template<>
+struct Packet_Fixed<0x3002>
+{
+    static const uint16_t PACKET_ID = 0x3002;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    CharId char_id = {};
+    uint8_t flag = {};
+};
+
+template<>
+struct Packet_Head<0x3003>
+{
+    static const uint16_t PACKET_ID = 0x3003;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+    CharName char_name = {};
+    GmLevel min_gm_level = {};
+};
+template<>
+struct Packet_Repeat<0x3003>
+{
+    static const uint16_t PACKET_ID = 0x3003;
+
+    uint8_t c = {};
+};
+
+template<>
+struct Packet_Head<0x3004>
+{
+    static const uint16_t PACKET_ID = 0x3004;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+    AccountId account_id = {};
+};
+template<>
+struct Packet_Repeat<0x3004>
+{
+    static const uint16_t PACKET_ID = 0x3004;
+
+    VarName name = {};
+    uint32_t value = {};
+};
+
+template<>
+struct Packet_Fixed<0x3005>
+{
+    static const uint16_t PACKET_ID = 0x3005;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountId account_id = {};
+};
+
+template<>
+struct Packet_Fixed<0x3010>
+{
+    static const uint16_t PACKET_ID = 0x3010;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountId account_id = {};
+};
+
+template<>
+struct Packet_Payload<0x3011>
+{
+    static const uint16_t PACKET_ID = 0x3011;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+    AccountId account_id = {};
+    Storage storage = {};
+};
+
+template<>
+struct Packet_Fixed<0x3020>
+{
+    static const uint16_t PACKET_ID = 0x3020;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountId account_id = {};
+    PartyName party_name = {};
+    CharName char_name = {};
+    MapName map_name = {};
+    uint16_t level = {};
+};
+
+template<>
+struct Packet_Fixed<0x3021>
+{
+    static const uint16_t PACKET_ID = 0x3021;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    PartyId party_id = {};
+};
+
+template<>
+struct Packet_Fixed<0x3022>
+{
+    static const uint16_t PACKET_ID = 0x3022;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    PartyId party_id = {};
+    AccountId account_id = {};
+    CharName char_name = {};
+    MapName map_name = {};
+    uint16_t level = {};
+};
+
+template<>
+struct Packet_Fixed<0x3023>
+{
+    static const uint16_t PACKET_ID = 0x3023;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    PartyId party_id = {};
+    AccountId account_id = {};
+    uint16_t exp = {};
+    uint16_t item = {};
+};
+
+template<>
+struct Packet_Fixed<0x3024>
+{
+    static const uint16_t PACKET_ID = 0x3024;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    PartyId party_id = {};
+    AccountId account_id = {};
+};
+
+template<>
+struct Packet_Fixed<0x3025>
+{
+    static const uint16_t PACKET_ID = 0x3025;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    PartyId party_id = {};
+    AccountId account_id = {};
+    MapName map_name = {};
+    uint8_t online = {};
+    uint16_t level = {};
+};
+
+template<>
+struct Packet_Fixed<0x3026>
+{
+    static const uint16_t PACKET_ID = 0x3026;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    PartyId party_id = {};
+};
+
+template<>
+struct Packet_Head<0x3027>
+{
+    static const uint16_t PACKET_ID = 0x3027;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+    PartyId party_id = {};
+    AccountId account_id = {};
+};
+template<>
+struct Packet_Repeat<0x3027>
+{
+    static const uint16_t PACKET_ID = 0x3027;
+
+    uint8_t c = {};
+};
+
+template<>
+struct Packet_Fixed<0x3028>
+{
+    static const uint16_t PACKET_ID = 0x3028;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    PartyId party_id = {};
+    AccountId account_id = {};
+    CharName char_name = {};
+};
+
+template<>
+struct Packet_Head<0x3800>
+{
+    static const uint16_t PACKET_ID = 0x3800;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+};
+template<>
+struct Packet_Repeat<0x3800>
+{
+    static const uint16_t PACKET_ID = 0x3800;
+
+    uint8_t c = {};
+};
+
+template<>
+struct Packet_Head<0x3801>
+{
+    static const uint16_t PACKET_ID = 0x3801;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+    CharId whisper_id = {};
+    CharName src_char_name = {};
+    CharName dst_char_name = {};
+};
+template<>
+struct Packet_Repeat<0x3801>
+{
+    static const uint16_t PACKET_ID = 0x3801;
+
+    uint8_t c = {};
+};
+
+template<>
+struct Packet_Fixed<0x3802>
+{
+    static const uint16_t PACKET_ID = 0x3802;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    CharName sender_char_name = {};
+    uint8_t flag = {};
+};
+
+template<>
+struct Packet_Head<0x3803>
+{
+    static const uint16_t PACKET_ID = 0x3803;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+    CharName char_name = {};
+    GmLevel min_gm_level = {};
+};
+template<>
+struct Packet_Repeat<0x3803>
+{
+    static const uint16_t PACKET_ID = 0x3803;
+
+    uint8_t c = {};
+};
+
+template<>
+struct Packet_Head<0x3804>
+{
+    static const uint16_t PACKET_ID = 0x3804;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+    AccountId account_id = {};
+};
+template<>
+struct Packet_Repeat<0x3804>
+{
+    static const uint16_t PACKET_ID = 0x3804;
+
+    VarName name = {};
+    uint32_t value = {};
+};
+
+template<>
+struct Packet_Payload<0x3810>
+{
+    static const uint16_t PACKET_ID = 0x3810;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+    AccountId account_id = {};
+    Storage storage = {};
+};
+
+template<>
+struct Packet_Fixed<0x3811>
+{
+    static const uint16_t PACKET_ID = 0x3811;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountId account_id = {};
+    uint8_t unknown = {};
+};
+
+template<>
+struct Packet_Fixed<0x3820>
+{
+    static const uint16_t PACKET_ID = 0x3820;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountId account_id = {};
+    uint8_t error = {};
+    PartyId party_id = {};
+    PartyName party_name = {};
+};
+
+template<>
+struct Packet_Head<0x3821>
+{
+    static const uint16_t PACKET_ID = 0x3821;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+    PartyId party_id = {};
+};
+template<>
+struct Packet_Option<0x3821>
+{
+    static const uint16_t PACKET_ID = 0x3821;
+
+    PartyMost party_most = {};
+};
+
+template<>
+struct Packet_Fixed<0x3822>
+{
+    static const uint16_t PACKET_ID = 0x3822;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    PartyId party_id = {};
+    AccountId account_id = {};
+    uint8_t flag = {};
+};
+
+template<>
+struct Packet_Fixed<0x3823>
+{
+    static const uint16_t PACKET_ID = 0x3823;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    PartyId party_id = {};
+    AccountId account_id = {};
+    uint16_t exp = {};
+    uint16_t item = {};
+    uint8_t flag = {};
+};
+
+template<>
+struct Packet_Fixed<0x3824>
+{
+    static const uint16_t PACKET_ID = 0x3824;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    PartyId party_id = {};
+    AccountId account_id = {};
+    CharName char_name = {};
+};
+
+template<>
+struct Packet_Fixed<0x3825>
+{
+    static const uint16_t PACKET_ID = 0x3825;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    PartyId party_id = {};
+    AccountId account_id = {};
+    MapName map_name = {};
+    uint8_t online = {};
+    uint16_t level = {};
+};
+
+template<>
+struct Packet_Fixed<0x3826>
+{
+    static const uint16_t PACKET_ID = 0x3826;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    PartyId party_id = {};
+    uint8_t flag = {};
+};
+
+template<>
+struct Packet_Head<0x3827>
+{
+    static const uint16_t PACKET_ID = 0x3827;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+    PartyId party_id = {};
+    AccountId account_id = {};
+};
+template<>
+struct Packet_Repeat<0x3827>
+{
+    static const uint16_t PACKET_ID = 0x3827;
+
+    uint8_t c = {};
+};
+
+
+template<>
+struct NetPacket_Fixed<0x2af7>
+{
+    Little16 magic_packet_id;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2af7>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2af7>, magic_packet_id) == 0");
+static_assert(sizeof(NetPacket_Fixed<0x2af7>) == 2, "sizeof(NetPacket_Fixed<0x2af7>) == 2");
+
+template<>
+struct NetPacket_Fixed<0x2af8>
+{
+    Little16 magic_packet_id;
+    NetString<sizeof(AccountName)> account_name;
+    NetString<sizeof(AccountPass)> account_pass;
+    Little32 unused;
+    IP4Address ip;
+    Little16 port;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2af8>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2af8>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2af8>, account_name) == 2, "offsetof(NetPacket_Fixed<0x2af8>, account_name) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x2af8>, account_pass) == 26, "offsetof(NetPacket_Fixed<0x2af8>, account_pass) == 26");
+static_assert(offsetof(NetPacket_Fixed<0x2af8>, unused) == 50, "offsetof(NetPacket_Fixed<0x2af8>, unused) == 50");
+static_assert(offsetof(NetPacket_Fixed<0x2af8>, ip) == 54, "offsetof(NetPacket_Fixed<0x2af8>, ip) == 54");
+static_assert(offsetof(NetPacket_Fixed<0x2af8>, port) == 58, "offsetof(NetPacket_Fixed<0x2af8>, port) == 58");
+static_assert(sizeof(NetPacket_Fixed<0x2af8>) == 60, "sizeof(NetPacket_Fixed<0x2af8>) == 60");
+
+template<>
+struct NetPacket_Fixed<0x2af9>
+{
+    Little16 magic_packet_id;
+    Byte code;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2af9>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2af9>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2af9>, code) == 2, "offsetof(NetPacket_Fixed<0x2af9>, code) == 2");
+static_assert(sizeof(NetPacket_Fixed<0x2af9>) == 3, "sizeof(NetPacket_Fixed<0x2af9>) == 3");
+
+template<>
+struct NetPacket_Head<0x2afa>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+};
+static_assert(offsetof(NetPacket_Head<0x2afa>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x2afa>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Head<0x2afa>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x2afa>, magic_packet_length) == 2");
+static_assert(sizeof(NetPacket_Head<0x2afa>) == 4, "sizeof(NetPacket_Head<0x2afa>) == 4");
+template<>
+struct NetPacket_Repeat<0x2afa>
+{
+    NetString<sizeof(MapName)> map_name;
+};
+static_assert(offsetof(NetPacket_Repeat<0x2afa>, map_name) == 0, "offsetof(NetPacket_Repeat<0x2afa>, map_name) == 0");
+static_assert(sizeof(NetPacket_Repeat<0x2afa>) == 16, "sizeof(NetPacket_Repeat<0x2afa>) == 16");
+
+template<>
+struct NetPacket_Fixed<0x2afa>
+{
+    Little16 magic_packet_id;
+    Little32 source_item_id;
+    Little32 dest_item_id;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2afa>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2afa>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2afa>, source_item_id) == 2, "offsetof(NetPacket_Fixed<0x2afa>, source_item_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x2afa>, dest_item_id) == 6, "offsetof(NetPacket_Fixed<0x2afa>, dest_item_id) == 6");
+static_assert(sizeof(NetPacket_Fixed<0x2afa>) == 10, "sizeof(NetPacket_Fixed<0x2afa>) == 10");
+
+template<>
+struct NetPacket_Fixed<0x2afb>
+{
+    Little16 magic_packet_id;
+    Byte unknown;
+    NetString<sizeof(CharName)> whisper_name;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2afb>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2afb>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2afb>, unknown) == 2, "offsetof(NetPacket_Fixed<0x2afb>, unknown) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x2afb>, whisper_name) == 3, "offsetof(NetPacket_Fixed<0x2afb>, whisper_name) == 3");
+static_assert(sizeof(NetPacket_Fixed<0x2afb>) == 27, "sizeof(NetPacket_Fixed<0x2afb>) == 27");
+
+template<>
+struct NetPacket_Fixed<0x2afc>
+{
+    Little16 magic_packet_id;
+    Little32 account_id;
+    Little32 char_id;
+    Little32 login_id1;
+    Little32 login_id2;
+    IP4Address ip;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2afc>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2afc>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2afc>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2afc>, account_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x2afc>, char_id) == 6, "offsetof(NetPacket_Fixed<0x2afc>, char_id) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x2afc>, login_id1) == 10, "offsetof(NetPacket_Fixed<0x2afc>, login_id1) == 10");
+static_assert(offsetof(NetPacket_Fixed<0x2afc>, login_id2) == 14, "offsetof(NetPacket_Fixed<0x2afc>, login_id2) == 14");
+static_assert(offsetof(NetPacket_Fixed<0x2afc>, ip) == 18, "offsetof(NetPacket_Fixed<0x2afc>, ip) == 18");
+static_assert(sizeof(NetPacket_Fixed<0x2afc>) == 22, "sizeof(NetPacket_Fixed<0x2afc>) == 22");
+
+template<>
+struct NetPacket_Payload<0x2afd>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+    Little32 account_id;
+    Little32 login_id2;
+    Little32 connect_until;
+    Little16 packet_tmw_version;
+    CharKey char_key;
+    CharData char_data;
+};
+static_assert(offsetof(NetPacket_Payload<0x2afd>, magic_packet_id) == 0, "offsetof(NetPacket_Payload<0x2afd>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Payload<0x2afd>, magic_packet_length) == 2, "offsetof(NetPacket_Payload<0x2afd>, magic_packet_length) == 2");
+static_assert(offsetof(NetPacket_Payload<0x2afd>, account_id) == 4, "offsetof(NetPacket_Payload<0x2afd>, account_id) == 4");
+static_assert(offsetof(NetPacket_Payload<0x2afd>, login_id2) == 8, "offsetof(NetPacket_Payload<0x2afd>, login_id2) == 8");
+static_assert(offsetof(NetPacket_Payload<0x2afd>, connect_until) == 12, "offsetof(NetPacket_Payload<0x2afd>, connect_until) == 12");
+static_assert(offsetof(NetPacket_Payload<0x2afd>, packet_tmw_version) == 16, "offsetof(NetPacket_Payload<0x2afd>, packet_tmw_version) == 16");
+static_assert(offsetof(NetPacket_Payload<0x2afd>, char_key) == 18, "offsetof(NetPacket_Payload<0x2afd>, char_key) == 18");
+
+template<>
+struct NetPacket_Fixed<0x2afe>
+{
+    Little16 magic_packet_id;
+    Little32 account_id;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2afe>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2afe>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2afe>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2afe>, account_id) == 2");
+static_assert(sizeof(NetPacket_Fixed<0x2afe>) == 6, "sizeof(NetPacket_Fixed<0x2afe>) == 6");
+
+template<>
+struct NetPacket_Head<0x2aff>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+    Little16 users;
+};
+static_assert(offsetof(NetPacket_Head<0x2aff>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x2aff>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Head<0x2aff>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x2aff>, magic_packet_length) == 2");
+static_assert(offsetof(NetPacket_Head<0x2aff>, users) == 4, "offsetof(NetPacket_Head<0x2aff>, users) == 4");
+static_assert(sizeof(NetPacket_Head<0x2aff>) == 6, "sizeof(NetPacket_Head<0x2aff>) == 6");
+template<>
+struct NetPacket_Repeat<0x2aff>
+{
+    Little32 char_id;
+};
+static_assert(offsetof(NetPacket_Repeat<0x2aff>, char_id) == 0, "offsetof(NetPacket_Repeat<0x2aff>, char_id) == 0");
+static_assert(sizeof(NetPacket_Repeat<0x2aff>) == 4, "sizeof(NetPacket_Repeat<0x2aff>) == 4");
+
+template<>
+struct NetPacket_Fixed<0x2b00>
+{
+    Little16 magic_packet_id;
+    Little32 users;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2b00>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b00>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2b00>, users) == 2, "offsetof(NetPacket_Fixed<0x2b00>, users) == 2");
+static_assert(sizeof(NetPacket_Fixed<0x2b00>) == 6, "sizeof(NetPacket_Fixed<0x2b00>) == 6");
+
+template<>
+struct NetPacket_Payload<0x2b01>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+    Little32 account_id;
+    Little32 char_id;
+    CharKey char_key;
+    CharData char_data;
+};
+static_assert(offsetof(NetPacket_Payload<0x2b01>, magic_packet_id) == 0, "offsetof(NetPacket_Payload<0x2b01>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Payload<0x2b01>, magic_packet_length) == 2, "offsetof(NetPacket_Payload<0x2b01>, magic_packet_length) == 2");
+static_assert(offsetof(NetPacket_Payload<0x2b01>, account_id) == 4, "offsetof(NetPacket_Payload<0x2b01>, account_id) == 4");
+static_assert(offsetof(NetPacket_Payload<0x2b01>, char_id) == 8, "offsetof(NetPacket_Payload<0x2b01>, char_id) == 8");
+static_assert(offsetof(NetPacket_Payload<0x2b01>, char_key) == 12, "offsetof(NetPacket_Payload<0x2b01>, char_key) == 12");
+
+template<>
+struct NetPacket_Fixed<0x2b02>
+{
+    Little16 magic_packet_id;
+    Little32 account_id;
+    Little32 login_id1;
+    Little32 login_id2;
+    IP4Address ip;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2b02>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b02>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2b02>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b02>, account_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x2b02>, login_id1) == 6, "offsetof(NetPacket_Fixed<0x2b02>, login_id1) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x2b02>, login_id2) == 10, "offsetof(NetPacket_Fixed<0x2b02>, login_id2) == 10");
+static_assert(offsetof(NetPacket_Fixed<0x2b02>, ip) == 14, "offsetof(NetPacket_Fixed<0x2b02>, ip) == 14");
+static_assert(sizeof(NetPacket_Fixed<0x2b02>) == 18, "sizeof(NetPacket_Fixed<0x2b02>) == 18");
+
+template<>
+struct NetPacket_Fixed<0x2b03>
+{
+    Little16 magic_packet_id;
+    Little32 account_id;
+    Byte unknown;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2b03>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b03>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2b03>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b03>, account_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x2b03>, unknown) == 6, "offsetof(NetPacket_Fixed<0x2b03>, unknown) == 6");
+static_assert(sizeof(NetPacket_Fixed<0x2b03>) == 7, "sizeof(NetPacket_Fixed<0x2b03>) == 7");
+
+template<>
+struct NetPacket_Head<0x2b04>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+    IP4Address ip;
+    Little16 port;
+};
+static_assert(offsetof(NetPacket_Head<0x2b04>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x2b04>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Head<0x2b04>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x2b04>, magic_packet_length) == 2");
+static_assert(offsetof(NetPacket_Head<0x2b04>, ip) == 4, "offsetof(NetPacket_Head<0x2b04>, ip) == 4");
+static_assert(offsetof(NetPacket_Head<0x2b04>, port) == 8, "offsetof(NetPacket_Head<0x2b04>, port) == 8");
+static_assert(sizeof(NetPacket_Head<0x2b04>) == 10, "sizeof(NetPacket_Head<0x2b04>) == 10");
+template<>
+struct NetPacket_Repeat<0x2b04>
+{
+    NetString<sizeof(MapName)> map_name;
+};
+static_assert(offsetof(NetPacket_Repeat<0x2b04>, map_name) == 0, "offsetof(NetPacket_Repeat<0x2b04>, map_name) == 0");
+static_assert(sizeof(NetPacket_Repeat<0x2b04>) == 16, "sizeof(NetPacket_Repeat<0x2b04>) == 16");
+
+template<>
+struct NetPacket_Fixed<0x2b05>
+{
+    Little16 magic_packet_id;
+    Little32 account_id;
+    Little32 login_id1;
+    Little32 login_id2;
+    Little32 char_id;
+    NetString<sizeof(MapName)> map_name;
+    Little16 x;
+    Little16 y;
+    IP4Address map_ip;
+    Little16 map_port;
+    Byte sex;
+    IP4Address client_ip;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2b05>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b05>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2b05>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b05>, account_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x2b05>, login_id1) == 6, "offsetof(NetPacket_Fixed<0x2b05>, login_id1) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x2b05>, login_id2) == 10, "offsetof(NetPacket_Fixed<0x2b05>, login_id2) == 10");
+static_assert(offsetof(NetPacket_Fixed<0x2b05>, char_id) == 14, "offsetof(NetPacket_Fixed<0x2b05>, char_id) == 14");
+static_assert(offsetof(NetPacket_Fixed<0x2b05>, map_name) == 18, "offsetof(NetPacket_Fixed<0x2b05>, map_name) == 18");
+static_assert(offsetof(NetPacket_Fixed<0x2b05>, x) == 34, "offsetof(NetPacket_Fixed<0x2b05>, x) == 34");
+static_assert(offsetof(NetPacket_Fixed<0x2b05>, y) == 36, "offsetof(NetPacket_Fixed<0x2b05>, y) == 36");
+static_assert(offsetof(NetPacket_Fixed<0x2b05>, map_ip) == 38, "offsetof(NetPacket_Fixed<0x2b05>, map_ip) == 38");
+static_assert(offsetof(NetPacket_Fixed<0x2b05>, map_port) == 42, "offsetof(NetPacket_Fixed<0x2b05>, map_port) == 42");
+static_assert(offsetof(NetPacket_Fixed<0x2b05>, sex) == 44, "offsetof(NetPacket_Fixed<0x2b05>, sex) == 44");
+static_assert(offsetof(NetPacket_Fixed<0x2b05>, client_ip) == 45, "offsetof(NetPacket_Fixed<0x2b05>, client_ip) == 45");
+static_assert(sizeof(NetPacket_Fixed<0x2b05>) == 49, "sizeof(NetPacket_Fixed<0x2b05>) == 49");
+
+template<>
+struct NetPacket_Fixed<0x2b06>
+{
+    Little16 magic_packet_id;
+    Little32 account_id;
+    Little32 error;
+    Little32 unknown;
+    Little32 char_id;
+    NetString<sizeof(MapName)> map_name;
+    Little16 x;
+    Little16 y;
+    IP4Address map_ip;
+    Little16 map_port;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2b06>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b06>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2b06>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b06>, account_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x2b06>, error) == 6, "offsetof(NetPacket_Fixed<0x2b06>, error) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x2b06>, unknown) == 10, "offsetof(NetPacket_Fixed<0x2b06>, unknown) == 10");
+static_assert(offsetof(NetPacket_Fixed<0x2b06>, char_id) == 14, "offsetof(NetPacket_Fixed<0x2b06>, char_id) == 14");
+static_assert(offsetof(NetPacket_Fixed<0x2b06>, map_name) == 18, "offsetof(NetPacket_Fixed<0x2b06>, map_name) == 18");
+static_assert(offsetof(NetPacket_Fixed<0x2b06>, x) == 34, "offsetof(NetPacket_Fixed<0x2b06>, x) == 34");
+static_assert(offsetof(NetPacket_Fixed<0x2b06>, y) == 36, "offsetof(NetPacket_Fixed<0x2b06>, y) == 36");
+static_assert(offsetof(NetPacket_Fixed<0x2b06>, map_ip) == 38, "offsetof(NetPacket_Fixed<0x2b06>, map_ip) == 38");
+static_assert(offsetof(NetPacket_Fixed<0x2b06>, map_port) == 42, "offsetof(NetPacket_Fixed<0x2b06>, map_port) == 42");
+static_assert(sizeof(NetPacket_Fixed<0x2b06>) == 44, "sizeof(NetPacket_Fixed<0x2b06>) == 44");
+
+template<>
+struct NetPacket_Head<0x2b0a>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+    Little32 account_id;
+};
+static_assert(offsetof(NetPacket_Head<0x2b0a>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x2b0a>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Head<0x2b0a>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x2b0a>, magic_packet_length) == 2");
+static_assert(offsetof(NetPacket_Head<0x2b0a>, account_id) == 4, "offsetof(NetPacket_Head<0x2b0a>, account_id) == 4");
+static_assert(sizeof(NetPacket_Head<0x2b0a>) == 8, "sizeof(NetPacket_Head<0x2b0a>) == 8");
+template<>
+struct NetPacket_Repeat<0x2b0a>
+{
+    Byte c;
+};
+static_assert(offsetof(NetPacket_Repeat<0x2b0a>, c) == 0, "offsetof(NetPacket_Repeat<0x2b0a>, c) == 0");
+static_assert(sizeof(NetPacket_Repeat<0x2b0a>) == 1, "sizeof(NetPacket_Repeat<0x2b0a>) == 1");
+
+template<>
+struct NetPacket_Fixed<0x2b0b>
+{
+    Little16 magic_packet_id;
+    Little32 account_id;
+    Little32 gm_level;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2b0b>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b0b>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2b0b>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b0b>, account_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x2b0b>, gm_level) == 6, "offsetof(NetPacket_Fixed<0x2b0b>, gm_level) == 6");
+static_assert(sizeof(NetPacket_Fixed<0x2b0b>) == 10, "sizeof(NetPacket_Fixed<0x2b0b>) == 10");
+
+template<>
+struct NetPacket_Fixed<0x2b0c>
+{
+    Little16 magic_packet_id;
+    Little32 account_id;
+    NetString<sizeof(AccountEmail)> old_email;
+    NetString<sizeof(AccountEmail)> new_email;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2b0c>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b0c>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2b0c>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b0c>, account_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x2b0c>, old_email) == 6, "offsetof(NetPacket_Fixed<0x2b0c>, old_email) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x2b0c>, new_email) == 46, "offsetof(NetPacket_Fixed<0x2b0c>, new_email) == 46");
+static_assert(sizeof(NetPacket_Fixed<0x2b0c>) == 86, "sizeof(NetPacket_Fixed<0x2b0c>) == 86");
+
+template<>
+struct NetPacket_Fixed<0x2b0d>
+{
+    Little16 magic_packet_id;
+    Little32 account_id;
+    Byte sex;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2b0d>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b0d>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2b0d>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b0d>, account_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x2b0d>, sex) == 6, "offsetof(NetPacket_Fixed<0x2b0d>, sex) == 6");
+static_assert(sizeof(NetPacket_Fixed<0x2b0d>) == 7, "sizeof(NetPacket_Fixed<0x2b0d>) == 7");
+
+template<>
+struct NetPacket_Fixed<0x2b0e>
+{
+    Little16 magic_packet_id;
+    Little32 account_id;
+    NetString<sizeof(CharName)> char_name;
+    Little16 operation;
+    NetHumanTimeDiff ban_add;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2b0e>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b0e>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2b0e>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b0e>, account_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x2b0e>, char_name) == 6, "offsetof(NetPacket_Fixed<0x2b0e>, char_name) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x2b0e>, operation) == 30, "offsetof(NetPacket_Fixed<0x2b0e>, operation) == 30");
+static_assert(offsetof(NetPacket_Fixed<0x2b0e>, ban_add) == 32, "offsetof(NetPacket_Fixed<0x2b0e>, ban_add) == 32");
+static_assert(sizeof(NetPacket_Fixed<0x2b0e>) == 44, "sizeof(NetPacket_Fixed<0x2b0e>) == 44");
+
+template<>
+struct NetPacket_Fixed<0x2b0f>
+{
+    Little16 magic_packet_id;
+    Little32 account_id;
+    NetString<sizeof(CharName)> char_name;
+    Little16 operation;
+    Little16 error;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2b0f>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b0f>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2b0f>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b0f>, account_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x2b0f>, char_name) == 6, "offsetof(NetPacket_Fixed<0x2b0f>, char_name) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x2b0f>, operation) == 30, "offsetof(NetPacket_Fixed<0x2b0f>, operation) == 30");
+static_assert(offsetof(NetPacket_Fixed<0x2b0f>, error) == 32, "offsetof(NetPacket_Fixed<0x2b0f>, error) == 32");
+static_assert(sizeof(NetPacket_Fixed<0x2b0f>) == 34, "sizeof(NetPacket_Fixed<0x2b0f>) == 34");
+
+template<>
+struct NetPacket_Head<0x2b10>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+    Little32 account_id;
+};
+static_assert(offsetof(NetPacket_Head<0x2b10>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x2b10>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Head<0x2b10>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x2b10>, magic_packet_length) == 2");
+static_assert(offsetof(NetPacket_Head<0x2b10>, account_id) == 4, "offsetof(NetPacket_Head<0x2b10>, account_id) == 4");
+static_assert(sizeof(NetPacket_Head<0x2b10>) == 8, "sizeof(NetPacket_Head<0x2b10>) == 8");
+template<>
+struct NetPacket_Repeat<0x2b10>
+{
+    NetString<sizeof(VarName)> name;
+    Little32 value;
+};
+static_assert(offsetof(NetPacket_Repeat<0x2b10>, name) == 0, "offsetof(NetPacket_Repeat<0x2b10>, name) == 0");
+static_assert(offsetof(NetPacket_Repeat<0x2b10>, value) == 32, "offsetof(NetPacket_Repeat<0x2b10>, value) == 32");
+static_assert(sizeof(NetPacket_Repeat<0x2b10>) == 36, "sizeof(NetPacket_Repeat<0x2b10>) == 36");
+
+template<>
+struct NetPacket_Head<0x2b11>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+    Little32 account_id;
+};
+static_assert(offsetof(NetPacket_Head<0x2b11>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x2b11>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Head<0x2b11>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x2b11>, magic_packet_length) == 2");
+static_assert(offsetof(NetPacket_Head<0x2b11>, account_id) == 4, "offsetof(NetPacket_Head<0x2b11>, account_id) == 4");
+static_assert(sizeof(NetPacket_Head<0x2b11>) == 8, "sizeof(NetPacket_Head<0x2b11>) == 8");
+template<>
+struct NetPacket_Repeat<0x2b11>
+{
+    NetString<sizeof(VarName)> name;
+    Little32 value;
+};
+static_assert(offsetof(NetPacket_Repeat<0x2b11>, name) == 0, "offsetof(NetPacket_Repeat<0x2b11>, name) == 0");
+static_assert(offsetof(NetPacket_Repeat<0x2b11>, value) == 32, "offsetof(NetPacket_Repeat<0x2b11>, value) == 32");
+static_assert(sizeof(NetPacket_Repeat<0x2b11>) == 36, "sizeof(NetPacket_Repeat<0x2b11>) == 36");
+
+template<>
+struct NetPacket_Fixed<0x2b12>
+{
+    Little16 magic_packet_id;
+    Little32 char_id;
+    Little32 partner_id;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2b12>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b12>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2b12>, char_id) == 2, "offsetof(NetPacket_Fixed<0x2b12>, char_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x2b12>, partner_id) == 6, "offsetof(NetPacket_Fixed<0x2b12>, partner_id) == 6");
+static_assert(sizeof(NetPacket_Fixed<0x2b12>) == 10, "sizeof(NetPacket_Fixed<0x2b12>) == 10");
+
+template<>
+struct NetPacket_Fixed<0x2b13>
+{
+    Little16 magic_packet_id;
+    Little32 account_id;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2b13>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b13>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2b13>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b13>, account_id) == 2");
+static_assert(sizeof(NetPacket_Fixed<0x2b13>) == 6, "sizeof(NetPacket_Fixed<0x2b13>) == 6");
+
+template<>
+struct NetPacket_Fixed<0x2b14>
+{
+    Little16 magic_packet_id;
+    Little32 account_id;
+    Byte ban_not_status;
+    Little32 status_or_ban_until;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2b14>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b14>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2b14>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b14>, account_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x2b14>, ban_not_status) == 6, "offsetof(NetPacket_Fixed<0x2b14>, ban_not_status) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x2b14>, status_or_ban_until) == 7, "offsetof(NetPacket_Fixed<0x2b14>, status_or_ban_until) == 7");
+static_assert(sizeof(NetPacket_Fixed<0x2b14>) == 11, "sizeof(NetPacket_Fixed<0x2b14>) == 11");
+
+template<>
+struct NetPacket_Head<0x2b15>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+};
+static_assert(offsetof(NetPacket_Head<0x2b15>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x2b15>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Head<0x2b15>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x2b15>, magic_packet_length) == 2");
+static_assert(sizeof(NetPacket_Head<0x2b15>) == 4, "sizeof(NetPacket_Head<0x2b15>) == 4");
+template<>
+struct NetPacket_Repeat<0x2b15>
+{
+    Little32 account_id;
+    Byte gm_level;
+};
+static_assert(offsetof(NetPacket_Repeat<0x2b15>, account_id) == 0, "offsetof(NetPacket_Repeat<0x2b15>, account_id) == 0");
+static_assert(offsetof(NetPacket_Repeat<0x2b15>, gm_level) == 4, "offsetof(NetPacket_Repeat<0x2b15>, gm_level) == 4");
+static_assert(sizeof(NetPacket_Repeat<0x2b15>) == 5, "sizeof(NetPacket_Repeat<0x2b15>) == 5");
+
+template<>
+struct NetPacket_Fixed<0x2b16>
+{
+    Little16 magic_packet_id;
+    Little32 char_id;
+};
+static_assert(offsetof(NetPacket_Fixed<0x2b16>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b16>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x2b16>, char_id) == 2, "offsetof(NetPacket_Fixed<0x2b16>, char_id) == 2");
+static_assert(sizeof(NetPacket_Fixed<0x2b16>) == 6, "sizeof(NetPacket_Fixed<0x2b16>) == 6");
+
+template<>
+struct NetPacket_Head<0x3000>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+};
+static_assert(offsetof(NetPacket_Head<0x3000>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3000>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Head<0x3000>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3000>, magic_packet_length) == 2");
+static_assert(sizeof(NetPacket_Head<0x3000>) == 4, "sizeof(NetPacket_Head<0x3000>) == 4");
+template<>
+struct NetPacket_Repeat<0x3000>
+{
+    Byte c;
+};
+static_assert(offsetof(NetPacket_Repeat<0x3000>, c) == 0, "offsetof(NetPacket_Repeat<0x3000>, c) == 0");
+static_assert(sizeof(NetPacket_Repeat<0x3000>) == 1, "sizeof(NetPacket_Repeat<0x3000>) == 1");
+
+template<>
+struct NetPacket_Head<0x3001>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+    NetString<sizeof(CharName)> from_char_name;
+    NetString<sizeof(CharName)> to_char_name;
+};
+static_assert(offsetof(NetPacket_Head<0x3001>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3001>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Head<0x3001>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3001>, magic_packet_length) == 2");
+static_assert(offsetof(NetPacket_Head<0x3001>, from_char_name) == 4, "offsetof(NetPacket_Head<0x3001>, from_char_name) == 4");
+static_assert(offsetof(NetPacket_Head<0x3001>, to_char_name) == 28, "offsetof(NetPacket_Head<0x3001>, to_char_name) == 28");
+static_assert(sizeof(NetPacket_Head<0x3001>) == 52, "sizeof(NetPacket_Head<0x3001>) == 52");
+template<>
+struct NetPacket_Repeat<0x3001>
+{
+    Byte c;
+};
+static_assert(offsetof(NetPacket_Repeat<0x3001>, c) == 0, "offsetof(NetPacket_Repeat<0x3001>, c) == 0");
+static_assert(sizeof(NetPacket_Repeat<0x3001>) == 1, "sizeof(NetPacket_Repeat<0x3001>) == 1");
+
+template<>
+struct NetPacket_Fixed<0x3002>
+{
+    Little16 magic_packet_id;
+    Little32 char_id;
+    Byte flag;
+};
+static_assert(offsetof(NetPacket_Fixed<0x3002>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3002>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x3002>, char_id) == 2, "offsetof(NetPacket_Fixed<0x3002>, char_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x3002>, flag) == 6, "offsetof(NetPacket_Fixed<0x3002>, flag) == 6");
+static_assert(sizeof(NetPacket_Fixed<0x3002>) == 7, "sizeof(NetPacket_Fixed<0x3002>) == 7");
+
+template<>
+struct NetPacket_Head<0x3003>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+    NetString<sizeof(CharName)> char_name;
+    Little16 min_gm_level;
+};
+static_assert(offsetof(NetPacket_Head<0x3003>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3003>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Head<0x3003>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3003>, magic_packet_length) == 2");
+static_assert(offsetof(NetPacket_Head<0x3003>, char_name) == 4, "offsetof(NetPacket_Head<0x3003>, char_name) == 4");
+static_assert(offsetof(NetPacket_Head<0x3003>, min_gm_level) == 28, "offsetof(NetPacket_Head<0x3003>, min_gm_level) == 28");
+static_assert(sizeof(NetPacket_Head<0x3003>) == 30, "sizeof(NetPacket_Head<0x3003>) == 30");
+template<>
+struct NetPacket_Repeat<0x3003>
+{
+    Byte c;
+};
+static_assert(offsetof(NetPacket_Repeat<0x3003>, c) == 0, "offsetof(NetPacket_Repeat<0x3003>, c) == 0");
+static_assert(sizeof(NetPacket_Repeat<0x3003>) == 1, "sizeof(NetPacket_Repeat<0x3003>) == 1");
+
+template<>
+struct NetPacket_Head<0x3004>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+    Little32 account_id;
+};
+static_assert(offsetof(NetPacket_Head<0x3004>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3004>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Head<0x3004>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3004>, magic_packet_length) == 2");
+static_assert(offsetof(NetPacket_Head<0x3004>, account_id) == 4, "offsetof(NetPacket_Head<0x3004>, account_id) == 4");
+static_assert(sizeof(NetPacket_Head<0x3004>) == 8, "sizeof(NetPacket_Head<0x3004>) == 8");
+template<>
+struct NetPacket_Repeat<0x3004>
+{
+    NetString<sizeof(VarName)> name;
+    Little32 value;
+};
+static_assert(offsetof(NetPacket_Repeat<0x3004>, name) == 0, "offsetof(NetPacket_Repeat<0x3004>, name) == 0");
+static_assert(offsetof(NetPacket_Repeat<0x3004>, value) == 32, "offsetof(NetPacket_Repeat<0x3004>, value) == 32");
+static_assert(sizeof(NetPacket_Repeat<0x3004>) == 36, "sizeof(NetPacket_Repeat<0x3004>) == 36");
+
+template<>
+struct NetPacket_Fixed<0x3005>
+{
+    Little16 magic_packet_id;
+    Little32 account_id;
+};
+static_assert(offsetof(NetPacket_Fixed<0x3005>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3005>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x3005>, account_id) == 2, "offsetof(NetPacket_Fixed<0x3005>, account_id) == 2");
+static_assert(sizeof(NetPacket_Fixed<0x3005>) == 6, "sizeof(NetPacket_Fixed<0x3005>) == 6");
+
+template<>
+struct NetPacket_Fixed<0x3010>
+{
+    Little16 magic_packet_id;
+    Little32 account_id;
+};
+static_assert(offsetof(NetPacket_Fixed<0x3010>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3010>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x3010>, account_id) == 2, "offsetof(NetPacket_Fixed<0x3010>, account_id) == 2");
+static_assert(sizeof(NetPacket_Fixed<0x3010>) == 6, "sizeof(NetPacket_Fixed<0x3010>) == 6");
+
+template<>
+struct NetPacket_Payload<0x3011>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+    Little32 account_id;
+    Storage storage;
+};
+static_assert(offsetof(NetPacket_Payload<0x3011>, magic_packet_id) == 0, "offsetof(NetPacket_Payload<0x3011>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Payload<0x3011>, magic_packet_length) == 2, "offsetof(NetPacket_Payload<0x3011>, magic_packet_length) == 2");
+static_assert(offsetof(NetPacket_Payload<0x3011>, account_id) == 4, "offsetof(NetPacket_Payload<0x3011>, account_id) == 4");
+static_assert(offsetof(NetPacket_Payload<0x3011>, storage) == 8, "offsetof(NetPacket_Payload<0x3011>, storage) == 8");
+
+template<>
+struct NetPacket_Fixed<0x3020>
+{
+    Little16 magic_packet_id;
+    Little32 account_id;
+    NetString<sizeof(PartyName)> party_name;
+    NetString<sizeof(CharName)> char_name;
+    NetString<sizeof(MapName)> map_name;
+    Little16 level;
+};
+static_assert(offsetof(NetPacket_Fixed<0x3020>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3020>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x3020>, account_id) == 2, "offsetof(NetPacket_Fixed<0x3020>, account_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x3020>, party_name) == 6, "offsetof(NetPacket_Fixed<0x3020>, party_name) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x3020>, char_name) == 30, "offsetof(NetPacket_Fixed<0x3020>, char_name) == 30");
+static_assert(offsetof(NetPacket_Fixed<0x3020>, map_name) == 54, "offsetof(NetPacket_Fixed<0x3020>, map_name) == 54");
+static_assert(offsetof(NetPacket_Fixed<0x3020>, level) == 70, "offsetof(NetPacket_Fixed<0x3020>, level) == 70");
+static_assert(sizeof(NetPacket_Fixed<0x3020>) == 72, "sizeof(NetPacket_Fixed<0x3020>) == 72");
+
+template<>
+struct NetPacket_Fixed<0x3021>
+{
+    Little16 magic_packet_id;
+    Little32 party_id;
+};
+static_assert(offsetof(NetPacket_Fixed<0x3021>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3021>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x3021>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3021>, party_id) == 2");
+static_assert(sizeof(NetPacket_Fixed<0x3021>) == 6, "sizeof(NetPacket_Fixed<0x3021>) == 6");
+
+template<>
+struct NetPacket_Fixed<0x3022>
+{
+    Little16 magic_packet_id;
+    Little32 party_id;
+    Little32 account_id;
+    NetString<sizeof(CharName)> char_name;
+    NetString<sizeof(MapName)> map_name;
+    Little16 level;
+};
+static_assert(offsetof(NetPacket_Fixed<0x3022>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3022>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x3022>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3022>, party_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x3022>, account_id) == 6, "offsetof(NetPacket_Fixed<0x3022>, account_id) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x3022>, char_name) == 10, "offsetof(NetPacket_Fixed<0x3022>, char_name) == 10");
+static_assert(offsetof(NetPacket_Fixed<0x3022>, map_name) == 34, "offsetof(NetPacket_Fixed<0x3022>, map_name) == 34");
+static_assert(offsetof(NetPacket_Fixed<0x3022>, level) == 50, "offsetof(NetPacket_Fixed<0x3022>, level) == 50");
+static_assert(sizeof(NetPacket_Fixed<0x3022>) == 52, "sizeof(NetPacket_Fixed<0x3022>) == 52");
+
+template<>
+struct NetPacket_Fixed<0x3023>
+{
+    Little16 magic_packet_id;
+    Little32 party_id;
+    Little32 account_id;
+    Little16 exp;
+    Little16 item;
+};
+static_assert(offsetof(NetPacket_Fixed<0x3023>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3023>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x3023>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3023>, party_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x3023>, account_id) == 6, "offsetof(NetPacket_Fixed<0x3023>, account_id) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x3023>, exp) == 10, "offsetof(NetPacket_Fixed<0x3023>, exp) == 10");
+static_assert(offsetof(NetPacket_Fixed<0x3023>, item) == 12, "offsetof(NetPacket_Fixed<0x3023>, item) == 12");
+static_assert(sizeof(NetPacket_Fixed<0x3023>) == 14, "sizeof(NetPacket_Fixed<0x3023>) == 14");
+
+template<>
+struct NetPacket_Fixed<0x3024>
+{
+    Little16 magic_packet_id;
+    Little32 party_id;
+    Little32 account_id;
+};
+static_assert(offsetof(NetPacket_Fixed<0x3024>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3024>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x3024>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3024>, party_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x3024>, account_id) == 6, "offsetof(NetPacket_Fixed<0x3024>, account_id) == 6");
+static_assert(sizeof(NetPacket_Fixed<0x3024>) == 10, "sizeof(NetPacket_Fixed<0x3024>) == 10");
+
+template<>
+struct NetPacket_Fixed<0x3025>
+{
+    Little16 magic_packet_id;
+    Little32 party_id;
+    Little32 account_id;
+    NetString<sizeof(MapName)> map_name;
+    Byte online;
+    Little16 level;
+};
+static_assert(offsetof(NetPacket_Fixed<0x3025>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3025>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x3025>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3025>, party_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x3025>, account_id) == 6, "offsetof(NetPacket_Fixed<0x3025>, account_id) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x3025>, map_name) == 10, "offsetof(NetPacket_Fixed<0x3025>, map_name) == 10");
+static_assert(offsetof(NetPacket_Fixed<0x3025>, online) == 26, "offsetof(NetPacket_Fixed<0x3025>, online) == 26");
+static_assert(offsetof(NetPacket_Fixed<0x3025>, level) == 27, "offsetof(NetPacket_Fixed<0x3025>, level) == 27");
+static_assert(sizeof(NetPacket_Fixed<0x3025>) == 29, "sizeof(NetPacket_Fixed<0x3025>) == 29");
+
+template<>
+struct NetPacket_Fixed<0x3026>
+{
+    Little16 magic_packet_id;
+    Little32 party_id;
+};
+static_assert(offsetof(NetPacket_Fixed<0x3026>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3026>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x3026>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3026>, party_id) == 2");
+static_assert(sizeof(NetPacket_Fixed<0x3026>) == 6, "sizeof(NetPacket_Fixed<0x3026>) == 6");
+
+template<>
+struct NetPacket_Head<0x3027>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+    Little32 party_id;
+    Little32 account_id;
+};
+static_assert(offsetof(NetPacket_Head<0x3027>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3027>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Head<0x3027>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3027>, magic_packet_length) == 2");
+static_assert(offsetof(NetPacket_Head<0x3027>, party_id) == 4, "offsetof(NetPacket_Head<0x3027>, party_id) == 4");
+static_assert(offsetof(NetPacket_Head<0x3027>, account_id) == 8, "offsetof(NetPacket_Head<0x3027>, account_id) == 8");
+static_assert(sizeof(NetPacket_Head<0x3027>) == 12, "sizeof(NetPacket_Head<0x3027>) == 12");
+template<>
+struct NetPacket_Repeat<0x3027>
+{
+    Byte c;
+};
+static_assert(offsetof(NetPacket_Repeat<0x3027>, c) == 0, "offsetof(NetPacket_Repeat<0x3027>, c) == 0");
+static_assert(sizeof(NetPacket_Repeat<0x3027>) == 1, "sizeof(NetPacket_Repeat<0x3027>) == 1");
+
+template<>
+struct NetPacket_Fixed<0x3028>
+{
+    Little16 magic_packet_id;
+    Little32 party_id;
+    Little32 account_id;
+    NetString<sizeof(CharName)> char_name;
+};
+static_assert(offsetof(NetPacket_Fixed<0x3028>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3028>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x3028>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3028>, party_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x3028>, account_id) == 6, "offsetof(NetPacket_Fixed<0x3028>, account_id) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x3028>, char_name) == 10, "offsetof(NetPacket_Fixed<0x3028>, char_name) == 10");
+static_assert(sizeof(NetPacket_Fixed<0x3028>) == 34, "sizeof(NetPacket_Fixed<0x3028>) == 34");
+
+template<>
+struct NetPacket_Head<0x3800>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+};
+static_assert(offsetof(NetPacket_Head<0x3800>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3800>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Head<0x3800>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3800>, magic_packet_length) == 2");
+static_assert(sizeof(NetPacket_Head<0x3800>) == 4, "sizeof(NetPacket_Head<0x3800>) == 4");
+template<>
+struct NetPacket_Repeat<0x3800>
+{
+    Byte c;
+};
+static_assert(offsetof(NetPacket_Repeat<0x3800>, c) == 0, "offsetof(NetPacket_Repeat<0x3800>, c) == 0");
+static_assert(sizeof(NetPacket_Repeat<0x3800>) == 1, "sizeof(NetPacket_Repeat<0x3800>) == 1");
+
+template<>
+struct NetPacket_Head<0x3801>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+    Little32 whisper_id;
+    NetString<sizeof(CharName)> src_char_name;
+    NetString<sizeof(CharName)> dst_char_name;
+};
+static_assert(offsetof(NetPacket_Head<0x3801>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3801>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Head<0x3801>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3801>, magic_packet_length) == 2");
+static_assert(offsetof(NetPacket_Head<0x3801>, whisper_id) == 4, "offsetof(NetPacket_Head<0x3801>, whisper_id) == 4");
+static_assert(offsetof(NetPacket_Head<0x3801>, src_char_name) == 8, "offsetof(NetPacket_Head<0x3801>, src_char_name) == 8");
+static_assert(offsetof(NetPacket_Head<0x3801>, dst_char_name) == 32, "offsetof(NetPacket_Head<0x3801>, dst_char_name) == 32");
+static_assert(sizeof(NetPacket_Head<0x3801>) == 56, "sizeof(NetPacket_Head<0x3801>) == 56");
+template<>
+struct NetPacket_Repeat<0x3801>
+{
+    Byte c;
+};
+static_assert(offsetof(NetPacket_Repeat<0x3801>, c) == 0, "offsetof(NetPacket_Repeat<0x3801>, c) == 0");
+static_assert(sizeof(NetPacket_Repeat<0x3801>) == 1, "sizeof(NetPacket_Repeat<0x3801>) == 1");
+
+template<>
+struct NetPacket_Fixed<0x3802>
+{
+    Little16 magic_packet_id;
+    NetString<sizeof(CharName)> sender_char_name;
+    Byte flag;
+};
+static_assert(offsetof(NetPacket_Fixed<0x3802>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3802>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x3802>, sender_char_name) == 2, "offsetof(NetPacket_Fixed<0x3802>, sender_char_name) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x3802>, flag) == 26, "offsetof(NetPacket_Fixed<0x3802>, flag) == 26");
+static_assert(sizeof(NetPacket_Fixed<0x3802>) == 27, "sizeof(NetPacket_Fixed<0x3802>) == 27");
+
+template<>
+struct NetPacket_Head<0x3803>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+    NetString<sizeof(CharName)> char_name;
+    Little16 min_gm_level;
+};
+static_assert(offsetof(NetPacket_Head<0x3803>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3803>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Head<0x3803>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3803>, magic_packet_length) == 2");
+static_assert(offsetof(NetPacket_Head<0x3803>, char_name) == 4, "offsetof(NetPacket_Head<0x3803>, char_name) == 4");
+static_assert(offsetof(NetPacket_Head<0x3803>, min_gm_level) == 28, "offsetof(NetPacket_Head<0x3803>, min_gm_level) == 28");
+static_assert(sizeof(NetPacket_Head<0x3803>) == 30, "sizeof(NetPacket_Head<0x3803>) == 30");
+template<>
+struct NetPacket_Repeat<0x3803>
+{
+    Byte c;
+};
+static_assert(offsetof(NetPacket_Repeat<0x3803>, c) == 0, "offsetof(NetPacket_Repeat<0x3803>, c) == 0");
+static_assert(sizeof(NetPacket_Repeat<0x3803>) == 1, "sizeof(NetPacket_Repeat<0x3803>) == 1");
+
+template<>
+struct NetPacket_Head<0x3804>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+    Little32 account_id;
+};
+static_assert(offsetof(NetPacket_Head<0x3804>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3804>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Head<0x3804>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3804>, magic_packet_length) == 2");
+static_assert(offsetof(NetPacket_Head<0x3804>, account_id) == 4, "offsetof(NetPacket_Head<0x3804>, account_id) == 4");
+static_assert(sizeof(NetPacket_Head<0x3804>) == 8, "sizeof(NetPacket_Head<0x3804>) == 8");
+template<>
+struct NetPacket_Repeat<0x3804>
+{
+    NetString<sizeof(VarName)> name;
+    Little32 value;
+};
+static_assert(offsetof(NetPacket_Repeat<0x3804>, name) == 0, "offsetof(NetPacket_Repeat<0x3804>, name) == 0");
+static_assert(offsetof(NetPacket_Repeat<0x3804>, value) == 32, "offsetof(NetPacket_Repeat<0x3804>, value) == 32");
+static_assert(sizeof(NetPacket_Repeat<0x3804>) == 36, "sizeof(NetPacket_Repeat<0x3804>) == 36");
+
+template<>
+struct NetPacket_Payload<0x3810>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+    Little32 account_id;
+    Storage storage;
+};
+static_assert(offsetof(NetPacket_Payload<0x3810>, magic_packet_id) == 0, "offsetof(NetPacket_Payload<0x3810>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Payload<0x3810>, magic_packet_length) == 2, "offsetof(NetPacket_Payload<0x3810>, magic_packet_length) == 2");
+static_assert(offsetof(NetPacket_Payload<0x3810>, account_id) == 4, "offsetof(NetPacket_Payload<0x3810>, account_id) == 4");
+static_assert(offsetof(NetPacket_Payload<0x3810>, storage) == 8, "offsetof(NetPacket_Payload<0x3810>, storage) == 8");
+
+template<>
+struct NetPacket_Fixed<0x3811>
+{
+    Little16 magic_packet_id;
+    Little32 account_id;
+    Byte unknown;
+};
+static_assert(offsetof(NetPacket_Fixed<0x3811>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3811>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x3811>, account_id) == 2, "offsetof(NetPacket_Fixed<0x3811>, account_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x3811>, unknown) == 6, "offsetof(NetPacket_Fixed<0x3811>, unknown) == 6");
+static_assert(sizeof(NetPacket_Fixed<0x3811>) == 7, "sizeof(NetPacket_Fixed<0x3811>) == 7");
+
+template<>
+struct NetPacket_Fixed<0x3820>
+{
+    Little16 magic_packet_id;
+    Little32 account_id;
+    Byte error;
+    Little32 party_id;
+    NetString<sizeof(PartyName)> party_name;
+};
+static_assert(offsetof(NetPacket_Fixed<0x3820>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3820>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x3820>, account_id) == 2, "offsetof(NetPacket_Fixed<0x3820>, account_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x3820>, error) == 6, "offsetof(NetPacket_Fixed<0x3820>, error) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x3820>, party_id) == 7, "offsetof(NetPacket_Fixed<0x3820>, party_id) == 7");
+static_assert(offsetof(NetPacket_Fixed<0x3820>, party_name) == 11, "offsetof(NetPacket_Fixed<0x3820>, party_name) == 11");
+static_assert(sizeof(NetPacket_Fixed<0x3820>) == 35, "sizeof(NetPacket_Fixed<0x3820>) == 35");
+
+template<>
+struct NetPacket_Head<0x3821>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+    Little32 party_id;
+};
+static_assert(offsetof(NetPacket_Head<0x3821>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3821>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Head<0x3821>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3821>, magic_packet_length) == 2");
+static_assert(offsetof(NetPacket_Head<0x3821>, party_id) == 4, "offsetof(NetPacket_Head<0x3821>, party_id) == 4");
+static_assert(sizeof(NetPacket_Head<0x3821>) == 8, "sizeof(NetPacket_Head<0x3821>) == 8");
+template<>
+struct NetPacket_Option<0x3821>
+{
+    PartyMost party_most;
+};
+static_assert(offsetof(NetPacket_Option<0x3821>, party_most) == 0, "offsetof(NetPacket_Option<0x3821>, party_most) == 0");
+
+template<>
+struct NetPacket_Fixed<0x3822>
+{
+    Little16 magic_packet_id;
+    Little32 party_id;
+    Little32 account_id;
+    Byte flag;
+};
+static_assert(offsetof(NetPacket_Fixed<0x3822>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3822>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x3822>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3822>, party_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x3822>, account_id) == 6, "offsetof(NetPacket_Fixed<0x3822>, account_id) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x3822>, flag) == 10, "offsetof(NetPacket_Fixed<0x3822>, flag) == 10");
+static_assert(sizeof(NetPacket_Fixed<0x3822>) == 11, "sizeof(NetPacket_Fixed<0x3822>) == 11");
+
+template<>
+struct NetPacket_Fixed<0x3823>
+{
+    Little16 magic_packet_id;
+    Little32 party_id;
+    Little32 account_id;
+    Little16 exp;
+    Little16 item;
+    Byte flag;
+};
+static_assert(offsetof(NetPacket_Fixed<0x3823>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3823>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x3823>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3823>, party_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x3823>, account_id) == 6, "offsetof(NetPacket_Fixed<0x3823>, account_id) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x3823>, exp) == 10, "offsetof(NetPacket_Fixed<0x3823>, exp) == 10");
+static_assert(offsetof(NetPacket_Fixed<0x3823>, item) == 12, "offsetof(NetPacket_Fixed<0x3823>, item) == 12");
+static_assert(offsetof(NetPacket_Fixed<0x3823>, flag) == 14, "offsetof(NetPacket_Fixed<0x3823>, flag) == 14");
+static_assert(sizeof(NetPacket_Fixed<0x3823>) == 15, "sizeof(NetPacket_Fixed<0x3823>) == 15");
+
+template<>
+struct NetPacket_Fixed<0x3824>
+{
+    Little16 magic_packet_id;
+    Little32 party_id;
+    Little32 account_id;
+    NetString<sizeof(CharName)> char_name;
+};
+static_assert(offsetof(NetPacket_Fixed<0x3824>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3824>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x3824>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3824>, party_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x3824>, account_id) == 6, "offsetof(NetPacket_Fixed<0x3824>, account_id) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x3824>, char_name) == 10, "offsetof(NetPacket_Fixed<0x3824>, char_name) == 10");
+static_assert(sizeof(NetPacket_Fixed<0x3824>) == 34, "sizeof(NetPacket_Fixed<0x3824>) == 34");
+
+template<>
+struct NetPacket_Fixed<0x3825>
+{
+    Little16 magic_packet_id;
+    Little32 party_id;
+    Little32 account_id;
+    NetString<sizeof(MapName)> map_name;
+    Byte online;
+    Little16 level;
+};
+static_assert(offsetof(NetPacket_Fixed<0x3825>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3825>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x3825>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3825>, party_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x3825>, account_id) == 6, "offsetof(NetPacket_Fixed<0x3825>, account_id) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x3825>, map_name) == 10, "offsetof(NetPacket_Fixed<0x3825>, map_name) == 10");
+static_assert(offsetof(NetPacket_Fixed<0x3825>, online) == 26, "offsetof(NetPacket_Fixed<0x3825>, online) == 26");
+static_assert(offsetof(NetPacket_Fixed<0x3825>, level) == 27, "offsetof(NetPacket_Fixed<0x3825>, level) == 27");
+static_assert(sizeof(NetPacket_Fixed<0x3825>) == 29, "sizeof(NetPacket_Fixed<0x3825>) == 29");
+
+template<>
+struct NetPacket_Fixed<0x3826>
+{
+    Little16 magic_packet_id;
+    Little32 party_id;
+    Byte flag;
+};
+static_assert(offsetof(NetPacket_Fixed<0x3826>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3826>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x3826>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3826>, party_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x3826>, flag) == 6, "offsetof(NetPacket_Fixed<0x3826>, flag) == 6");
+static_assert(sizeof(NetPacket_Fixed<0x3826>) == 7, "sizeof(NetPacket_Fixed<0x3826>) == 7");
+
+template<>
+struct NetPacket_Head<0x3827>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+    Little32 party_id;
+    Little32 account_id;
+};
+static_assert(offsetof(NetPacket_Head<0x3827>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3827>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Head<0x3827>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3827>, magic_packet_length) == 2");
+static_assert(offsetof(NetPacket_Head<0x3827>, party_id) == 4, "offsetof(NetPacket_Head<0x3827>, party_id) == 4");
+static_assert(offsetof(NetPacket_Head<0x3827>, account_id) == 8, "offsetof(NetPacket_Head<0x3827>, account_id) == 8");
+static_assert(sizeof(NetPacket_Head<0x3827>) == 12, "sizeof(NetPacket_Head<0x3827>) == 12");
+template<>
+struct NetPacket_Repeat<0x3827>
+{
+    Byte c;
+};
+static_assert(offsetof(NetPacket_Repeat<0x3827>, c) == 0, "offsetof(NetPacket_Repeat<0x3827>, c) == 0");
+static_assert(sizeof(NetPacket_Repeat<0x3827>) == 1, "sizeof(NetPacket_Repeat<0x3827>) == 1");
+
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2af7> *network, Packet_Fixed<0x2af7> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2af7> *native, NetPacket_Fixed<0x2af7> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2af8> *network, Packet_Fixed<0x2af8> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_name, native.account_name);
+    rv &= native_to_network(&network->account_pass, native.account_pass);
+    rv &= native_to_network(&network->unused, native.unused);
+    rv &= native_to_network(&network->ip, native.ip);
+    rv &= native_to_network(&network->port, native.port);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2af8> *native, NetPacket_Fixed<0x2af8> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_name, network.account_name);
+    rv &= network_to_native(&native->account_pass, network.account_pass);
+    rv &= network_to_native(&native->unused, network.unused);
+    rv &= network_to_native(&native->ip, network.ip);
+    rv &= network_to_native(&native->port, network.port);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2af9> *network, Packet_Fixed<0x2af9> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->code, native.code);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2af9> *native, NetPacket_Fixed<0x2af9> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->code, network.code);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Head<0x2afa> *network, Packet_Head<0x2afa> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Head<0x2afa> *native, NetPacket_Head<0x2afa> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Repeat<0x2afa> *network, Packet_Repeat<0x2afa> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->map_name, native.map_name);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Repeat<0x2afa> *native, NetPacket_Repeat<0x2afa> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->map_name, network.map_name);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2afa> *network, Packet_Fixed<0x2afa> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->source_item_id, native.source_item_id);
+    rv &= native_to_network(&network->dest_item_id, native.dest_item_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2afa> *native, NetPacket_Fixed<0x2afa> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->source_item_id, network.source_item_id);
+    rv &= network_to_native(&native->dest_item_id, network.dest_item_id);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2afb> *network, Packet_Fixed<0x2afb> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->unknown, native.unknown);
+    rv &= native_to_network(&network->whisper_name, native.whisper_name);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2afb> *native, NetPacket_Fixed<0x2afb> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->unknown, network.unknown);
+    rv &= network_to_native(&native->whisper_name, network.whisper_name);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2afc> *network, Packet_Fixed<0x2afc> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->char_id, native.char_id);
+    rv &= native_to_network(&network->login_id1, native.login_id1);
+    rv &= native_to_network(&network->login_id2, native.login_id2);
+    rv &= native_to_network(&network->ip, native.ip);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2afc> *native, NetPacket_Fixed<0x2afc> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->char_id, network.char_id);
+    rv &= network_to_native(&native->login_id1, network.login_id1);
+    rv &= network_to_native(&native->login_id2, network.login_id2);
+    rv &= network_to_native(&native->ip, network.ip);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Payload<0x2afd> *network, Packet_Payload<0x2afd> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->login_id2, native.login_id2);
+    rv &= native_to_network(&network->connect_until, native.connect_until);
+    rv &= native_to_network(&network->packet_tmw_version, native.packet_tmw_version);
+    rv &= native_to_network(&network->char_key, native.char_key);
+    rv &= native_to_network(&network->char_data, native.char_data);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Payload<0x2afd> *native, NetPacket_Payload<0x2afd> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->login_id2, network.login_id2);
+    rv &= network_to_native(&native->connect_until, network.connect_until);
+    rv &= network_to_native(&native->packet_tmw_version, network.packet_tmw_version);
+    rv &= network_to_native(&native->char_key, network.char_key);
+    rv &= network_to_native(&native->char_data, network.char_data);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2afe> *network, Packet_Fixed<0x2afe> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2afe> *native, NetPacket_Fixed<0x2afe> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Head<0x2aff> *network, Packet_Head<0x2aff> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    rv &= native_to_network(&network->users, native.users);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Head<0x2aff> *native, NetPacket_Head<0x2aff> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    rv &= network_to_native(&native->users, network.users);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Repeat<0x2aff> *network, Packet_Repeat<0x2aff> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->char_id, native.char_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Repeat<0x2aff> *native, NetPacket_Repeat<0x2aff> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->char_id, network.char_id);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2b00> *network, Packet_Fixed<0x2b00> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->users, native.users);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2b00> *native, NetPacket_Fixed<0x2b00> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->users, network.users);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Payload<0x2b01> *network, Packet_Payload<0x2b01> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->char_id, native.char_id);
+    rv &= native_to_network(&network->char_key, native.char_key);
+    rv &= native_to_network(&network->char_data, native.char_data);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Payload<0x2b01> *native, NetPacket_Payload<0x2b01> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->char_id, network.char_id);
+    rv &= network_to_native(&native->char_key, network.char_key);
+    rv &= network_to_native(&native->char_data, network.char_data);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2b02> *network, Packet_Fixed<0x2b02> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->login_id1, native.login_id1);
+    rv &= native_to_network(&network->login_id2, native.login_id2);
+    rv &= native_to_network(&network->ip, native.ip);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2b02> *native, NetPacket_Fixed<0x2b02> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->login_id1, network.login_id1);
+    rv &= network_to_native(&native->login_id2, network.login_id2);
+    rv &= network_to_native(&native->ip, network.ip);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2b03> *network, Packet_Fixed<0x2b03> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->unknown, native.unknown);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2b03> *native, NetPacket_Fixed<0x2b03> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->unknown, network.unknown);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Head<0x2b04> *network, Packet_Head<0x2b04> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    rv &= native_to_network(&network->ip, native.ip);
+    rv &= native_to_network(&network->port, native.port);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Head<0x2b04> *native, NetPacket_Head<0x2b04> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    rv &= network_to_native(&native->ip, network.ip);
+    rv &= network_to_native(&native->port, network.port);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Repeat<0x2b04> *network, Packet_Repeat<0x2b04> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->map_name, native.map_name);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Repeat<0x2b04> *native, NetPacket_Repeat<0x2b04> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->map_name, network.map_name);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2b05> *network, Packet_Fixed<0x2b05> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->login_id1, native.login_id1);
+    rv &= native_to_network(&network->login_id2, native.login_id2);
+    rv &= native_to_network(&network->char_id, native.char_id);
+    rv &= native_to_network(&network->map_name, native.map_name);
+    rv &= native_to_network(&network->x, native.x);
+    rv &= native_to_network(&network->y, native.y);
+    rv &= native_to_network(&network->map_ip, native.map_ip);
+    rv &= native_to_network(&network->map_port, native.map_port);
+    rv &= native_to_network(&network->sex, native.sex);
+    rv &= native_to_network(&network->client_ip, native.client_ip);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2b05> *native, NetPacket_Fixed<0x2b05> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->login_id1, network.login_id1);
+    rv &= network_to_native(&native->login_id2, network.login_id2);
+    rv &= network_to_native(&native->char_id, network.char_id);
+    rv &= network_to_native(&native->map_name, network.map_name);
+    rv &= network_to_native(&native->x, network.x);
+    rv &= network_to_native(&native->y, network.y);
+    rv &= network_to_native(&native->map_ip, network.map_ip);
+    rv &= network_to_native(&native->map_port, network.map_port);
+    rv &= network_to_native(&native->sex, network.sex);
+    rv &= network_to_native(&native->client_ip, network.client_ip);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2b06> *network, Packet_Fixed<0x2b06> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->error, native.error);
+    rv &= native_to_network(&network->unknown, native.unknown);
+    rv &= native_to_network(&network->char_id, native.char_id);
+    rv &= native_to_network(&network->map_name, native.map_name);
+    rv &= native_to_network(&network->x, native.x);
+    rv &= native_to_network(&network->y, native.y);
+    rv &= native_to_network(&network->map_ip, native.map_ip);
+    rv &= native_to_network(&network->map_port, native.map_port);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2b06> *native, NetPacket_Fixed<0x2b06> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->error, network.error);
+    rv &= network_to_native(&native->unknown, network.unknown);
+    rv &= network_to_native(&native->char_id, network.char_id);
+    rv &= network_to_native(&native->map_name, network.map_name);
+    rv &= network_to_native(&native->x, network.x);
+    rv &= network_to_native(&native->y, network.y);
+    rv &= network_to_native(&native->map_ip, network.map_ip);
+    rv &= network_to_native(&native->map_port, network.map_port);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Head<0x2b0a> *network, Packet_Head<0x2b0a> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Head<0x2b0a> *native, NetPacket_Head<0x2b0a> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Repeat<0x2b0a> *network, Packet_Repeat<0x2b0a> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->c, native.c);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Repeat<0x2b0a> *native, NetPacket_Repeat<0x2b0a> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->c, network.c);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2b0b> *network, Packet_Fixed<0x2b0b> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->gm_level, native.gm_level);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2b0b> *native, NetPacket_Fixed<0x2b0b> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->gm_level, network.gm_level);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2b0c> *network, Packet_Fixed<0x2b0c> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->old_email, native.old_email);
+    rv &= native_to_network(&network->new_email, native.new_email);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2b0c> *native, NetPacket_Fixed<0x2b0c> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->old_email, network.old_email);
+    rv &= network_to_native(&native->new_email, network.new_email);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2b0d> *network, Packet_Fixed<0x2b0d> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->sex, native.sex);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2b0d> *native, NetPacket_Fixed<0x2b0d> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->sex, network.sex);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2b0e> *network, Packet_Fixed<0x2b0e> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->char_name, native.char_name);
+    rv &= native_to_network(&network->operation, native.operation);
+    rv &= native_to_network(&network->ban_add, native.ban_add);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2b0e> *native, NetPacket_Fixed<0x2b0e> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->char_name, network.char_name);
+    rv &= network_to_native(&native->operation, network.operation);
+    rv &= network_to_native(&native->ban_add, network.ban_add);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2b0f> *network, Packet_Fixed<0x2b0f> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->char_name, native.char_name);
+    rv &= native_to_network(&network->operation, native.operation);
+    rv &= native_to_network(&network->error, native.error);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2b0f> *native, NetPacket_Fixed<0x2b0f> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->char_name, network.char_name);
+    rv &= network_to_native(&native->operation, network.operation);
+    rv &= network_to_native(&native->error, network.error);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Head<0x2b10> *network, Packet_Head<0x2b10> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Head<0x2b10> *native, NetPacket_Head<0x2b10> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Repeat<0x2b10> *network, Packet_Repeat<0x2b10> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->name, native.name);
+    rv &= native_to_network(&network->value, native.value);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Repeat<0x2b10> *native, NetPacket_Repeat<0x2b10> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->name, network.name);
+    rv &= network_to_native(&native->value, network.value);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Head<0x2b11> *network, Packet_Head<0x2b11> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Head<0x2b11> *native, NetPacket_Head<0x2b11> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Repeat<0x2b11> *network, Packet_Repeat<0x2b11> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->name, native.name);
+    rv &= native_to_network(&network->value, native.value);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Repeat<0x2b11> *native, NetPacket_Repeat<0x2b11> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->name, network.name);
+    rv &= network_to_native(&native->value, network.value);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2b12> *network, Packet_Fixed<0x2b12> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->char_id, native.char_id);
+    rv &= native_to_network(&network->partner_id, native.partner_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2b12> *native, NetPacket_Fixed<0x2b12> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->char_id, network.char_id);
+    rv &= network_to_native(&native->partner_id, network.partner_id);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2b13> *network, Packet_Fixed<0x2b13> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2b13> *native, NetPacket_Fixed<0x2b13> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2b14> *network, Packet_Fixed<0x2b14> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->ban_not_status, native.ban_not_status);
+    rv &= native_to_network(&network->status_or_ban_until, native.status_or_ban_until);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2b14> *native, NetPacket_Fixed<0x2b14> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->ban_not_status, network.ban_not_status);
+    rv &= network_to_native(&native->status_or_ban_until, network.status_or_ban_until);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Head<0x2b15> *network, Packet_Head<0x2b15> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Head<0x2b15> *native, NetPacket_Head<0x2b15> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Repeat<0x2b15> *network, Packet_Repeat<0x2b15> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->gm_level, native.gm_level);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Repeat<0x2b15> *native, NetPacket_Repeat<0x2b15> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->gm_level, network.gm_level);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x2b16> *network, Packet_Fixed<0x2b16> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->char_id, native.char_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x2b16> *native, NetPacket_Fixed<0x2b16> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->char_id, network.char_id);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Head<0x3000> *network, Packet_Head<0x3000> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Head<0x3000> *native, NetPacket_Head<0x3000> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Repeat<0x3000> *network, Packet_Repeat<0x3000> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->c, native.c);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Repeat<0x3000> *native, NetPacket_Repeat<0x3000> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->c, network.c);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Head<0x3001> *network, Packet_Head<0x3001> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    rv &= native_to_network(&network->from_char_name, native.from_char_name);
+    rv &= native_to_network(&network->to_char_name, native.to_char_name);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Head<0x3001> *native, NetPacket_Head<0x3001> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    rv &= network_to_native(&native->from_char_name, network.from_char_name);
+    rv &= network_to_native(&native->to_char_name, network.to_char_name);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Repeat<0x3001> *network, Packet_Repeat<0x3001> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->c, native.c);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Repeat<0x3001> *native, NetPacket_Repeat<0x3001> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->c, network.c);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x3002> *network, Packet_Fixed<0x3002> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->char_id, native.char_id);
+    rv &= native_to_network(&network->flag, native.flag);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x3002> *native, NetPacket_Fixed<0x3002> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->char_id, network.char_id);
+    rv &= network_to_native(&native->flag, network.flag);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Head<0x3003> *network, Packet_Head<0x3003> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    rv &= native_to_network(&network->char_name, native.char_name);
+    rv &= native_to_network(&network->min_gm_level, native.min_gm_level);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Head<0x3003> *native, NetPacket_Head<0x3003> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    rv &= network_to_native(&native->char_name, network.char_name);
+    rv &= network_to_native(&native->min_gm_level, network.min_gm_level);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Repeat<0x3003> *network, Packet_Repeat<0x3003> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->c, native.c);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Repeat<0x3003> *native, NetPacket_Repeat<0x3003> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->c, network.c);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Head<0x3004> *network, Packet_Head<0x3004> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Head<0x3004> *native, NetPacket_Head<0x3004> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Repeat<0x3004> *network, Packet_Repeat<0x3004> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->name, native.name);
+    rv &= native_to_network(&network->value, native.value);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Repeat<0x3004> *native, NetPacket_Repeat<0x3004> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->name, network.name);
+    rv &= network_to_native(&native->value, network.value);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x3005> *network, Packet_Fixed<0x3005> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x3005> *native, NetPacket_Fixed<0x3005> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x3010> *network, Packet_Fixed<0x3010> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x3010> *native, NetPacket_Fixed<0x3010> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Payload<0x3011> *network, Packet_Payload<0x3011> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->storage, native.storage);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Payload<0x3011> *native, NetPacket_Payload<0x3011> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->storage, network.storage);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x3020> *network, Packet_Fixed<0x3020> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->party_name, native.party_name);
+    rv &= native_to_network(&network->char_name, native.char_name);
+    rv &= native_to_network(&network->map_name, native.map_name);
+    rv &= native_to_network(&network->level, native.level);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x3020> *native, NetPacket_Fixed<0x3020> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->party_name, network.party_name);
+    rv &= network_to_native(&native->char_name, network.char_name);
+    rv &= network_to_native(&native->map_name, network.map_name);
+    rv &= network_to_native(&native->level, network.level);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x3021> *network, Packet_Fixed<0x3021> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->party_id, native.party_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x3021> *native, NetPacket_Fixed<0x3021> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->party_id, network.party_id);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x3022> *network, Packet_Fixed<0x3022> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->party_id, native.party_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->char_name, native.char_name);
+    rv &= native_to_network(&network->map_name, native.map_name);
+    rv &= native_to_network(&network->level, native.level);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x3022> *native, NetPacket_Fixed<0x3022> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->party_id, network.party_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->char_name, network.char_name);
+    rv &= network_to_native(&native->map_name, network.map_name);
+    rv &= network_to_native(&native->level, network.level);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x3023> *network, Packet_Fixed<0x3023> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->party_id, native.party_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->exp, native.exp);
+    rv &= native_to_network(&network->item, native.item);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x3023> *native, NetPacket_Fixed<0x3023> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->party_id, network.party_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->exp, network.exp);
+    rv &= network_to_native(&native->item, network.item);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x3024> *network, Packet_Fixed<0x3024> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->party_id, native.party_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x3024> *native, NetPacket_Fixed<0x3024> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->party_id, network.party_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x3025> *network, Packet_Fixed<0x3025> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->party_id, native.party_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->map_name, native.map_name);
+    rv &= native_to_network(&network->online, native.online);
+    rv &= native_to_network(&network->level, native.level);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x3025> *native, NetPacket_Fixed<0x3025> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->party_id, network.party_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->map_name, network.map_name);
+    rv &= network_to_native(&native->online, network.online);
+    rv &= network_to_native(&native->level, network.level);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x3026> *network, Packet_Fixed<0x3026> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->party_id, native.party_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x3026> *native, NetPacket_Fixed<0x3026> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->party_id, network.party_id);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Head<0x3027> *network, Packet_Head<0x3027> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    rv &= native_to_network(&network->party_id, native.party_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Head<0x3027> *native, NetPacket_Head<0x3027> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    rv &= network_to_native(&native->party_id, network.party_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Repeat<0x3027> *network, Packet_Repeat<0x3027> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->c, native.c);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Repeat<0x3027> *native, NetPacket_Repeat<0x3027> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->c, network.c);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x3028> *network, Packet_Fixed<0x3028> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->party_id, native.party_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->char_name, native.char_name);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x3028> *native, NetPacket_Fixed<0x3028> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->party_id, network.party_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->char_name, network.char_name);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Head<0x3800> *network, Packet_Head<0x3800> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Head<0x3800> *native, NetPacket_Head<0x3800> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Repeat<0x3800> *network, Packet_Repeat<0x3800> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->c, native.c);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Repeat<0x3800> *native, NetPacket_Repeat<0x3800> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->c, network.c);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Head<0x3801> *network, Packet_Head<0x3801> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    rv &= native_to_network(&network->whisper_id, native.whisper_id);
+    rv &= native_to_network(&network->src_char_name, native.src_char_name);
+    rv &= native_to_network(&network->dst_char_name, native.dst_char_name);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Head<0x3801> *native, NetPacket_Head<0x3801> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    rv &= network_to_native(&native->whisper_id, network.whisper_id);
+    rv &= network_to_native(&native->src_char_name, network.src_char_name);
+    rv &= network_to_native(&native->dst_char_name, network.dst_char_name);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Repeat<0x3801> *network, Packet_Repeat<0x3801> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->c, native.c);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Repeat<0x3801> *native, NetPacket_Repeat<0x3801> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->c, network.c);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x3802> *network, Packet_Fixed<0x3802> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->sender_char_name, native.sender_char_name);
+    rv &= native_to_network(&network->flag, native.flag);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x3802> *native, NetPacket_Fixed<0x3802> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->sender_char_name, network.sender_char_name);
+    rv &= network_to_native(&native->flag, network.flag);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Head<0x3803> *network, Packet_Head<0x3803> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    rv &= native_to_network(&network->char_name, native.char_name);
+    rv &= native_to_network(&network->min_gm_level, native.min_gm_level);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Head<0x3803> *native, NetPacket_Head<0x3803> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    rv &= network_to_native(&native->char_name, network.char_name);
+    rv &= network_to_native(&native->min_gm_level, network.min_gm_level);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Repeat<0x3803> *network, Packet_Repeat<0x3803> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->c, native.c);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Repeat<0x3803> *native, NetPacket_Repeat<0x3803> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->c, network.c);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Head<0x3804> *network, Packet_Head<0x3804> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Head<0x3804> *native, NetPacket_Head<0x3804> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Repeat<0x3804> *network, Packet_Repeat<0x3804> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->name, native.name);
+    rv &= native_to_network(&network->value, native.value);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Repeat<0x3804> *native, NetPacket_Repeat<0x3804> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->name, network.name);
+    rv &= network_to_native(&native->value, network.value);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Payload<0x3810> *network, Packet_Payload<0x3810> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->storage, native.storage);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Payload<0x3810> *native, NetPacket_Payload<0x3810> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->storage, network.storage);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x3811> *network, Packet_Fixed<0x3811> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->unknown, native.unknown);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x3811> *native, NetPacket_Fixed<0x3811> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->unknown, network.unknown);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x3820> *network, Packet_Fixed<0x3820> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->error, native.error);
+    rv &= native_to_network(&network->party_id, native.party_id);
+    rv &= native_to_network(&network->party_name, native.party_name);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x3820> *native, NetPacket_Fixed<0x3820> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->error, network.error);
+    rv &= network_to_native(&native->party_id, network.party_id);
+    rv &= network_to_native(&native->party_name, network.party_name);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Head<0x3821> *network, Packet_Head<0x3821> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    rv &= native_to_network(&network->party_id, native.party_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Head<0x3821> *native, NetPacket_Head<0x3821> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    rv &= network_to_native(&native->party_id, network.party_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Option<0x3821> *network, Packet_Option<0x3821> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->party_most, native.party_most);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Option<0x3821> *native, NetPacket_Option<0x3821> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->party_most, network.party_most);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x3822> *network, Packet_Fixed<0x3822> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->party_id, native.party_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->flag, native.flag);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x3822> *native, NetPacket_Fixed<0x3822> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->party_id, network.party_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->flag, network.flag);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x3823> *network, Packet_Fixed<0x3823> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->party_id, native.party_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->exp, native.exp);
+    rv &= native_to_network(&network->item, native.item);
+    rv &= native_to_network(&network->flag, native.flag);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x3823> *native, NetPacket_Fixed<0x3823> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->party_id, network.party_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->exp, network.exp);
+    rv &= network_to_native(&native->item, network.item);
+    rv &= network_to_native(&native->flag, network.flag);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x3824> *network, Packet_Fixed<0x3824> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->party_id, native.party_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->char_name, native.char_name);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x3824> *native, NetPacket_Fixed<0x3824> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->party_id, network.party_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->char_name, network.char_name);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x3825> *network, Packet_Fixed<0x3825> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->party_id, native.party_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->map_name, native.map_name);
+    rv &= native_to_network(&network->online, native.online);
+    rv &= native_to_network(&network->level, native.level);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x3825> *native, NetPacket_Fixed<0x3825> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->party_id, network.party_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->map_name, network.map_name);
+    rv &= network_to_native(&native->online, network.online);
+    rv &= network_to_native(&native->level, network.level);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x3826> *network, Packet_Fixed<0x3826> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->party_id, native.party_id);
+    rv &= native_to_network(&network->flag, native.flag);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x3826> *native, NetPacket_Fixed<0x3826> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->party_id, network.party_id);
+    rv &= network_to_native(&native->flag, network.flag);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Head<0x3827> *network, Packet_Head<0x3827> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    rv &= native_to_network(&network->party_id, native.party_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Head<0x3827> *native, NetPacket_Head<0x3827> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    rv &= network_to_native(&native->party_id, network.party_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Repeat<0x3827> *network, Packet_Repeat<0x3827> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->c, native.c);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Repeat<0x3827> *native, NetPacket_Repeat<0x3827> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->c, network.c);
+    return rv;
+}
+
+
+#pragma pack(pop)
 
 #endif // TMWA_PROTO2_CHAR_MAP_HPP
diff --git a/src/proto2/char-user.hpp b/src/proto2/char-user.hpp
index b31d9f1..3a51a2a 100644
--- a/src/proto2/char-user.hpp
+++ b/src/proto2/char-user.hpp
@@ -27,7 +27,587 @@
 
 // This is a public protocol, and changes require client cooperation
 
+// this is only needed for the payload packet right now, and that needs to die
+#pragma pack(push, 1)
 
+template<>
+struct Packet_Fixed<0x0061>
+{
+    static const uint16_t PACKET_ID = 0x0061;
 
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountPass old_pass = {};
+    AccountPass new_pass = {};
+};
+
+template<>
+struct Packet_Fixed<0x0062>
+{
+    static const uint16_t PACKET_ID = 0x0062;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    uint8_t status = {};
+};
+
+template<>
+struct Packet_Fixed<0x0065>
+{
+    static const uint16_t PACKET_ID = 0x0065;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    AccountId account_id = {};
+    uint32_t login_id1 = {};
+    uint32_t login_id2 = {};
+    uint16_t packet_tmw_version = {};
+    SEX sex = {};
+};
+
+template<>
+struct Packet_Fixed<0x0066>
+{
+    static const uint16_t PACKET_ID = 0x0066;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    uint8_t code = {};
+};
+
+template<>
+struct Packet_Fixed<0x0067>
+{
+    static const uint16_t PACKET_ID = 0x0067;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    CharName char_name = {};
+    Stats6 stats = {};
+    uint8_t slot = {};
+    uint16_t hair_color = {};
+    uint16_t hair_style = {};
+};
+
+template<>
+struct Packet_Fixed<0x0068>
+{
+    static const uint16_t PACKET_ID = 0x0068;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    CharId char_id = {};
+    AccountEmail email = {};
+};
+
+template<>
+struct Packet_Head<0x006b>
+{
+    static const uint16_t PACKET_ID = 0x006b;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    // TODO remove this
+    uint16_t magic_packet_length = {};
+    VString<19> unused = {};
+};
+template<>
+struct Packet_Repeat<0x006b>
+{
+    static const uint16_t PACKET_ID = 0x006b;
+
+    CharSelect char_select = {};
+};
+
+template<>
+struct Packet_Fixed<0x006c>
+{
+    static const uint16_t PACKET_ID = 0x006c;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    uint8_t code = {};
+};
+
+template<>
+struct Packet_Fixed<0x006d>
+{
+    static const uint16_t PACKET_ID = 0x006d;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    CharSelect char_select = {};
+};
+
+template<>
+struct Packet_Fixed<0x006e>
+{
+    static const uint16_t PACKET_ID = 0x006e;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    uint8_t code = {};
+};
+
+template<>
+struct Packet_Fixed<0x006f>
+{
+    static const uint16_t PACKET_ID = 0x006f;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+};
+
+template<>
+struct Packet_Fixed<0x0070>
+{
+    static const uint16_t PACKET_ID = 0x0070;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    uint8_t code = {};
+};
+
+template<>
+struct Packet_Fixed<0x0071>
+{
+    static const uint16_t PACKET_ID = 0x0071;
+
+    // TODO remove this
+    uint16_t magic_packet_id = PACKET_ID;
+    CharId char_id = {};
+    MapName map_name = {};
+    IP4Address ip = {};
+    uint16_t port = {};
+};
+
+
+template<>
+struct NetPacket_Fixed<0x0061>
+{
+    Little16 magic_packet_id;
+    NetString<sizeof(AccountPass)> old_pass;
+    NetString<sizeof(AccountPass)> new_pass;
+};
+static_assert(offsetof(NetPacket_Fixed<0x0061>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0061>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x0061>, old_pass) == 2, "offsetof(NetPacket_Fixed<0x0061>, old_pass) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x0061>, new_pass) == 26, "offsetof(NetPacket_Fixed<0x0061>, new_pass) == 26");
+static_assert(sizeof(NetPacket_Fixed<0x0061>) == 50, "sizeof(NetPacket_Fixed<0x0061>) == 50");
+
+template<>
+struct NetPacket_Fixed<0x0062>
+{
+    Little16 magic_packet_id;
+    Byte status;
+};
+static_assert(offsetof(NetPacket_Fixed<0x0062>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0062>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x0062>, status) == 2, "offsetof(NetPacket_Fixed<0x0062>, status) == 2");
+static_assert(sizeof(NetPacket_Fixed<0x0062>) == 3, "sizeof(NetPacket_Fixed<0x0062>) == 3");
+
+template<>
+struct NetPacket_Fixed<0x0065>
+{
+    Little16 magic_packet_id;
+    Little32 account_id;
+    Little32 login_id1;
+    Little32 login_id2;
+    Little16 packet_tmw_version;
+    Byte sex;
+};
+static_assert(offsetof(NetPacket_Fixed<0x0065>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0065>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x0065>, account_id) == 2, "offsetof(NetPacket_Fixed<0x0065>, account_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x0065>, login_id1) == 6, "offsetof(NetPacket_Fixed<0x0065>, login_id1) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x0065>, login_id2) == 10, "offsetof(NetPacket_Fixed<0x0065>, login_id2) == 10");
+static_assert(offsetof(NetPacket_Fixed<0x0065>, packet_tmw_version) == 14, "offsetof(NetPacket_Fixed<0x0065>, packet_tmw_version) == 14");
+static_assert(offsetof(NetPacket_Fixed<0x0065>, sex) == 16, "offsetof(NetPacket_Fixed<0x0065>, sex) == 16");
+static_assert(sizeof(NetPacket_Fixed<0x0065>) == 17, "sizeof(NetPacket_Fixed<0x0065>) == 17");
+
+template<>
+struct NetPacket_Fixed<0x0066>
+{
+    Little16 magic_packet_id;
+    Byte code;
+};
+static_assert(offsetof(NetPacket_Fixed<0x0066>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0066>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x0066>, code) == 2, "offsetof(NetPacket_Fixed<0x0066>, code) == 2");
+static_assert(sizeof(NetPacket_Fixed<0x0066>) == 3, "sizeof(NetPacket_Fixed<0x0066>) == 3");
+
+template<>
+struct NetPacket_Fixed<0x0067>
+{
+    Little16 magic_packet_id;
+    NetString<sizeof(CharName)> char_name;
+    NetStats6 stats;
+    Byte slot;
+    Little16 hair_color;
+    Little16 hair_style;
+};
+static_assert(offsetof(NetPacket_Fixed<0x0067>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0067>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x0067>, char_name) == 2, "offsetof(NetPacket_Fixed<0x0067>, char_name) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x0067>, stats) == 26, "offsetof(NetPacket_Fixed<0x0067>, stats) == 26");
+static_assert(offsetof(NetPacket_Fixed<0x0067>, slot) == 32, "offsetof(NetPacket_Fixed<0x0067>, slot) == 32");
+static_assert(offsetof(NetPacket_Fixed<0x0067>, hair_color) == 33, "offsetof(NetPacket_Fixed<0x0067>, hair_color) == 33");
+static_assert(offsetof(NetPacket_Fixed<0x0067>, hair_style) == 35, "offsetof(NetPacket_Fixed<0x0067>, hair_style) == 35");
+static_assert(sizeof(NetPacket_Fixed<0x0067>) == 37, "sizeof(NetPacket_Fixed<0x0067>) == 37");
+
+template<>
+struct NetPacket_Fixed<0x0068>
+{
+    Little16 magic_packet_id;
+    Little32 char_id;
+    NetString<sizeof(AccountEmail)> email;
+};
+static_assert(offsetof(NetPacket_Fixed<0x0068>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0068>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x0068>, char_id) == 2, "offsetof(NetPacket_Fixed<0x0068>, char_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x0068>, email) == 6, "offsetof(NetPacket_Fixed<0x0068>, email) == 6");
+static_assert(sizeof(NetPacket_Fixed<0x0068>) == 46, "sizeof(NetPacket_Fixed<0x0068>) == 46");
+
+template<>
+struct NetPacket_Head<0x006b>
+{
+    Little16 magic_packet_id;
+    Little16 magic_packet_length;
+    NetString<sizeof(VString<19>)> unused;
+};
+static_assert(offsetof(NetPacket_Head<0x006b>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x006b>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Head<0x006b>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x006b>, magic_packet_length) == 2");
+static_assert(offsetof(NetPacket_Head<0x006b>, unused) == 4, "offsetof(NetPacket_Head<0x006b>, unused) == 4");
+static_assert(sizeof(NetPacket_Head<0x006b>) == 24, "sizeof(NetPacket_Head<0x006b>) == 24");
+template<>
+struct NetPacket_Repeat<0x006b>
+{
+    NetCharSelect char_select;
+};
+static_assert(offsetof(NetPacket_Repeat<0x006b>, char_select) == 0, "offsetof(NetPacket_Repeat<0x006b>, char_select) == 0");
+static_assert(sizeof(NetPacket_Repeat<0x006b>) == 106, "sizeof(NetPacket_Repeat<0x006b>) == 106");
+
+template<>
+struct NetPacket_Fixed<0x006c>
+{
+    Little16 magic_packet_id;
+    Byte code;
+};
+static_assert(offsetof(NetPacket_Fixed<0x006c>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x006c>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x006c>, code) == 2, "offsetof(NetPacket_Fixed<0x006c>, code) == 2");
+static_assert(sizeof(NetPacket_Fixed<0x006c>) == 3, "sizeof(NetPacket_Fixed<0x006c>) == 3");
+
+template<>
+struct NetPacket_Fixed<0x006d>
+{
+    Little16 magic_packet_id;
+    NetCharSelect char_select;
+};
+static_assert(offsetof(NetPacket_Fixed<0x006d>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x006d>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x006d>, char_select) == 2, "offsetof(NetPacket_Fixed<0x006d>, char_select) == 2");
+static_assert(sizeof(NetPacket_Fixed<0x006d>) == 108, "sizeof(NetPacket_Fixed<0x006d>) == 108");
+
+template<>
+struct NetPacket_Fixed<0x006e>
+{
+    Little16 magic_packet_id;
+    Byte code;
+};
+static_assert(offsetof(NetPacket_Fixed<0x006e>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x006e>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x006e>, code) == 2, "offsetof(NetPacket_Fixed<0x006e>, code) == 2");
+static_assert(sizeof(NetPacket_Fixed<0x006e>) == 3, "sizeof(NetPacket_Fixed<0x006e>) == 3");
+
+template<>
+struct NetPacket_Fixed<0x006f>
+{
+    Little16 magic_packet_id;
+};
+static_assert(offsetof(NetPacket_Fixed<0x006f>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x006f>, magic_packet_id) == 0");
+static_assert(sizeof(NetPacket_Fixed<0x006f>) == 2, "sizeof(NetPacket_Fixed<0x006f>) == 2");
+
+template<>
+struct NetPacket_Fixed<0x0070>
+{
+    Little16 magic_packet_id;
+    Byte code;
+};
+static_assert(offsetof(NetPacket_Fixed<0x0070>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0070>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x0070>, code) == 2, "offsetof(NetPacket_Fixed<0x0070>, code) == 2");
+static_assert(sizeof(NetPacket_Fixed<0x0070>) == 3, "sizeof(NetPacket_Fixed<0x0070>) == 3");
+
+template<>
+struct NetPacket_Fixed<0x0071>
+{
+    Little16 magic_packet_id;
+    Little32 char_id;
+    NetString<sizeof(MapName)> map_name;
+    IP4Address ip;
+    Little16 port;
+};
+static_assert(offsetof(NetPacket_Fixed<0x0071>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0071>, magic_packet_id) == 0");
+static_assert(offsetof(NetPacket_Fixed<0x0071>, char_id) == 2, "offsetof(NetPacket_Fixed<0x0071>, char_id) == 2");
+static_assert(offsetof(NetPacket_Fixed<0x0071>, map_name) == 6, "offsetof(NetPacket_Fixed<0x0071>, map_name) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x0071>, ip) == 22, "offsetof(NetPacket_Fixed<0x0071>, ip) == 22");
+static_assert(offsetof(NetPacket_Fixed<0x0071>, port) == 26, "offsetof(NetPacket_Fixed<0x0071>, port) == 26");
+static_assert(sizeof(NetPacket_Fixed<0x0071>) == 28, "sizeof(NetPacket_Fixed<0x0071>) == 28");
+
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x0061> *network, Packet_Fixed<0x0061> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->old_pass, native.old_pass);
+    rv &= native_to_network(&network->new_pass, native.new_pass);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x0061> *native, NetPacket_Fixed<0x0061> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->old_pass, network.old_pass);
+    rv &= network_to_native(&native->new_pass, network.new_pass);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x0062> *network, Packet_Fixed<0x0062> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->status, native.status);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x0062> *native, NetPacket_Fixed<0x0062> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->status, network.status);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x0065> *network, Packet_Fixed<0x0065> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->account_id, native.account_id);
+    rv &= native_to_network(&network->login_id1, native.login_id1);
+    rv &= native_to_network(&network->login_id2, native.login_id2);
+    rv &= native_to_network(&network->packet_tmw_version, native.packet_tmw_version);
+    rv &= native_to_network(&network->sex, native.sex);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x0065> *native, NetPacket_Fixed<0x0065> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->account_id, network.account_id);
+    rv &= network_to_native(&native->login_id1, network.login_id1);
+    rv &= network_to_native(&native->login_id2, network.login_id2);
+    rv &= network_to_native(&native->packet_tmw_version, network.packet_tmw_version);
+    rv &= network_to_native(&native->sex, network.sex);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x0066> *network, Packet_Fixed<0x0066> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->code, native.code);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x0066> *native, NetPacket_Fixed<0x0066> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->code, network.code);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x0067> *network, Packet_Fixed<0x0067> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->char_name, native.char_name);
+    rv &= native_to_network(&network->stats, native.stats);
+    rv &= native_to_network(&network->slot, native.slot);
+    rv &= native_to_network(&network->hair_color, native.hair_color);
+    rv &= native_to_network(&network->hair_style, native.hair_style);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x0067> *native, NetPacket_Fixed<0x0067> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->char_name, network.char_name);
+    rv &= network_to_native(&native->stats, network.stats);
+    rv &= network_to_native(&native->slot, network.slot);
+    rv &= network_to_native(&native->hair_color, network.hair_color);
+    rv &= network_to_native(&native->hair_style, network.hair_style);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x0068> *network, Packet_Fixed<0x0068> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->char_id, native.char_id);
+    rv &= native_to_network(&network->email, native.email);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x0068> *native, NetPacket_Fixed<0x0068> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->char_id, network.char_id);
+    rv &= network_to_native(&native->email, network.email);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Head<0x006b> *network, Packet_Head<0x006b> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length);
+    rv &= native_to_network(&network->unused, native.unused);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Head<0x006b> *native, NetPacket_Head<0x006b> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length);
+    rv &= network_to_native(&native->unused, network.unused);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Repeat<0x006b> *network, Packet_Repeat<0x006b> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->char_select, native.char_select);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Repeat<0x006b> *native, NetPacket_Repeat<0x006b> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->char_select, network.char_select);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x006c> *network, Packet_Fixed<0x006c> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->code, native.code);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x006c> *native, NetPacket_Fixed<0x006c> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->code, network.code);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x006d> *network, Packet_Fixed<0x006d> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->char_select, native.char_select);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x006d> *native, NetPacket_Fixed<0x006d> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->char_select, network.char_select);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x006e> *network, Packet_Fixed<0x006e> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->code, native.code);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x006e> *native, NetPacket_Fixed<0x006e> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->code, network.code);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x006f> *network, Packet_Fixed<0x006f> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x006f> *native, NetPacket_Fixed<0x006f> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x0070> *network, Packet_Fixed<0x0070> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->code, native.code);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x0070> *native, NetPacket_Fixed<0x0070> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->code, network.code);
+    return rv;
+}
+
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetPacket_Fixed<0x0071> *network, Packet_Fixed<0x0071> native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
+    rv &= native_to_network(&network->char_id, native.char_id);
+    rv &= native_to_network(&network->map_name, native.map_name);
+    rv &= native_to_network(&network->ip, native.ip);
+    rv &= native_to_network(&network->port, native.port);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Packet_Fixed<0x0071> *native, NetPacket_Fixed<0x0071> network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
+    rv &= network_to_native(&native->char_id, network.char_id);
+    rv &= network_to_native(&native->map_name, network.map_name);
+    rv &= network_to_native(&native->ip, network.ip);
+    rv &= network_to_native(&native->port, network.port);
+    return rv;
+}
+
+
+#pragma pack(pop)
 
 #endif // TMWA_PROTO2_CHAR_USER_HPP
diff --git a/src/proto2/fwd.hpp b/src/proto2/fwd.hpp
index f050ab4..169f5e2 100644
--- a/src/proto2/fwd.hpp
+++ b/src/proto2/fwd.hpp
@@ -25,10 +25,14 @@
 
 template<uint16_t PACKET_ID> class Packet_Fixed;
 template<uint16_t PACKET_ID> class NetPacket_Fixed;
+template<uint16_t PACKET_ID> class Packet_Payload;
+template<uint16_t PACKET_ID> class NetPacket_Payload;
 template<uint16_t PACKET_ID> class Packet_Head;
 template<uint16_t PACKET_ID> class NetPacket_Head;
 template<uint16_t PACKET_ID> class Packet_Repeat;
 template<uint16_t PACKET_ID> class NetPacket_Repeat;
+template<uint16_t PACKET_ID> class Packet_Option;
+template<uint16_t PACKET_ID> class NetPacket_Option;
 
 template<>
 struct Packet_Fixed<0x2709>;
@@ -445,12 +449,458 @@ struct Packet_Fixed<0x006a>;
 template<>
 struct NetPacket_Fixed<0x006a>;
 
+
 template<>
-struct Packet_Fixed<0x0081>;
+struct Packet_Fixed<0x2af7>;
 template<>
-struct NetPacket_Fixed<0x0081>;
+struct NetPacket_Fixed<0x2af7>;
+
+template<>
+struct Packet_Fixed<0x2af8>;
+template<>
+struct NetPacket_Fixed<0x2af8>;
+
+template<>
+struct Packet_Fixed<0x2af9>;
+template<>
+struct NetPacket_Fixed<0x2af9>;
+
+template<>
+struct Packet_Head<0x2afa>;
+template<>
+struct NetPacket_Head<0x2afa>;
+template<>
+struct Packet_Repeat<0x2afa>;
+template<>
+struct NetPacket_Repeat<0x2afa>;
+
+template<>
+struct Packet_Fixed<0x2afa>;
+template<>
+struct NetPacket_Fixed<0x2afa>;
+
+template<>
+struct Packet_Fixed<0x2afb>;
+template<>
+struct NetPacket_Fixed<0x2afb>;
+
+template<>
+struct Packet_Fixed<0x2afc>;
+template<>
+struct NetPacket_Fixed<0x2afc>;
+
+template<>
+struct Packet_Payload<0x2afd>;
+template<>
+struct NetPacket_Payload<0x2afd>;
+
+template<>
+struct Packet_Fixed<0x2afe>;
+template<>
+struct NetPacket_Fixed<0x2afe>;
+
+template<>
+struct Packet_Head<0x2aff>;
+template<>
+struct NetPacket_Head<0x2aff>;
+template<>
+struct Packet_Repeat<0x2aff>;
+template<>
+struct NetPacket_Repeat<0x2aff>;
+
+template<>
+struct Packet_Fixed<0x2b00>;
+template<>
+struct NetPacket_Fixed<0x2b00>;
+
+template<>
+struct Packet_Payload<0x2b01>;
+template<>
+struct NetPacket_Payload<0x2b01>;
+
+template<>
+struct Packet_Fixed<0x2b02>;
+template<>
+struct NetPacket_Fixed<0x2b02>;
+
+template<>
+struct Packet_Fixed<0x2b03>;
+template<>
+struct NetPacket_Fixed<0x2b03>;
+
+template<>
+struct Packet_Head<0x2b04>;
+template<>
+struct NetPacket_Head<0x2b04>;
+template<>
+struct Packet_Repeat<0x2b04>;
+template<>
+struct NetPacket_Repeat<0x2b04>;
+
+template<>
+struct Packet_Fixed<0x2b05>;
+template<>
+struct NetPacket_Fixed<0x2b05>;
+
+template<>
+struct Packet_Fixed<0x2b06>;
+template<>
+struct NetPacket_Fixed<0x2b06>;
+
+template<>
+struct Packet_Head<0x2b0a>;
+template<>
+struct NetPacket_Head<0x2b0a>;
+template<>
+struct Packet_Repeat<0x2b0a>;
+template<>
+struct NetPacket_Repeat<0x2b0a>;
+
+template<>
+struct Packet_Fixed<0x2b0b>;
+template<>
+struct NetPacket_Fixed<0x2b0b>;
+
+template<>
+struct Packet_Fixed<0x2b0c>;
+template<>
+struct NetPacket_Fixed<0x2b0c>;
+
+template<>
+struct Packet_Fixed<0x2b0d>;
+template<>
+struct NetPacket_Fixed<0x2b0d>;
+
+template<>
+struct Packet_Fixed<0x2b0e>;
+template<>
+struct NetPacket_Fixed<0x2b0e>;
+
+template<>
+struct Packet_Fixed<0x2b0f>;
+template<>
+struct NetPacket_Fixed<0x2b0f>;
+
+template<>
+struct Packet_Head<0x2b10>;
+template<>
+struct NetPacket_Head<0x2b10>;
+template<>
+struct Packet_Repeat<0x2b10>;
+template<>
+struct NetPacket_Repeat<0x2b10>;
+
+template<>
+struct Packet_Head<0x2b11>;
+template<>
+struct NetPacket_Head<0x2b11>;
+template<>
+struct Packet_Repeat<0x2b11>;
+template<>
+struct NetPacket_Repeat<0x2b11>;
 
+template<>
+struct Packet_Fixed<0x2b12>;
+template<>
+struct NetPacket_Fixed<0x2b12>;
 
+template<>
+struct Packet_Fixed<0x2b13>;
+template<>
+struct NetPacket_Fixed<0x2b13>;
+
+template<>
+struct Packet_Fixed<0x2b14>;
+template<>
+struct NetPacket_Fixed<0x2b14>;
+
+template<>
+struct Packet_Head<0x2b15>;
+template<>
+struct NetPacket_Head<0x2b15>;
+template<>
+struct Packet_Repeat<0x2b15>;
+template<>
+struct NetPacket_Repeat<0x2b15>;
+
+template<>
+struct Packet_Fixed<0x2b16>;
+template<>
+struct NetPacket_Fixed<0x2b16>;
+
+template<>
+struct Packet_Head<0x3000>;
+template<>
+struct NetPacket_Head<0x3000>;
+template<>
+struct Packet_Repeat<0x3000>;
+template<>
+struct NetPacket_Repeat<0x3000>;
+
+template<>
+struct Packet_Head<0x3001>;
+template<>
+struct NetPacket_Head<0x3001>;
+template<>
+struct Packet_Repeat<0x3001>;
+template<>
+struct NetPacket_Repeat<0x3001>;
+
+template<>
+struct Packet_Fixed<0x3002>;
+template<>
+struct NetPacket_Fixed<0x3002>;
+
+template<>
+struct Packet_Head<0x3003>;
+template<>
+struct NetPacket_Head<0x3003>;
+template<>
+struct Packet_Repeat<0x3003>;
+template<>
+struct NetPacket_Repeat<0x3003>;
+
+template<>
+struct Packet_Head<0x3004>;
+template<>
+struct NetPacket_Head<0x3004>;
+template<>
+struct Packet_Repeat<0x3004>;
+template<>
+struct NetPacket_Repeat<0x3004>;
+
+template<>
+struct Packet_Fixed<0x3005>;
+template<>
+struct NetPacket_Fixed<0x3005>;
+
+template<>
+struct Packet_Fixed<0x3010>;
+template<>
+struct NetPacket_Fixed<0x3010>;
+
+template<>
+struct Packet_Payload<0x3011>;
+template<>
+struct NetPacket_Payload<0x3011>;
+
+template<>
+struct Packet_Fixed<0x3020>;
+template<>
+struct NetPacket_Fixed<0x3020>;
+
+template<>
+struct Packet_Fixed<0x3021>;
+template<>
+struct NetPacket_Fixed<0x3021>;
+
+template<>
+struct Packet_Fixed<0x3022>;
+template<>
+struct NetPacket_Fixed<0x3022>;
+
+template<>
+struct Packet_Fixed<0x3023>;
+template<>
+struct NetPacket_Fixed<0x3023>;
+
+template<>
+struct Packet_Fixed<0x3024>;
+template<>
+struct NetPacket_Fixed<0x3024>;
+
+template<>
+struct Packet_Fixed<0x3025>;
+template<>
+struct NetPacket_Fixed<0x3025>;
+
+template<>
+struct Packet_Fixed<0x3026>;
+template<>
+struct NetPacket_Fixed<0x3026>;
+
+template<>
+struct Packet_Head<0x3027>;
+template<>
+struct NetPacket_Head<0x3027>;
+template<>
+struct Packet_Repeat<0x3027>;
+template<>
+struct NetPacket_Repeat<0x3027>;
+
+template<>
+struct Packet_Fixed<0x3028>;
+template<>
+struct NetPacket_Fixed<0x3028>;
+
+template<>
+struct Packet_Head<0x3800>;
+template<>
+struct NetPacket_Head<0x3800>;
+template<>
+struct Packet_Repeat<0x3800>;
+template<>
+struct NetPacket_Repeat<0x3800>;
+
+template<>
+struct Packet_Head<0x3801>;
+template<>
+struct NetPacket_Head<0x3801>;
+template<>
+struct Packet_Repeat<0x3801>;
+template<>
+struct NetPacket_Repeat<0x3801>;
+
+template<>
+struct Packet_Fixed<0x3802>;
+template<>
+struct NetPacket_Fixed<0x3802>;
+
+template<>
+struct Packet_Head<0x3803>;
+template<>
+struct NetPacket_Head<0x3803>;
+template<>
+struct Packet_Repeat<0x3803>;
+template<>
+struct NetPacket_Repeat<0x3803>;
+
+template<>
+struct Packet_Head<0x3804>;
+template<>
+struct NetPacket_Head<0x3804>;
+template<>
+struct Packet_Repeat<0x3804>;
+template<>
+struct NetPacket_Repeat<0x3804>;
+
+template<>
+struct Packet_Payload<0x3810>;
+template<>
+struct NetPacket_Payload<0x3810>;
+
+template<>
+struct Packet_Fixed<0x3811>;
+template<>
+struct NetPacket_Fixed<0x3811>;
+
+template<>
+struct Packet_Fixed<0x3820>;
+template<>
+struct NetPacket_Fixed<0x3820>;
+
+template<>
+struct Packet_Head<0x3821>;
+template<>
+struct NetPacket_Head<0x3821>;
+template<>
+struct Packet_Option<0x3821>;
+template<>
+struct NetPacket_Option<0x3821>;
+
+template<>
+struct Packet_Fixed<0x3822>;
+template<>
+struct NetPacket_Fixed<0x3822>;
+
+template<>
+struct Packet_Fixed<0x3823>;
+template<>
+struct NetPacket_Fixed<0x3823>;
+
+template<>
+struct Packet_Fixed<0x3824>;
+template<>
+struct NetPacket_Fixed<0x3824>;
+
+template<>
+struct Packet_Fixed<0x3825>;
+template<>
+struct NetPacket_Fixed<0x3825>;
+
+template<>
+struct Packet_Fixed<0x3826>;
+template<>
+struct NetPacket_Fixed<0x3826>;
+
+template<>
+struct Packet_Head<0x3827>;
+template<>
+struct NetPacket_Head<0x3827>;
+template<>
+struct Packet_Repeat<0x3827>;
+template<>
+struct NetPacket_Repeat<0x3827>;
+
+
+template<>
+struct Packet_Fixed<0x0061>;
+template<>
+struct NetPacket_Fixed<0x0061>;
+
+template<>
+struct Packet_Fixed<0x0062>;
+template<>
+struct NetPacket_Fixed<0x0062>;
+
+template<>
+struct Packet_Fixed<0x0065>;
+template<>
+struct NetPacket_Fixed<0x0065>;
+
+template<>
+struct Packet_Fixed<0x0066>;
+template<>
+struct NetPacket_Fixed<0x0066>;
+
+template<>
+struct Packet_Fixed<0x0067>;
+template<>
+struct NetPacket_Fixed<0x0067>;
+
+template<>
+struct Packet_Fixed<0x0068>;
+template<>
+struct NetPacket_Fixed<0x0068>;
+
+template<>
+struct Packet_Head<0x006b>;
+template<>
+struct NetPacket_Head<0x006b>;
+template<>
+struct Packet_Repeat<0x006b>;
+template<>
+struct NetPacket_Repeat<0x006b>;
+
+template<>
+struct Packet_Fixed<0x006c>;
+template<>
+struct NetPacket_Fixed<0x006c>;
+
+template<>
+struct Packet_Fixed<0x006d>;
+template<>
+struct NetPacket_Fixed<0x006d>;
+
+template<>
+struct Packet_Fixed<0x006e>;
+template<>
+struct NetPacket_Fixed<0x006e>;
+
+template<>
+struct Packet_Fixed<0x006f>;
+template<>
+struct NetPacket_Fixed<0x006f>;
+
+template<>
+struct Packet_Fixed<0x0070>;
+template<>
+struct NetPacket_Fixed<0x0070>;
+
+template<>
+struct Packet_Fixed<0x0071>;
+template<>
+struct NetPacket_Fixed<0x0071>;
 
 
 template<>
@@ -460,6 +910,11 @@ struct NetPacket_Fixed<0x0212>;
 
 
 template<>
+struct Packet_Fixed<0x0081>;
+template<>
+struct NetPacket_Fixed<0x0081>;
+
+template<>
 struct Packet_Fixed<0x7530>;
 template<>
 struct NetPacket_Fixed<0x7530>;
diff --git a/src/proto2/include_enums_test.cpp b/src/proto2/include_enums_test.cpp
index 2b9ed36..49b4a95 100644
--- a/src/proto2/include_enums_test.cpp
+++ b/src/proto2/include_enums_test.cpp
@@ -21,3 +21,4 @@
 #include "../poison.hpp"
 
 using Test_SEX = SEX;
+using Test_Option = Option;
diff --git a/src/proto2/include_mmo_test.cpp b/src/proto2/include_mmo_test.cpp
new file mode 100644
index 0000000..feb2de2
--- /dev/null
+++ b/src/proto2/include_mmo_test.cpp
@@ -0,0 +1,26 @@
+#include "../mmo/mmo.hpp"
+//    include_mmo_test.cpp - testsuite for protocol includes
+//
+//    Copyright © 2014 Ben Longbons <b.r.longbons@gmail.com>
+//
+//    This file is part of The Mana World (Athena server)
+//
+//    This program is free software: you can redistribute it and/or modify
+//    it under the terms of the GNU Affero General Public License as published by
+//    the Free Software Foundation, either version 3 of the License, or
+//    (at your option) any later version.
+//
+//    This program is distributed in the hope that it will be useful,
+//    but WITHOUT ANY WARRANTY; without even the implied warranty of
+//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//    GNU Affero General Public License for more details.
+//
+//    You should have received a copy of the GNU Affero General Public License
+//    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "../poison.hpp"
+
+using Test_CharKey = CharKey;
+using Test_CharData = CharData;
+using Test_PartyMost = PartyMost;
+using Test_Storage = Storage;
diff --git a/src/proto2/include_strs_test.cpp b/src/proto2/include_strs_test.cpp
index 5bf516c..eeaed7c 100644
--- a/src/proto2/include_strs_test.cpp
+++ b/src/proto2/include_strs_test.cpp
@@ -24,4 +24,7 @@ using Test_AccountName = AccountName;
 using Test_AccountPass = AccountPass;
 using Test_AccountEmail = AccountEmail;
 using Test_ServerName = ServerName;
+using Test_PartyName = PartyName;
 using Test_VarName = VarName;
+using Test_CharName = CharName;
+using Test_MapName = MapName;
diff --git a/src/proto2/login-admin.hpp b/src/proto2/login-admin.hpp
index f5cf0f7..7876d1d 100644
--- a/src/proto2/login-admin.hpp
+++ b/src/proto2/login-admin.hpp
@@ -27,6 +27,9 @@
 
 // This is an internal protocol, and can be changed without notice
 
+// this is only needed for the payload packet right now, and that needs to die
+#pragma pack(push, 1)
+
 template<>
 struct Packet_Head<0x2726>
 {
@@ -2164,4 +2167,6 @@ bool network_to_native(Packet_Fixed<0x7955> *native, NetPacket_Fixed<0x7955> net
 }
 
 
+#pragma pack(pop)
+
 #endif // TMWA_PROTO2_LOGIN_ADMIN_HPP
diff --git a/src/proto2/login-char.hpp b/src/proto2/login-char.hpp
index 6b2004d..14d19a9 100644
--- a/src/proto2/login-char.hpp
+++ b/src/proto2/login-char.hpp
@@ -27,6 +27,9 @@
 
 // This is an internal protocol, and can be changed without notice
 
+// this is only needed for the payload packet right now, and that needs to die
+#pragma pack(push, 1)
+
 template<>
 struct Packet_Fixed<0x2709>
 {
@@ -206,7 +209,7 @@ struct Packet_Fixed<0x2725>
     // TODO remove this
     uint16_t magic_packet_id = PACKET_ID;
     AccountId account_id = {};
-    HumanTimeDiff deltas = {};
+    HumanTimeDiff ban_add = {};
 };
 
 template<>
@@ -532,11 +535,11 @@ struct NetPacket_Fixed<0x2725>
 {
     Little16 magic_packet_id;
     Little32 account_id;
-    NetHumanTimeDiff deltas;
+    NetHumanTimeDiff ban_add;
 };
 static_assert(offsetof(NetPacket_Fixed<0x2725>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2725>, magic_packet_id) == 0");
 static_assert(offsetof(NetPacket_Fixed<0x2725>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2725>, account_id) == 2");
-static_assert(offsetof(NetPacket_Fixed<0x2725>, deltas) == 6, "offsetof(NetPacket_Fixed<0x2725>, deltas) == 6");
+static_assert(offsetof(NetPacket_Fixed<0x2725>, ban_add) == 6, "offsetof(NetPacket_Fixed<0x2725>, ban_add) == 6");
 static_assert(sizeof(NetPacket_Fixed<0x2725>) == 18, "sizeof(NetPacket_Fixed<0x2725>) == 18");
 
 template<>
@@ -975,7 +978,7 @@ bool native_to_network(NetPacket_Fixed<0x2725> *network, Packet_Fixed<0x2725> na
     bool rv = true;
     rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
     rv &= native_to_network(&network->account_id, native.account_id);
-    rv &= native_to_network(&network->deltas, native.deltas);
+    rv &= native_to_network(&network->ban_add, native.ban_add);
     return rv;
 }
 inline __attribute__((warn_unused_result))
@@ -984,7 +987,7 @@ bool network_to_native(Packet_Fixed<0x2725> *native, NetPacket_Fixed<0x2725> net
     bool rv = true;
     rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
     rv &= network_to_native(&native->account_id, network.account_id);
-    rv &= network_to_native(&native->deltas, network.deltas);
+    rv &= network_to_native(&native->ban_add, network.ban_add);
     return rv;
 }
 
@@ -1204,4 +1207,6 @@ bool network_to_native(Packet_Fixed<0x2741> *native, NetPacket_Fixed<0x2741> net
 }
 
 
+#pragma pack(pop)
+
 #endif // TMWA_PROTO2_LOGIN_CHAR_HPP
diff --git a/src/proto2/login-user.hpp b/src/proto2/login-user.hpp
index dbdf322..7f0e5ea 100644
--- a/src/proto2/login-user.hpp
+++ b/src/proto2/login-user.hpp
@@ -27,6 +27,9 @@
 
 // This is a public protocol, and changes require client cooperation
 
+// this is only needed for the payload packet right now, and that needs to die
+#pragma pack(push, 1)
+
 template<>
 struct Packet_Head<0x0063>
 {
@@ -99,16 +102,6 @@ struct Packet_Fixed<0x006a>
     timestamp_seconds_buffer error_message = {};
 };
 
-template<>
-struct Packet_Fixed<0x0081>
-{
-    static const uint16_t PACKET_ID = 0x0081;
-
-    // TODO remove this
-    uint16_t magic_packet_id = PACKET_ID;
-    uint8_t error_code = {};
-};
-
 
 template<>
 struct NetPacket_Head<0x0063>
@@ -196,16 +189,6 @@ static_assert(offsetof(NetPacket_Fixed<0x006a>, error_code) == 2, "offsetof(NetP
 static_assert(offsetof(NetPacket_Fixed<0x006a>, error_message) == 3, "offsetof(NetPacket_Fixed<0x006a>, error_message) == 3");
 static_assert(sizeof(NetPacket_Fixed<0x006a>) == 23, "sizeof(NetPacket_Fixed<0x006a>) == 23");
 
-template<>
-struct NetPacket_Fixed<0x0081>
-{
-    Little16 magic_packet_id;
-    Byte error_code;
-};
-static_assert(offsetof(NetPacket_Fixed<0x0081>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0081>, magic_packet_id) == 0");
-static_assert(offsetof(NetPacket_Fixed<0x0081>, error_code) == 2, "offsetof(NetPacket_Fixed<0x0081>, error_code) == 2");
-static_assert(sizeof(NetPacket_Fixed<0x0081>) == 3, "sizeof(NetPacket_Fixed<0x0081>) == 3");
-
 
 inline __attribute__((warn_unused_result))
 bool native_to_network(NetPacket_Head<0x0063> *network, Packet_Head<0x0063> native)
@@ -335,22 +318,7 @@ bool network_to_native(Packet_Fixed<0x006a> *native, NetPacket_Fixed<0x006a> net
     return rv;
 }
 
-inline __attribute__((warn_unused_result))
-bool native_to_network(NetPacket_Fixed<0x0081> *network, Packet_Fixed<0x0081> native)
-{
-    bool rv = true;
-    rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id);
-    rv &= native_to_network(&network->error_code, native.error_code);
-    return rv;
-}
-inline __attribute__((warn_unused_result))
-bool network_to_native(Packet_Fixed<0x0081> *native, NetPacket_Fixed<0x0081> network)
-{
-    bool rv = true;
-    rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id);
-    rv &= network_to_native(&native->error_code, network.error_code);
-    return rv;
-}
 
+#pragma pack(pop)
 
 #endif // TMWA_PROTO2_LOGIN_USER_HPP
diff --git a/src/proto2/map-user.hpp b/src/proto2/map-user.hpp
index d68f436..08d19fa 100644
--- a/src/proto2/map-user.hpp
+++ b/src/proto2/map-user.hpp
@@ -27,6 +27,9 @@
 
 // This is a public protocol, and changes require client cooperation
 
+// this is only needed for the payload packet right now, and that needs to die
+#pragma pack(push, 1)
+
 template<>
 struct Packet_Fixed<0x0212>
 {
@@ -87,4 +90,6 @@ bool network_to_native(Packet_Fixed<0x0212> *native, NetPacket_Fixed<0x0212> net
 }
 
 
+#pragma pack(pop)
+
 #endif // TMWA_PROTO2_MAP_USER_HPP
diff --git a/src/proto2/types.hpp b/src/proto2/types.hpp
index 92413e3..594be22 100644
--- a/src/proto2/types.hpp
+++ b/src/proto2/types.hpp
@@ -29,6 +29,7 @@
 # include "../mmo/enums.hpp"
 # include "../mmo/human_time_diff.hpp"
 # include "../mmo/ids.hpp"
+# include "../mmo/mmo.hpp"
 # include "../mmo/strs.hpp"
 # include "../mmo/utils.hpp"
 # include "../mmo/version.hpp"
@@ -71,6 +72,38 @@ bool network_to_native(VString<N-1> *native, NetString<N> network)
     return true;
 }
 
+inline
+bool native_to_network(NetString<24> *network, CharName native)
+{
+    VString<23> tmp = native.to__actual();
+    bool rv = native_to_network(network, tmp);
+    return rv;
+}
+inline
+bool network_to_native(CharName *native, NetString<24> network)
+{
+    VString<23> tmp;
+    bool rv = network_to_native(&tmp, network);
+    *native = stringish<CharName>(tmp);
+    return rv;
+}
+
+inline
+bool native_to_network(NetString<16> *network, MapName native)
+{
+    XString tmp = native;
+    bool rv = native_to_network(network, VString<15>(tmp));
+    return rv;
+}
+inline
+bool network_to_native(MapName *native, NetString<16> network)
+{
+    VString<15> tmp;
+    bool rv = network_to_native(&tmp, network);
+    *native = stringish<MapName>(tmp);
+    return rv;
+}
+
 template<class T, size_t N>
 struct SkewedLength
 {
@@ -109,6 +142,24 @@ bool network_to_native(SEX *native, Byte network)
     return rv;
 }
 inline __attribute__((warn_unused_result))
+bool native_to_network(Little16 *network, Option native)
+{
+    bool rv = true;
+    uint16_t tmp = static_cast<uint16_t>(native);
+    rv &= native_to_network(network, tmp);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Option *native, Little16 network)
+{
+    bool rv = true;
+    uint16_t tmp;
+    rv &= network_to_native(&tmp, network);
+    *native = static_cast<Option>(tmp);
+    // TODO this is what really should be doing a checked cast
+    return rv;
+}
+inline __attribute__((warn_unused_result))
 bool native_to_network(Little16 *network, Species native)
 {
     bool rv = true;
@@ -316,4 +367,244 @@ bool network_to_native(VERSION_2 *native, Byte network)
     // TODO this is what really should be doing a checked cast
     return rv;
 }
+struct Stats6
+{
+    uint8_t str = {};
+    uint8_t agi = {};
+    uint8_t vit = {};
+    uint8_t int_ = {};
+    uint8_t dex = {};
+    uint8_t luk = {};
+};
+struct NetStats6
+{
+    Byte str;
+    Byte agi;
+    Byte vit;
+    Byte int_;
+    Byte dex;
+    Byte luk;
+};
+static_assert(offsetof(NetStats6, str) == 0, "offsetof(NetStats6, str) == 0");
+static_assert(offsetof(NetStats6, agi) == 1, "offsetof(NetStats6, agi) == 1");
+static_assert(offsetof(NetStats6, vit) == 2, "offsetof(NetStats6, vit) == 2");
+static_assert(offsetof(NetStats6, int_) == 3, "offsetof(NetStats6, int_) == 3");
+static_assert(offsetof(NetStats6, dex) == 4, "offsetof(NetStats6, dex) == 4");
+static_assert(offsetof(NetStats6, luk) == 5, "offsetof(NetStats6, luk) == 5");
+static_assert(sizeof(NetStats6) == 6, "sizeof(NetStats6) == 6");
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetStats6 *network, Stats6 native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->str, native.str);
+    rv &= native_to_network(&network->agi, native.agi);
+    rv &= native_to_network(&network->vit, native.vit);
+    rv &= native_to_network(&network->int_, native.int_);
+    rv &= native_to_network(&network->dex, native.dex);
+    rv &= native_to_network(&network->luk, native.luk);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(Stats6 *native, NetStats6 network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->str, network.str);
+    rv &= network_to_native(&native->agi, network.agi);
+    rv &= network_to_native(&native->vit, network.vit);
+    rv &= network_to_native(&native->int_, network.int_);
+    rv &= network_to_native(&native->dex, network.dex);
+    rv &= network_to_native(&native->luk, network.luk);
+    return rv;
+}
+
+struct CharSelect
+{
+    CharId char_id = {};
+    uint32_t base_exp = {};
+    uint32_t zeny = {};
+    uint32_t job_exp = {};
+    uint32_t job_level = {};
+    ItemNameId shoes = {};
+    ItemNameId gloves = {};
+    ItemNameId cape = {};
+    ItemNameId misc1 = {};
+    Option option = {};
+    uint16_t unused = {};
+    uint32_t karma = {};
+    uint32_t manner = {};
+    uint16_t status_point = {};
+    uint16_t hp = {};
+    uint16_t max_hp = {};
+    uint16_t sp = {};
+    uint16_t max_sp = {};
+    uint16_t speed = {};
+    Species species = {};
+    uint16_t hair_style = {};
+    uint16_t weapon = {};
+    uint16_t base_level = {};
+    uint16_t skill_point = {};
+    ItemNameId head_bottom = {};
+    ItemNameId shield = {};
+    ItemNameId head_top = {};
+    ItemNameId head_mid = {};
+    uint16_t hair_color = {};
+    ItemNameId misc2 = {};
+    CharName char_name = {};
+    Stats6 stats = {};
+    uint8_t char_num = {};
+    uint8_t unused2 = {};
+};
+struct NetCharSelect
+{
+    Little32 char_id;
+    Little32 base_exp;
+    Little32 zeny;
+    Little32 job_exp;
+    Little32 job_level;
+    Little16 shoes;
+    Little16 gloves;
+    Little16 cape;
+    Little16 misc1;
+    Little16 option;
+    Little16 unused;
+    Little32 karma;
+    Little32 manner;
+    Little16 status_point;
+    Little16 hp;
+    Little16 max_hp;
+    Little16 sp;
+    Little16 max_sp;
+    Little16 speed;
+    Little16 species;
+    Little16 hair_style;
+    Little16 weapon;
+    Little16 base_level;
+    Little16 skill_point;
+    Little16 head_bottom;
+    Little16 shield;
+    Little16 head_top;
+    Little16 head_mid;
+    Little16 hair_color;
+    Little16 misc2;
+    NetString<sizeof(CharName)> char_name;
+    NetStats6 stats;
+    Byte char_num;
+    Byte unused2;
+};
+static_assert(offsetof(NetCharSelect, char_id) == 0, "offsetof(NetCharSelect, char_id) == 0");
+static_assert(offsetof(NetCharSelect, base_exp) == 4, "offsetof(NetCharSelect, base_exp) == 4");
+static_assert(offsetof(NetCharSelect, zeny) == 8, "offsetof(NetCharSelect, zeny) == 8");
+static_assert(offsetof(NetCharSelect, job_exp) == 12, "offsetof(NetCharSelect, job_exp) == 12");
+static_assert(offsetof(NetCharSelect, job_level) == 16, "offsetof(NetCharSelect, job_level) == 16");
+static_assert(offsetof(NetCharSelect, shoes) == 20, "offsetof(NetCharSelect, shoes) == 20");
+static_assert(offsetof(NetCharSelect, gloves) == 22, "offsetof(NetCharSelect, gloves) == 22");
+static_assert(offsetof(NetCharSelect, cape) == 24, "offsetof(NetCharSelect, cape) == 24");
+static_assert(offsetof(NetCharSelect, misc1) == 26, "offsetof(NetCharSelect, misc1) == 26");
+static_assert(offsetof(NetCharSelect, option) == 28, "offsetof(NetCharSelect, option) == 28");
+static_assert(offsetof(NetCharSelect, unused) == 30, "offsetof(NetCharSelect, unused) == 30");
+static_assert(offsetof(NetCharSelect, karma) == 32, "offsetof(NetCharSelect, karma) == 32");
+static_assert(offsetof(NetCharSelect, manner) == 36, "offsetof(NetCharSelect, manner) == 36");
+static_assert(offsetof(NetCharSelect, status_point) == 40, "offsetof(NetCharSelect, status_point) == 40");
+static_assert(offsetof(NetCharSelect, hp) == 42, "offsetof(NetCharSelect, hp) == 42");
+static_assert(offsetof(NetCharSelect, max_hp) == 44, "offsetof(NetCharSelect, max_hp) == 44");
+static_assert(offsetof(NetCharSelect, sp) == 46, "offsetof(NetCharSelect, sp) == 46");
+static_assert(offsetof(NetCharSelect, max_sp) == 48, "offsetof(NetCharSelect, max_sp) == 48");
+static_assert(offsetof(NetCharSelect, speed) == 50, "offsetof(NetCharSelect, speed) == 50");
+static_assert(offsetof(NetCharSelect, species) == 52, "offsetof(NetCharSelect, species) == 52");
+static_assert(offsetof(NetCharSelect, hair_style) == 54, "offsetof(NetCharSelect, hair_style) == 54");
+static_assert(offsetof(NetCharSelect, weapon) == 56, "offsetof(NetCharSelect, weapon) == 56");
+static_assert(offsetof(NetCharSelect, base_level) == 58, "offsetof(NetCharSelect, base_level) == 58");
+static_assert(offsetof(NetCharSelect, skill_point) == 60, "offsetof(NetCharSelect, skill_point) == 60");
+static_assert(offsetof(NetCharSelect, head_bottom) == 62, "offsetof(NetCharSelect, head_bottom) == 62");
+static_assert(offsetof(NetCharSelect, shield) == 64, "offsetof(NetCharSelect, shield) == 64");
+static_assert(offsetof(NetCharSelect, head_top) == 66, "offsetof(NetCharSelect, head_top) == 66");
+static_assert(offsetof(NetCharSelect, head_mid) == 68, "offsetof(NetCharSelect, head_mid) == 68");
+static_assert(offsetof(NetCharSelect, hair_color) == 70, "offsetof(NetCharSelect, hair_color) == 70");
+static_assert(offsetof(NetCharSelect, misc2) == 72, "offsetof(NetCharSelect, misc2) == 72");
+static_assert(offsetof(NetCharSelect, char_name) == 74, "offsetof(NetCharSelect, char_name) == 74");
+static_assert(offsetof(NetCharSelect, stats) == 98, "offsetof(NetCharSelect, stats) == 98");
+static_assert(offsetof(NetCharSelect, char_num) == 104, "offsetof(NetCharSelect, char_num) == 104");
+static_assert(offsetof(NetCharSelect, unused2) == 105, "offsetof(NetCharSelect, unused2) == 105");
+static_assert(sizeof(NetCharSelect) == 106, "sizeof(NetCharSelect) == 106");
+inline __attribute__((warn_unused_result))
+bool native_to_network(NetCharSelect *network, CharSelect native)
+{
+    bool rv = true;
+    rv &= native_to_network(&network->char_id, native.char_id);
+    rv &= native_to_network(&network->base_exp, native.base_exp);
+    rv &= native_to_network(&network->zeny, native.zeny);
+    rv &= native_to_network(&network->job_exp, native.job_exp);
+    rv &= native_to_network(&network->job_level, native.job_level);
+    rv &= native_to_network(&network->shoes, native.shoes);
+    rv &= native_to_network(&network->gloves, native.gloves);
+    rv &= native_to_network(&network->cape, native.cape);
+    rv &= native_to_network(&network->misc1, native.misc1);
+    rv &= native_to_network(&network->option, native.option);
+    rv &= native_to_network(&network->unused, native.unused);
+    rv &= native_to_network(&network->karma, native.karma);
+    rv &= native_to_network(&network->manner, native.manner);
+    rv &= native_to_network(&network->status_point, native.status_point);
+    rv &= native_to_network(&network->hp, native.hp);
+    rv &= native_to_network(&network->max_hp, native.max_hp);
+    rv &= native_to_network(&network->sp, native.sp);
+    rv &= native_to_network(&network->max_sp, native.max_sp);
+    rv &= native_to_network(&network->speed, native.speed);
+    rv &= native_to_network(&network->species, native.species);
+    rv &= native_to_network(&network->hair_style, native.hair_style);
+    rv &= native_to_network(&network->weapon, native.weapon);
+    rv &= native_to_network(&network->base_level, native.base_level);
+    rv &= native_to_network(&network->skill_point, native.skill_point);
+    rv &= native_to_network(&network->head_bottom, native.head_bottom);
+    rv &= native_to_network(&network->shield, native.shield);
+    rv &= native_to_network(&network->head_top, native.head_top);
+    rv &= native_to_network(&network->head_mid, native.head_mid);
+    rv &= native_to_network(&network->hair_color, native.hair_color);
+    rv &= native_to_network(&network->misc2, native.misc2);
+    rv &= native_to_network(&network->char_name, native.char_name);
+    rv &= native_to_network(&network->stats, native.stats);
+    rv &= native_to_network(&network->char_num, native.char_num);
+    rv &= native_to_network(&network->unused2, native.unused2);
+    return rv;
+}
+inline __attribute__((warn_unused_result))
+bool network_to_native(CharSelect *native, NetCharSelect network)
+{
+    bool rv = true;
+    rv &= network_to_native(&native->char_id, network.char_id);
+    rv &= network_to_native(&native->base_exp, network.base_exp);
+    rv &= network_to_native(&native->zeny, network.zeny);
+    rv &= network_to_native(&native->job_exp, network.job_exp);
+    rv &= network_to_native(&native->job_level, network.job_level);
+    rv &= network_to_native(&native->shoes, network.shoes);
+    rv &= network_to_native(&native->gloves, network.gloves);
+    rv &= network_to_native(&native->cape, network.cape);
+    rv &= network_to_native(&native->misc1, network.misc1);
+    rv &= network_to_native(&native->option, network.option);
+    rv &= network_to_native(&native->unused, network.unused);
+    rv &= network_to_native(&native->karma, network.karma);
+    rv &= network_to_native(&native->manner, network.manner);
+    rv &= network_to_native(&native->status_point, network.status_point);
+    rv &= network_to_native(&native->hp, network.hp);
+    rv &= network_to_native(&native->max_hp, network.max_hp);
+    rv &= network_to_native(&native->sp, network.sp);
+    rv &= network_to_native(&native->max_sp, network.max_sp);
+    rv &= network_to_native(&native->speed, network.speed);
+    rv &= network_to_native(&native->species, network.species);
+    rv &= network_to_native(&native->hair_style, network.hair_style);
+    rv &= network_to_native(&native->weapon, network.weapon);
+    rv &= network_to_native(&native->base_level, network.base_level);
+    rv &= network_to_native(&native->skill_point, network.skill_point);
+    rv &= network_to_native(&native->head_bottom, network.head_bottom);
+    rv &= network_to_native(&native->shield, network.shield);
+    rv &= network_to_native(&native->head_top, network.head_top);
+    rv &= network_to_native(&native->head_mid, network.head_mid);
+    rv &= network_to_native(&native->hair_color, network.hair_color);
+    rv &= network_to_native(&native->misc2, network.misc2);
+    rv &= network_to_native(&native->char_name, network.char_name);
+    rv &= network_to_native(&native->stats, network.stats);
+    rv &= network_to_native(&native->char_num, network.char_num);
+    rv &= network_to_native(&native->unused2, network.unused2);
+    return rv;
+}
+
 #endif // TMWA_PROTO2_TYPES_HPP