1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
|
/**
* This file is part of Hercules.
* http://herc.ws - http://github.com/HerculesWS/Hercules
*
* Copyright (C) 2014-2018 Hercules Dev Team
*
* Hercules is free software: you can redistribute it and/or modify
* it under the terms of the GNU 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* NOTE: This file was auto-generated and should never be manually edited,
* as it will get overwritten.
*/
/* GENERATED FILE DO NOT EDIT */
#ifndef HPM_DATA_CHECK_H
#define HPM_DATA_CHECK_H
#if !defined(HPMHOOKGEN)
#include "common/HPMSymbols.inc.h"
#endif // ! HPMHOOKGEN
#ifdef HPM_SYMBOL
#undef HPM_SYMBOL
#endif // HPM_SYMBOL
HPExport const struct s_HPMDataCheck HPMDataCheck[] = {
#ifdef CHAR_CHAR_H
{ "char_auth_node", sizeof(struct char_auth_node), SERVER_TYPE_CHAR },
{ "char_interface", sizeof(struct char_interface), SERVER_TYPE_CHAR },
{ "char_session_data", sizeof(struct char_session_data), SERVER_TYPE_CHAR },
{ "mmo_map_server", sizeof(struct mmo_map_server), SERVER_TYPE_CHAR },
{ "online_char_data", sizeof(struct online_char_data), SERVER_TYPE_CHAR },
#else
#define CHAR_CHAR_H
#endif // CHAR_CHAR_H
#ifdef CHAR_GEOIP_H
{ "geoip_interface", sizeof(struct geoip_interface), SERVER_TYPE_CHAR },
{ "s_geoip", sizeof(struct s_geoip), SERVER_TYPE_CHAR },
#else
#define CHAR_GEOIP_H
#endif // CHAR_GEOIP_H
#ifdef CHAR_INTER_H
{ "WisData", sizeof(struct WisData), SERVER_TYPE_CHAR },
{ "inter_interface", sizeof(struct inter_interface), SERVER_TYPE_CHAR },
#else
#define CHAR_INTER_H
#endif // CHAR_INTER_H
#ifdef CHAR_INT_ACHIEVEMENT_H
{ "inter_achievement_interface", sizeof(struct inter_achievement_interface), SERVER_TYPE_CHAR },
#else
#define CHAR_INT_ACHIEVEMENT_H
#endif // CHAR_INT_ACHIEVEMENT_H
#ifdef CHAR_INT_AUCTION_H
{ "inter_auction_interface", sizeof(struct inter_auction_interface), SERVER_TYPE_CHAR },
#else
#define CHAR_INT_AUCTION_H
#endif // CHAR_INT_AUCTION_H
#ifdef CHAR_INT_CLAN_H
{ "inter_clan_interface", sizeof(struct inter_clan_interface), SERVER_TYPE_CHAR },
#else
#define CHAR_INT_CLAN_H
#endif // CHAR_INT_CLAN_H
#ifdef CHAR_INT_ELEMENTAL_H
{ "inter_elemental_interface", sizeof(struct inter_elemental_interface), SERVER_TYPE_CHAR },
#else
#define CHAR_INT_ELEMENTAL_H
#endif // CHAR_INT_ELEMENTAL_H
#ifdef CHAR_INT_GUILD_H
{ "inter_guild_interface", sizeof(struct inter_guild_interface), SERVER_TYPE_CHAR },
#else
#define CHAR_INT_GUILD_H
#endif // CHAR_INT_GUILD_H
#ifdef CHAR_INT_HOMUN_H
{ "inter_homunculus_interface", sizeof(struct inter_homunculus_interface), SERVER_TYPE_CHAR },
#else
#define CHAR_INT_HOMUN_H
#endif // CHAR_INT_HOMUN_H
#ifdef CHAR_INT_MAIL_H
{ "inter_mail_interface", sizeof(struct inter_mail_interface), SERVER_TYPE_CHAR },
#else
#define CHAR_INT_MAIL_H
#endif // CHAR_INT_MAIL_H
#ifdef CHAR_INT_MERCENARY_H
{ "inter_mercenary_interface", sizeof(struct inter_mercenary_interface), SERVER_TYPE_CHAR },
#else
#define CHAR_INT_MERCENARY_H
#endif // CHAR_INT_MERCENARY_H
#ifdef CHAR_INT_PARTY_H
{ "inter_party_interface", sizeof(struct inter_party_interface), SERVER_TYPE_CHAR },
#else
#define CHAR_INT_PARTY_H
#endif // CHAR_INT_PARTY_H
#ifdef CHAR_INT_PET_H
{ "inter_pet_interface", sizeof(struct inter_pet_interface), SERVER_TYPE_CHAR },
#else
#define CHAR_INT_PET_H
#endif // CHAR_INT_PET_H
#ifdef CHAR_INT_QUEST_H
{ "inter_quest_interface", sizeof(struct inter_quest_interface), SERVER_TYPE_CHAR },
#else
#define CHAR_INT_QUEST_H
#endif // CHAR_INT_QUEST_H
#ifdef CHAR_INT_RODEX_H
{ "inter_rodex_interface", sizeof(struct inter_rodex_interface), SERVER_TYPE_CHAR },
#else
#define CHAR_INT_RODEX_H
#endif // CHAR_INT_RODEX_H
#ifdef CHAR_INT_STORAGE_H
{ "inter_storage_interface", sizeof(struct inter_storage_interface), SERVER_TYPE_CHAR },
#else
#define CHAR_INT_STORAGE_H
#endif // CHAR_INT_STORAGE_H
#ifdef CHAR_LOGINIF_H
{ "loginif_interface", sizeof(struct loginif_interface), SERVER_TYPE_CHAR },
#else
#define CHAR_LOGINIF_H
#endif // CHAR_LOGINIF_H
#ifdef CHAR_MAPIF_H
{ "mapif_interface", sizeof(struct mapif_interface), SERVER_TYPE_CHAR },
#else
#define CHAR_MAPIF_H
#endif // CHAR_MAPIF_H
#ifdef CHAR_PINCODE_H
{ "pincode_interface", sizeof(struct pincode_interface), SERVER_TYPE_CHAR },
#else
#define CHAR_PINCODE_H
#endif // CHAR_PINCODE_H
#ifdef COMMON_CONF_H
{ "libconfig_interface", sizeof(struct libconfig_interface), SERVER_TYPE_ALL },
#else
#define COMMON_CONF_H
#endif // COMMON_CONF_H
#ifdef COMMON_CONSOLE_H
{ "CParseEntry", sizeof(struct CParseEntry), SERVER_TYPE_ALL },
{ "console_input_interface", sizeof(struct console_input_interface), SERVER_TYPE_ALL },
{ "console_interface", sizeof(struct console_interface), SERVER_TYPE_ALL },
#else
#define COMMON_CONSOLE_H
#endif // COMMON_CONSOLE_H
#ifdef COMMON_CORE_H
{ "CmdlineArgData", sizeof(struct CmdlineArgData), SERVER_TYPE_ALL },
{ "cmdline_interface", sizeof(struct cmdline_interface), SERVER_TYPE_ALL },
{ "core_interface", sizeof(struct core_interface), SERVER_TYPE_ALL },
#else
#define COMMON_CORE_H
#endif // COMMON_CORE_H
#ifdef COMMON_DB_H
{ "DBData", sizeof(struct DBData), SERVER_TYPE_ALL },
{ "DBIterator", sizeof(struct DBIterator), SERVER_TYPE_ALL },
{ "DBMap", sizeof(struct DBMap), SERVER_TYPE_ALL },
{ "db_interface", sizeof(struct db_interface), SERVER_TYPE_ALL },
{ "linkdb_node", sizeof(struct linkdb_node), SERVER_TYPE_ALL },
#else
#define COMMON_DB_H
#endif // COMMON_DB_H
#ifdef COMMON_DES_H
{ "des_bit64", sizeof(struct des_bit64), SERVER_TYPE_ALL },
{ "des_interface", sizeof(struct des_interface), SERVER_TYPE_ALL },
#else
#define COMMON_DES_H
#endif // COMMON_DES_H
#ifdef COMMON_ERS_H
{ "eri", sizeof(struct eri), SERVER_TYPE_ALL },
#else
#define COMMON_ERS_H
#endif // COMMON_ERS_H
#ifdef COMMON_GRFIO_H
{ "grfio_interface", sizeof(struct grfio_interface), SERVER_TYPE_MAP },
#else
#define COMMON_GRFIO_H
#endif // COMMON_GRFIO_H
#ifdef COMMON_HPMI_H
{ "HPMi_interface", sizeof(struct HPMi_interface), SERVER_TYPE_ALL },
{ "hplugin_info", sizeof(struct hplugin_info), SERVER_TYPE_ALL },
{ "s_HPMDataCheck", sizeof(struct s_HPMDataCheck), SERVER_TYPE_ALL },
#else
#define COMMON_HPMI_H
#endif // COMMON_HPMI_H
#ifdef COMMON_MAPINDEX_H
{ "mapindex_interface", sizeof(struct mapindex_interface), SERVER_TYPE_CHAR|SERVER_TYPE_MAP },
#else
#define COMMON_MAPINDEX_H
#endif // COMMON_MAPINDEX_H
#ifdef COMMON_MD5CALC_H
{ "md5_interface", sizeof(struct md5_interface), SERVER_TYPE_ALL },
#else
#define COMMON_MD5CALC_H
#endif // COMMON_MD5CALC_H
#ifdef COMMON_MEMMGR_H
{ "malloc_interface", sizeof(struct malloc_interface), SERVER_TYPE_ALL },
#else
#define COMMON_MEMMGR_H
#endif // COMMON_MEMMGR_H
#ifdef COMMON_MMO_H
{ "achievement", sizeof(struct achievement), SERVER_TYPE_ALL },
{ "auction_data", sizeof(struct auction_data), SERVER_TYPE_ALL },
{ "char_achievements", sizeof(struct char_achievements), SERVER_TYPE_ALL },
{ "clan", sizeof(struct clan), SERVER_TYPE_ALL },
{ "clan_buff", sizeof(struct clan_buff), SERVER_TYPE_ALL },
{ "clan_member", sizeof(struct clan_member), SERVER_TYPE_ALL },
{ "clan_relationship", sizeof(struct clan_relationship), SERVER_TYPE_ALL },
{ "fame_list", sizeof(struct fame_list), SERVER_TYPE_ALL },
{ "guild", sizeof(struct guild), SERVER_TYPE_ALL },
{ "guild_alliance", sizeof(struct guild_alliance), SERVER_TYPE_ALL },
{ "guild_castle", sizeof(struct guild_castle), SERVER_TYPE_ALL },
{ "guild_expulsion", sizeof(struct guild_expulsion), SERVER_TYPE_ALL },
{ "guild_member", sizeof(struct guild_member), SERVER_TYPE_ALL },
{ "guild_position", sizeof(struct guild_position), SERVER_TYPE_ALL },
{ "guild_skill", sizeof(struct guild_skill), SERVER_TYPE_ALL },
{ "guild_storage", sizeof(struct guild_storage), SERVER_TYPE_ALL },
{ "hotkey", sizeof(struct hotkey), SERVER_TYPE_ALL },
{ "item", sizeof(struct item), SERVER_TYPE_ALL },
{ "item_option", sizeof(struct item_option), SERVER_TYPE_ALL },
{ "mail_data", sizeof(struct mail_data), SERVER_TYPE_ALL },
{ "mail_message", sizeof(struct mail_message), SERVER_TYPE_ALL },
{ "mmo_charstatus", sizeof(struct mmo_charstatus), SERVER_TYPE_ALL },
{ "party", sizeof(struct party), SERVER_TYPE_ALL },
{ "party_member", sizeof(struct party_member), SERVER_TYPE_ALL },
{ "point", sizeof(struct point), SERVER_TYPE_ALL },
{ "quest", sizeof(struct quest), SERVER_TYPE_ALL },
{ "rodex_maillist", sizeof(struct rodex_maillist), SERVER_TYPE_ALL },
{ "rodex_message", sizeof(struct rodex_message), SERVER_TYPE_ALL },
{ "s_elemental", sizeof(struct s_elemental), SERVER_TYPE_ALL },
{ "s_friend", sizeof(struct s_friend), SERVER_TYPE_ALL },
{ "s_homunculus", sizeof(struct s_homunculus), SERVER_TYPE_ALL },
{ "s_mercenary", sizeof(struct s_mercenary), SERVER_TYPE_ALL },
{ "s_pet", sizeof(struct s_pet), SERVER_TYPE_ALL },
{ "s_skill", sizeof(struct s_skill), SERVER_TYPE_ALL },
{ "script_reg_num", sizeof(struct script_reg_num), SERVER_TYPE_ALL },
{ "script_reg_state", sizeof(struct script_reg_state), SERVER_TYPE_ALL },
{ "script_reg_str", sizeof(struct script_reg_str), SERVER_TYPE_ALL },
{ "status_change_data", sizeof(struct status_change_data), SERVER_TYPE_ALL },
{ "storage_data", sizeof(struct storage_data), SERVER_TYPE_ALL },
#else
#define COMMON_MMO_H
#endif // COMMON_MMO_H
#ifdef COMMON_MUTEX_H
{ "mutex_interface", sizeof(struct mutex_interface), SERVER_TYPE_ALL },
#else
#define COMMON_MUTEX_H
#endif // COMMON_MUTEX_H
#ifdef COMMON_NULLPO_H
{ "nullpo_interface", sizeof(struct nullpo_interface), SERVER_TYPE_ALL },
#else
#define COMMON_NULLPO_H
#endif // COMMON_NULLPO_H
#ifdef COMMON_RANDOM_H
{ "rnd_interface", sizeof(struct rnd_interface), SERVER_TYPE_ALL },
#else
#define COMMON_RANDOM_H
#endif // COMMON_RANDOM_H
#ifdef COMMON_SHOWMSG_H
{ "showmsg_interface", sizeof(struct showmsg_interface), SERVER_TYPE_ALL },
#else
#define COMMON_SHOWMSG_H
#endif // COMMON_SHOWMSG_H
#ifdef COMMON_SOCKET_H
{ "hSockOpt", sizeof(struct hSockOpt), SERVER_TYPE_ALL },
{ "s_subnet", sizeof(struct s_subnet), SERVER_TYPE_ALL },
{ "s_subnet_vector", sizeof(struct s_subnet_vector), SERVER_TYPE_ALL },
{ "socket_data", sizeof(struct socket_data), SERVER_TYPE_ALL },
{ "socket_interface", sizeof(struct socket_interface), SERVER_TYPE_ALL },
#else
#define COMMON_SOCKET_H
#endif // COMMON_SOCKET_H
#ifdef COMMON_SPINLOCK_H
{ "spin_lock", sizeof(struct spin_lock), SERVER_TYPE_ALL },
#else
#define COMMON_SPINLOCK_H
#endif // COMMON_SPINLOCK_H
#ifdef COMMON_SQL_H
{ "sql_interface", sizeof(struct sql_interface), SERVER_TYPE_ALL },
#else
#define COMMON_SQL_H
#endif // COMMON_SQL_H
#ifdef COMMON_STRLIB_H
{ "StringBuf", sizeof(struct StringBuf), SERVER_TYPE_ALL },
{ "s_svstate", sizeof(struct s_svstate), SERVER_TYPE_ALL },
{ "stringbuf_interface", sizeof(struct stringbuf_interface), SERVER_TYPE_ALL },
{ "strlib_interface", sizeof(struct strlib_interface), SERVER_TYPE_ALL },
{ "sv_interface", sizeof(struct sv_interface), SERVER_TYPE_ALL },
#else
#define COMMON_STRLIB_H
#endif // COMMON_STRLIB_H
#ifdef COMMON_SYSINFO_H
{ "sysinfo_interface", sizeof(struct sysinfo_interface), SERVER_TYPE_ALL },
#else
#define COMMON_SYSINFO_H
#endif // COMMON_SYSINFO_H
#ifdef COMMON_THREAD_H
{ "thread_interface", sizeof(struct thread_interface), SERVER_TYPE_ALL },
#else
#define COMMON_THREAD_H
#endif // COMMON_THREAD_H
#ifdef COMMON_TIMER_H
{ "TimerData", sizeof(struct TimerData), SERVER_TYPE_ALL },
{ "timer_interface", sizeof(struct timer_interface), SERVER_TYPE_ALL },
#else
#define COMMON_TIMER_H
#endif // COMMON_TIMER_H
#ifdef COMMON_UTILS_H
{ "HCache_interface", sizeof(struct HCache_interface), SERVER_TYPE_ALL },
#else
#define COMMON_UTILS_H
#endif // COMMON_UTILS_H
#ifdef LOGIN_ACCOUNT_H
{ "Account_engine", sizeof(struct Account_engine), SERVER_TYPE_LOGIN },
{ "AccountDB", sizeof(struct AccountDB), SERVER_TYPE_LOGIN },
{ "AccountDB_SQL", sizeof(struct AccountDB_SQL), SERVER_TYPE_LOGIN },
{ "AccountDBIterator", sizeof(struct AccountDBIterator), SERVER_TYPE_LOGIN },
{ "AccountDBIterator_SQL", sizeof(struct AccountDBIterator_SQL), SERVER_TYPE_LOGIN },
{ "account_interface", sizeof(struct account_interface), SERVER_TYPE_LOGIN },
{ "mmo_account", sizeof(struct mmo_account), SERVER_TYPE_LOGIN },
#else
#define LOGIN_ACCOUNT_H
#endif // LOGIN_ACCOUNT_H
#ifdef LOGIN_IPBAN_H
{ "ipban_interface", sizeof(struct ipban_interface), SERVER_TYPE_LOGIN },
{ "s_ipban_dbs", sizeof(struct s_ipban_dbs), SERVER_TYPE_LOGIN },
#else
#define LOGIN_IPBAN_H
#endif // LOGIN_IPBAN_H
#ifdef LOGIN_LCLIF_H
{ "lclif_interface", sizeof(struct lclif_interface), SERVER_TYPE_LOGIN },
{ "login_packet_db", sizeof(struct login_packet_db), SERVER_TYPE_LOGIN },
#else
#define LOGIN_LCLIF_H
#endif // LOGIN_LCLIF_H
#ifdef LOGIN_LCLIF_P_H
{ "lclif_interface_dbs", sizeof(struct lclif_interface_dbs), SERVER_TYPE_LOGIN },
{ "lclif_interface_private", sizeof(struct lclif_interface_private), SERVER_TYPE_LOGIN },
{ "packet_AC_ACCEPT_LOGIN", sizeof(struct packet_AC_ACCEPT_LOGIN), SERVER_TYPE_LOGIN },
{ "packet_AC_REFUSE_LOGIN", sizeof(struct packet_AC_REFUSE_LOGIN), SERVER_TYPE_LOGIN },
{ "packet_AC_REFUSE_LOGIN_R2", sizeof(struct packet_AC_REFUSE_LOGIN_R2), SERVER_TYPE_LOGIN },
{ "packet_CA_CHARSERVERCONNECT", sizeof(struct packet_CA_CHARSERVERCONNECT), SERVER_TYPE_LOGIN },
{ "packet_CA_CONNECT_INFO_CHANGED", sizeof(struct packet_CA_CONNECT_INFO_CHANGED), SERVER_TYPE_LOGIN },
{ "packet_CA_EXE_HASHCHECK", sizeof(struct packet_CA_EXE_HASHCHECK), SERVER_TYPE_LOGIN },
{ "packet_CA_LOGIN", sizeof(struct packet_CA_LOGIN), SERVER_TYPE_LOGIN },
{ "packet_CA_LOGIN2", sizeof(struct packet_CA_LOGIN2), SERVER_TYPE_LOGIN },
{ "packet_CA_LOGIN3", sizeof(struct packet_CA_LOGIN3), SERVER_TYPE_LOGIN },
{ "packet_CA_LOGIN4", sizeof(struct packet_CA_LOGIN4), SERVER_TYPE_LOGIN },
{ "packet_CA_LOGIN_HAN", sizeof(struct packet_CA_LOGIN_HAN), SERVER_TYPE_LOGIN },
{ "packet_CA_LOGIN_OTP", sizeof(struct packet_CA_LOGIN_OTP), SERVER_TYPE_LOGIN },
{ "packet_CA_LOGIN_PCBANG", sizeof(struct packet_CA_LOGIN_PCBANG), SERVER_TYPE_LOGIN },
{ "packet_CA_SSO_LOGIN_REQ", sizeof(struct packet_CA_SSO_LOGIN_REQ), SERVER_TYPE_LOGIN },
{ "packet_SC_NOTIFY_BAN", sizeof(struct packet_SC_NOTIFY_BAN), SERVER_TYPE_LOGIN },
#else
#define LOGIN_LCLIF_P_H
#endif // LOGIN_LCLIF_P_H
#ifdef LOGIN_LOGINLOG_H
{ "loginlog_interface", sizeof(struct loginlog_interface), SERVER_TYPE_LOGIN },
{ "s_loginlog_dbs", sizeof(struct s_loginlog_dbs), SERVER_TYPE_LOGIN },
#else
#define LOGIN_LOGINLOG_H
#endif // LOGIN_LOGINLOG_H
#ifdef LOGIN_LOGIN_H
{ "Login_Config", sizeof(struct Login_Config), SERVER_TYPE_LOGIN },
{ "client_hash_node", sizeof(struct client_hash_node), SERVER_TYPE_LOGIN },
{ "lchrif_interface", sizeof(struct lchrif_interface), SERVER_TYPE_LOGIN },
{ "login_auth_node", sizeof(struct login_auth_node), SERVER_TYPE_LOGIN },
{ "login_interface", sizeof(struct login_interface), SERVER_TYPE_LOGIN },
{ "login_session_data", sizeof(struct login_session_data), SERVER_TYPE_LOGIN },
{ "mmo_char_server", sizeof(struct mmo_char_server), SERVER_TYPE_LOGIN },
{ "online_login_data", sizeof(struct online_login_data), SERVER_TYPE_LOGIN },
{ "s_login_dbs", sizeof(struct s_login_dbs), SERVER_TYPE_LOGIN },
#else
#define LOGIN_LOGIN_H
#endif // LOGIN_LOGIN_H
#ifdef MAP_ACHIEVEMENT_H
{ "achievement_data", sizeof(struct achievement_data), SERVER_TYPE_MAP },
{ "achievement_interface", sizeof(struct achievement_interface), SERVER_TYPE_MAP },
{ "achievement_objective", sizeof(struct achievement_objective), SERVER_TYPE_MAP },
{ "achievement_reward_item", sizeof(struct achievement_reward_item), SERVER_TYPE_MAP },
{ "achievement_rewards", sizeof(struct achievement_rewards), SERVER_TYPE_MAP },
#else
#define MAP_ACHIEVEMENT_H
#endif // MAP_ACHIEVEMENT_H
#ifdef MAP_ATCOMMAND_H
{ "AliasInfo", sizeof(struct AliasInfo), SERVER_TYPE_MAP },
{ "AtCommandInfo", sizeof(struct AtCommandInfo), SERVER_TYPE_MAP },
{ "atcmd_binding_data", sizeof(struct atcmd_binding_data), SERVER_TYPE_MAP },
{ "atcommand_interface", sizeof(struct atcommand_interface), SERVER_TYPE_MAP },
#else
#define MAP_ATCOMMAND_H
#endif // MAP_ATCOMMAND_H
#ifdef MAP_BATTLEGROUND_H
{ "battleground_data", sizeof(struct battleground_data), SERVER_TYPE_MAP },
{ "battleground_interface", sizeof(struct battleground_interface), SERVER_TYPE_MAP },
{ "battleground_member_data", sizeof(struct battleground_member_data), SERVER_TYPE_MAP },
{ "bg_arena", sizeof(struct bg_arena), SERVER_TYPE_MAP },
#else
#define MAP_BATTLEGROUND_H
#endif // MAP_BATTLEGROUND_H
#ifdef MAP_BATTLE_H
{ "Battle_Config", sizeof(struct Battle_Config), SERVER_TYPE_MAP },
{ "Damage", sizeof(struct Damage), SERVER_TYPE_MAP },
{ "battle_interface", sizeof(struct battle_interface), SERVER_TYPE_MAP },
{ "delay_damage", sizeof(struct delay_damage), SERVER_TYPE_MAP },
#else
#define MAP_BATTLE_H
#endif // MAP_BATTLE_H
#ifdef MAP_BUYINGSTORE_H
{ "buyingstore_interface", sizeof(struct buyingstore_interface), SERVER_TYPE_MAP },
{ "s_buyingstore", sizeof(struct s_buyingstore), SERVER_TYPE_MAP },
{ "s_buyingstore_item", sizeof(struct s_buyingstore_item), SERVER_TYPE_MAP },
#else
#define MAP_BUYINGSTORE_H
#endif // MAP_BUYINGSTORE_H
#ifdef MAP_CHANNEL_H
{ "Channel_Config", sizeof(struct Channel_Config), SERVER_TYPE_MAP },
{ "channel_ban_entry", sizeof(struct channel_ban_entry), SERVER_TYPE_MAP },
{ "channel_data", sizeof(struct channel_data), SERVER_TYPE_MAP },
{ "channel_interface", sizeof(struct channel_interface), SERVER_TYPE_MAP },
#else
#define MAP_CHANNEL_H
#endif // MAP_CHANNEL_H
#ifdef MAP_CHAT_H
{ "chat_data", sizeof(struct chat_data), SERVER_TYPE_MAP },
{ "chat_interface", sizeof(struct chat_interface), SERVER_TYPE_MAP },
#else
#define MAP_CHAT_H
#endif // MAP_CHAT_H
#ifdef MAP_CHRIF_H
{ "auth_node", sizeof(struct auth_node), SERVER_TYPE_MAP },
{ "chrif_interface", sizeof(struct chrif_interface), SERVER_TYPE_MAP },
#else
#define MAP_CHRIF_H
#endif // MAP_CHRIF_H
#ifdef MAP_CLAN_H
{ "clan_interface", sizeof(struct clan_interface), SERVER_TYPE_MAP },
#else
#define MAP_CLAN_H
#endif // MAP_CLAN_H
#ifdef MAP_CLIF_H
{ "attendance_entry", sizeof(struct attendance_entry), SERVER_TYPE_MAP },
{ "cdelayed_damage", sizeof(struct cdelayed_damage), SERVER_TYPE_MAP },
{ "clif_interface", sizeof(struct clif_interface), SERVER_TYPE_MAP },
{ "hCSData", sizeof(struct hCSData), SERVER_TYPE_MAP },
{ "merge_item", sizeof(struct merge_item), SERVER_TYPE_MAP },
{ "s_packet_db", sizeof(struct s_packet_db), SERVER_TYPE_MAP },
{ "stylist_data_entry", sizeof(struct stylist_data_entry), SERVER_TYPE_MAP },
#else
#define MAP_CLIF_H
#endif // MAP_CLIF_H
#ifdef MAP_DUEL_H
{ "duel", sizeof(struct duel), SERVER_TYPE_MAP },
{ "duel_interface", sizeof(struct duel_interface), SERVER_TYPE_MAP },
#else
#define MAP_DUEL_H
#endif // MAP_DUEL_H
#ifdef MAP_ELEMENTAL_H
{ "elemental_data", sizeof(struct elemental_data), SERVER_TYPE_MAP },
{ "elemental_interface", sizeof(struct elemental_interface), SERVER_TYPE_MAP },
{ "elemental_skill", sizeof(struct elemental_skill), SERVER_TYPE_MAP },
{ "s_elemental_db", sizeof(struct s_elemental_db), SERVER_TYPE_MAP },
#else
#define MAP_ELEMENTAL_H
#endif // MAP_ELEMENTAL_H
#ifdef MAP_GUILD_H
{ "eventlist", sizeof(struct eventlist), SERVER_TYPE_MAP },
{ "guardian_data", sizeof(struct guardian_data), SERVER_TYPE_MAP },
{ "guild_expcache", sizeof(struct guild_expcache), SERVER_TYPE_MAP },
{ "guild_interface", sizeof(struct guild_interface), SERVER_TYPE_MAP },
{ "s_guild_skill_tree", sizeof(struct s_guild_skill_tree), SERVER_TYPE_MAP },
#else
#define MAP_GUILD_H
#endif // MAP_GUILD_H
#ifdef MAP_HOMUNCULUS_H
{ "h_stats", sizeof(struct h_stats), SERVER_TYPE_MAP },
{ "homun_data", sizeof(struct homun_data), SERVER_TYPE_MAP },
{ "homun_dbs", sizeof(struct homun_dbs), SERVER_TYPE_MAP },
{ "homun_skill_tree_entry", sizeof(struct homun_skill_tree_entry), SERVER_TYPE_MAP },
{ "homunculus_interface", sizeof(struct homunculus_interface), SERVER_TYPE_MAP },
{ "s_homunculus_db", sizeof(struct s_homunculus_db), SERVER_TYPE_MAP },
#else
#define MAP_HOMUNCULUS_H
#endif // MAP_HOMUNCULUS_H
#ifdef MAP_INSTANCE_H
{ "instance_data", sizeof(struct instance_data), SERVER_TYPE_MAP },
{ "instance_interface", sizeof(struct instance_interface), SERVER_TYPE_MAP },
#else
#define MAP_INSTANCE_H
#endif // MAP_INSTANCE_H
#ifdef MAP_INTIF_H
{ "intif_interface", sizeof(struct intif_interface), SERVER_TYPE_MAP },
#else
#define MAP_INTIF_H
#endif // MAP_INTIF_H
#ifdef MAP_IRC_BOT_H
{ "irc_bot_interface", sizeof(struct irc_bot_interface), SERVER_TYPE_MAP },
{ "irc_func", sizeof(struct irc_func), SERVER_TYPE_MAP },
{ "message_flood", sizeof(struct message_flood), SERVER_TYPE_MAP },
#else
#define MAP_IRC_BOT_H
#endif // MAP_IRC_BOT_H
#ifdef MAP_ITEMDB_H
{ "item_chain", sizeof(struct item_chain), SERVER_TYPE_MAP },
{ "item_chain_entry", sizeof(struct item_chain_entry), SERVER_TYPE_MAP },
{ "item_combo", sizeof(struct item_combo), SERVER_TYPE_MAP },
{ "item_data", sizeof(struct item_data), SERVER_TYPE_MAP },
{ "item_group", sizeof(struct item_group), SERVER_TYPE_MAP },
{ "item_package", sizeof(struct item_package), SERVER_TYPE_MAP },
{ "item_package_must_entry", sizeof(struct item_package_must_entry), SERVER_TYPE_MAP },
{ "item_package_rand_entry", sizeof(struct item_package_rand_entry), SERVER_TYPE_MAP },
{ "item_package_rand_group", sizeof(struct item_package_rand_group), SERVER_TYPE_MAP },
{ "itemdb_interface", sizeof(struct itemdb_interface), SERVER_TYPE_MAP },
{ "itemdb_option", sizeof(struct itemdb_option), SERVER_TYPE_MAP },
{ "itemlist", sizeof(struct itemlist), SERVER_TYPE_MAP },
{ "itemlist_entry", sizeof(struct itemlist_entry), SERVER_TYPE_MAP },
#else
#define MAP_ITEMDB_H
#endif // MAP_ITEMDB_H
#ifdef MAP_LOG_H
{ "log_interface", sizeof(struct log_interface), SERVER_TYPE_MAP },
#else
#define MAP_LOG_H
#endif // MAP_LOG_H
#ifdef MAP_MAIL_H
{ "mail_interface", sizeof(struct mail_interface), SERVER_TYPE_MAP },
#else
#define MAP_MAIL_H
#endif // MAP_MAIL_H
#ifdef MAP_MAPREG_H
{ "mapreg_interface", sizeof(struct mapreg_interface), SERVER_TYPE_MAP },
{ "mapreg_save", sizeof(struct mapreg_save), SERVER_TYPE_MAP },
#else
#define MAP_MAPREG_H
#endif // MAP_MAPREG_H
#ifdef MAP_MAP_H
{ "block_list", sizeof(struct block_list), SERVER_TYPE_MAP },
{ "charid2nick", sizeof(struct charid2nick), SERVER_TYPE_MAP },
{ "charid_request", sizeof(struct charid_request), SERVER_TYPE_MAP },
{ "flooritem_data", sizeof(struct flooritem_data), SERVER_TYPE_MAP },
{ "iwall_data", sizeof(struct iwall_data), SERVER_TYPE_MAP },
{ "map_cache_header", sizeof(struct map_cache_header), SERVER_TYPE_MAP },
{ "map_data", sizeof(struct map_data), SERVER_TYPE_MAP },
{ "map_data_other_server", sizeof(struct map_data_other_server), SERVER_TYPE_MAP },
{ "map_drop_list", sizeof(struct map_drop_list), SERVER_TYPE_MAP },
{ "map_interface", sizeof(struct map_interface), SERVER_TYPE_MAP },
{ "map_zone_data", sizeof(struct map_zone_data), SERVER_TYPE_MAP },
{ "map_zone_disabled_command_entry", sizeof(struct map_zone_disabled_command_entry), SERVER_TYPE_MAP },
{ "map_zone_disabled_skill_entry", sizeof(struct map_zone_disabled_skill_entry), SERVER_TYPE_MAP },
{ "map_zone_skill_damage_cap_entry", sizeof(struct map_zone_skill_damage_cap_entry), SERVER_TYPE_MAP },
{ "mapcell", sizeof(struct mapcell), SERVER_TYPE_MAP },
{ "mapflag_skill_adjust", sizeof(struct mapflag_skill_adjust), SERVER_TYPE_MAP },
{ "mapit_interface", sizeof(struct mapit_interface), SERVER_TYPE_MAP },
{ "questinfo", sizeof(struct questinfo), SERVER_TYPE_MAP },
{ "questinfo_qreq", sizeof(struct questinfo_qreq), SERVER_TYPE_MAP },
{ "spawn_data", sizeof(struct spawn_data), SERVER_TYPE_MAP },
#else
#define MAP_MAP_H
#endif // MAP_MAP_H
#ifdef MAP_MERCENARY_H
{ "mercenary_data", sizeof(struct mercenary_data), SERVER_TYPE_MAP },
{ "mercenary_interface", sizeof(struct mercenary_interface), SERVER_TYPE_MAP },
{ "s_mercenary_db", sizeof(struct s_mercenary_db), SERVER_TYPE_MAP },
#else
#define MAP_MERCENARY_H
#endif // MAP_MERCENARY_H
#ifdef MAP_MOB_H
{ "item_drop", sizeof(struct item_drop), SERVER_TYPE_MAP },
{ "item_drop_list", sizeof(struct item_drop_list), SERVER_TYPE_MAP },
{ "mob_chat", sizeof(struct mob_chat), SERVER_TYPE_MAP },
{ "mob_data", sizeof(struct mob_data), SERVER_TYPE_MAP },
{ "mob_db", sizeof(struct mob_db), SERVER_TYPE_MAP },
{ "mob_interface", sizeof(struct mob_interface), SERVER_TYPE_MAP },
{ "mob_skill", sizeof(struct mob_skill), SERVER_TYPE_MAP },
{ "spawn_info", sizeof(struct spawn_info), SERVER_TYPE_MAP },
#else
#define MAP_MOB_H
#endif // MAP_MOB_H
#ifdef MAP_NPC_H
{ "event_data", sizeof(struct event_data), SERVER_TYPE_MAP },
{ "npc_chat_interface", sizeof(struct npc_chat_interface), SERVER_TYPE_MAP },
{ "npc_data", sizeof(struct npc_data), SERVER_TYPE_MAP },
{ "npc_interface", sizeof(struct npc_interface), SERVER_TYPE_MAP },
{ "npc_item_list", sizeof(struct npc_item_list), SERVER_TYPE_MAP },
{ "npc_label_list", sizeof(struct npc_label_list), SERVER_TYPE_MAP },
{ "npc_parse", sizeof(struct npc_parse), SERVER_TYPE_MAP },
{ "npc_path_data", sizeof(struct npc_path_data), SERVER_TYPE_MAP },
{ "npc_shop_data", sizeof(struct npc_shop_data), SERVER_TYPE_MAP },
{ "npc_src_list", sizeof(struct npc_src_list), SERVER_TYPE_MAP },
{ "npc_timerevent_list", sizeof(struct npc_timerevent_list), SERVER_TYPE_MAP },
{ "pcre_interface", sizeof(struct pcre_interface), SERVER_TYPE_MAP },
{ "pcrematch_entry", sizeof(struct pcrematch_entry), SERVER_TYPE_MAP },
{ "pcrematch_set", sizeof(struct pcrematch_set), SERVER_TYPE_MAP },
#else
#define MAP_NPC_H
#endif // MAP_NPC_H
#ifdef MAP_PACKETS_STRUCT_H
{ "EQUIPITEM_INFO", sizeof(struct EQUIPITEM_INFO), SERVER_TYPE_MAP },
{ "EQUIPSLOTINFO", sizeof(struct EQUIPSLOTINFO), SERVER_TYPE_MAP },
{ "ItemOptions", sizeof(struct ItemOptions), SERVER_TYPE_MAP },
{ "NORMALITEM_INFO", sizeof(struct NORMALITEM_INFO), SERVER_TYPE_MAP },
{ "PACKET_CZ_ADD_ITEM_TO_MAIL", sizeof(struct PACKET_CZ_ADD_ITEM_TO_MAIL), SERVER_TYPE_MAP },
{ "PACKET_CZ_CHECKNAME", sizeof(struct PACKET_CZ_CHECKNAME), SERVER_TYPE_MAP },
{ "PACKET_CZ_OPEN_UI", sizeof(struct PACKET_CZ_OPEN_UI), SERVER_TYPE_MAP },
{ "PACKET_CZ_PC_BUY_CASH_POINT_ITEM", sizeof(struct PACKET_CZ_PC_BUY_CASH_POINT_ITEM), SERVER_TYPE_MAP },
{ "PACKET_CZ_PC_BUY_CASH_POINT_ITEM_sub", sizeof(struct PACKET_CZ_PC_BUY_CASH_POINT_ITEM_sub), SERVER_TYPE_MAP },
{ "PACKET_CZ_PC_PURCHASE_ITEMLIST", sizeof(struct PACKET_CZ_PC_PURCHASE_ITEMLIST), SERVER_TYPE_MAP },
{ "PACKET_CZ_PC_PURCHASE_ITEMLIST_sub", sizeof(struct PACKET_CZ_PC_PURCHASE_ITEMLIST_sub), SERVER_TYPE_MAP },
{ "PACKET_CZ_PET_EVOLUTION", sizeof(struct PACKET_CZ_PET_EVOLUTION), SERVER_TYPE_MAP },
{ "PACKET_CZ_PRIVATE_AIRSHIP_REQUEST", sizeof(struct PACKET_CZ_PRIVATE_AIRSHIP_REQUEST), SERVER_TYPE_MAP },
{ "PACKET_CZ_REQ_DELETE_MAIL", sizeof(struct PACKET_CZ_REQ_DELETE_MAIL), SERVER_TYPE_MAP },
{ "PACKET_CZ_REQ_ITEM_FROM_MAIL", sizeof(struct PACKET_CZ_REQ_ITEM_FROM_MAIL), SERVER_TYPE_MAP },
{ "PACKET_CZ_REQ_ITEMREPAIR", sizeof(struct PACKET_CZ_REQ_ITEMREPAIR), SERVER_TYPE_MAP },
{ "PACKET_CZ_REQ_MAKINGITEM", sizeof(struct PACKET_CZ_REQ_MAKINGITEM), SERVER_TYPE_MAP },
{ "PACKET_CZ_REQ_NEXT_MAIL_LIST", sizeof(struct PACKET_CZ_REQ_NEXT_MAIL_LIST), SERVER_TYPE_MAP },
{ "PACKET_CZ_REQ_OPEN_BUYING_STORE", sizeof(struct PACKET_CZ_REQ_OPEN_BUYING_STORE), SERVER_TYPE_MAP },
{ "PACKET_CZ_REQ_OPEN_BUYING_STORE_sub", sizeof(struct PACKET_CZ_REQ_OPEN_BUYING_STORE_sub), SERVER_TYPE_MAP },
{ "PACKET_CZ_REQ_OPEN_MAIL", sizeof(struct PACKET_CZ_REQ_OPEN_MAIL), SERVER_TYPE_MAP },
{ "PACKET_CZ_REQ_OPEN_WRITE_MAIL", sizeof(struct PACKET_CZ_REQ_OPEN_WRITE_MAIL), SERVER_TYPE_MAP },
{ "PACKET_CZ_REQ_READ_MAIL", sizeof(struct PACKET_CZ_REQ_READ_MAIL), SERVER_TYPE_MAP },
{ "PACKET_CZ_REQ_REFRESH_MAIL_LIST", sizeof(struct PACKET_CZ_REQ_REFRESH_MAIL_LIST), SERVER_TYPE_MAP },
{ "PACKET_CZ_REQ_REMOVE_ITEM_MAIL", sizeof(struct PACKET_CZ_REQ_REMOVE_ITEM_MAIL), SERVER_TYPE_MAP },
{ "PACKET_CZ_REQ_STYLE_CHANGE", sizeof(struct PACKET_CZ_REQ_STYLE_CHANGE), SERVER_TYPE_MAP },
{ "PACKET_CZ_REQ_STYLE_CHANGE2", sizeof(struct PACKET_CZ_REQ_STYLE_CHANGE2), SERVER_TYPE_MAP },
{ "PACKET_CZ_REQ_TRADE_BUYING_STORE", sizeof(struct PACKET_CZ_REQ_TRADE_BUYING_STORE), SERVER_TYPE_MAP },
{ "PACKET_CZ_REQ_TRADE_BUYING_STORE_sub", sizeof(struct PACKET_CZ_REQ_TRADE_BUYING_STORE_sub), SERVER_TYPE_MAP },
{ "PACKET_CZ_REQ_ZENY_FROM_MAIL", sizeof(struct PACKET_CZ_REQ_ZENY_FROM_MAIL), SERVER_TYPE_MAP },
{ "PACKET_CZ_REQMAKINGITEM", sizeof(struct PACKET_CZ_REQMAKINGITEM), SERVER_TYPE_MAP },
{ "PACKET_CZ_SEARCH_STORE_INFO", sizeof(struct PACKET_CZ_SEARCH_STORE_INFO), SERVER_TYPE_MAP },
{ "PACKET_CZ_SEARCH_STORE_INFO_item", sizeof(struct PACKET_CZ_SEARCH_STORE_INFO_item), SERVER_TYPE_MAP },
{ "PACKET_CZ_SEND_MAIL", sizeof(struct PACKET_CZ_SEND_MAIL), SERVER_TYPE_MAP },
{ "PACKET_CZ_SSILIST_ITEM_CLICK", sizeof(struct PACKET_CZ_SSILIST_ITEM_CLICK), SERVER_TYPE_MAP },
{ "PACKET_ZC_ACK_BAN_GUILD1", sizeof(struct PACKET_ZC_ACK_BAN_GUILD1), SERVER_TYPE_MAP },
{ "PACKET_ZC_ACK_BAN_GUILD2", sizeof(struct PACKET_ZC_ACK_BAN_GUILD2), SERVER_TYPE_MAP },
{ "PACKET_ZC_ACK_BAN_GUILD3", sizeof(struct PACKET_ZC_ACK_BAN_GUILD3), SERVER_TYPE_MAP },
{ "PACKET_ZC_ACK_CLAN_LEAVE", sizeof(struct PACKET_ZC_ACK_CLAN_LEAVE), SERVER_TYPE_MAP },
{ "PACKET_ZC_ACK_DELETE_MAIL", sizeof(struct PACKET_ZC_ACK_DELETE_MAIL), SERVER_TYPE_MAP },
{ "PACKET_ZC_ACK_ITEM_FROM_MAIL", sizeof(struct PACKET_ZC_ACK_ITEM_FROM_MAIL), SERVER_TYPE_MAP },
{ "PACKET_ZC_ACK_ITEMLIST_BUYING_STORE", sizeof(struct PACKET_ZC_ACK_ITEMLIST_BUYING_STORE), SERVER_TYPE_MAP },
{ "PACKET_ZC_ACK_ITEMLIST_BUYING_STORE_sub", sizeof(struct PACKET_ZC_ACK_ITEMLIST_BUYING_STORE_sub), SERVER_TYPE_MAP },
{ "PACKET_ZC_ACK_LEAVE_GUILD1", sizeof(struct PACKET_ZC_ACK_LEAVE_GUILD1), SERVER_TYPE_MAP },
{ "PACKET_ZC_ACK_LEAVE_GUILD2", sizeof(struct PACKET_ZC_ACK_LEAVE_GUILD2), SERVER_TYPE_MAP },
{ "PACKET_ZC_ACK_OPEN_WRITE_MAIL", sizeof(struct PACKET_ZC_ACK_OPEN_WRITE_MAIL), SERVER_TYPE_MAP },
{ "PACKET_ZC_ACK_REMOVE_ITEM_MAIL", sizeof(struct PACKET_ZC_ACK_REMOVE_ITEM_MAIL), SERVER_TYPE_MAP },
{ "PACKET_ZC_ACK_REQMAKINGITEM", sizeof(struct PACKET_ZC_ACK_REQMAKINGITEM), SERVER_TYPE_MAP },
{ "PACKET_ZC_ACK_SCHEDULER_CASHITEM", sizeof(struct PACKET_ZC_ACK_SCHEDULER_CASHITEM), SERVER_TYPE_MAP },
{ "PACKET_ZC_ACK_SCHEDULER_CASHITEM_sub", sizeof(struct PACKET_ZC_ACK_SCHEDULER_CASHITEM_sub), SERVER_TYPE_MAP },
{ "PACKET_ZC_ACK_TOUSESKILL", sizeof(struct PACKET_ZC_ACK_TOUSESKILL), SERVER_TYPE_MAP },
{ "PACKET_ZC_ACK_WEAPONREFINE", sizeof(struct PACKET_ZC_ACK_WEAPONREFINE), SERVER_TYPE_MAP },
{ "PACKET_ZC_ACK_ZENY_FROM_MAIL", sizeof(struct PACKET_ZC_ACK_ZENY_FROM_MAIL), SERVER_TYPE_MAP },
{ "PACKET_ZC_ADD_EXCHANGE_ITEM", sizeof(struct PACKET_ZC_ADD_EXCHANGE_ITEM), SERVER_TYPE_MAP },
{ "PACKET_ZC_ADD_ITEM_TO_CART", sizeof(struct PACKET_ZC_ADD_ITEM_TO_CART), SERVER_TYPE_MAP },
{ "PACKET_ZC_ADD_ITEM_TO_MAIL", sizeof(struct PACKET_ZC_ADD_ITEM_TO_MAIL), SERVER_TYPE_MAP },
{ "PACKET_ZC_ADD_ITEM_TO_STORE", sizeof(struct PACKET_ZC_ADD_ITEM_TO_STORE), SERVER_TYPE_MAP },
{ "PACKET_ZC_ADD_MEMBER_TO_GROUP", sizeof(struct PACKET_ZC_ADD_MEMBER_TO_GROUP), SERVER_TYPE_MAP },
{ "PACKET_ZC_CASH_ITEM_DELETE", sizeof(struct PACKET_ZC_CASH_ITEM_DELETE), SERVER_TYPE_MAP },
{ "PACKET_ZC_CASH_TIME_COUNTER", sizeof(struct PACKET_ZC_CASH_TIME_COUNTER), SERVER_TYPE_MAP },
{ "PACKET_ZC_CHECKNAME", sizeof(struct PACKET_ZC_CHECKNAME), SERVER_TYPE_MAP },
{ "PACKET_ZC_CLANINFO", sizeof(struct PACKET_ZC_CLANINFO), SERVER_TYPE_MAP },
{ "PACKET_ZC_FAILED_TRADE_BUYING_STORE_TO_SELLER", sizeof(struct PACKET_ZC_FAILED_TRADE_BUYING_STORE_TO_SELLER), SERVER_TYPE_MAP },
{ "PACKET_ZC_FEED_MER", sizeof(struct PACKET_ZC_FEED_MER), SERVER_TYPE_MAP },
{ "PACKET_ZC_FEED_PET", sizeof(struct PACKET_ZC_FEED_PET), SERVER_TYPE_MAP },
{ "PACKET_ZC_FORMATSTRING_MSG", sizeof(struct PACKET_ZC_FORMATSTRING_MSG), SERVER_TYPE_MAP },
{ "PACKET_ZC_FORMATSTRING_MSG_COLOR", sizeof(struct PACKET_ZC_FORMATSTRING_MSG_COLOR), SERVER_TYPE_MAP },
{ "PACKET_ZC_GROUP_ISALIVE", sizeof(struct PACKET_ZC_GROUP_ISALIVE), SERVER_TYPE_MAP },
{ "PACKET_ZC_GROUP_LIST", sizeof(struct PACKET_ZC_GROUP_LIST), SERVER_TYPE_MAP },
{ "PACKET_ZC_GROUP_LIST_SUB", sizeof(struct PACKET_ZC_GROUP_LIST_SUB), SERVER_TYPE_MAP },
{ "PACKET_ZC_GUILD_POSITION", sizeof(struct PACKET_ZC_GUILD_POSITION), SERVER_TYPE_MAP },
{ "PACKET_ZC_INVENTORY_MOVE_FAILED", sizeof(struct PACKET_ZC_INVENTORY_MOVE_FAILED), SERVER_TYPE_MAP },
{ "PACKET_ZC_ITEM_ENTRY", sizeof(struct PACKET_ZC_ITEM_ENTRY), SERVER_TYPE_MAP },
{ "PACKET_ZC_ITEM_PICKUP_PARTY", sizeof(struct PACKET_ZC_ITEM_PICKUP_PARTY), SERVER_TYPE_MAP },
{ "PACKET_ZC_MAIL_LIST", sizeof(struct PACKET_ZC_MAIL_LIST), SERVER_TYPE_MAP },
{ "PACKET_ZC_MAKABLEITEMLIST", sizeof(struct PACKET_ZC_MAKABLEITEMLIST), SERVER_TYPE_MAP },
{ "PACKET_ZC_MAKABLEITEMLIST_sub", sizeof(struct PACKET_ZC_MAKABLEITEMLIST_sub), SERVER_TYPE_MAP },
{ "PACKET_ZC_MAKINGARROW_LIST", sizeof(struct PACKET_ZC_MAKINGARROW_LIST), SERVER_TYPE_MAP },
{ "PACKET_ZC_MAKINGARROW_LIST_sub", sizeof(struct PACKET_ZC_MAKINGARROW_LIST_sub), SERVER_TYPE_MAP },
{ "PACKET_ZC_MAKINGITEM_LIST", sizeof(struct PACKET_ZC_MAKINGITEM_LIST), SERVER_TYPE_MAP },
{ "PACKET_ZC_MAKINGITEM_LIST_sub", sizeof(struct PACKET_ZC_MAKINGITEM_LIST_sub), SERVER_TYPE_MAP },
{ "PACKET_ZC_MSG_COLOR", sizeof(struct PACKET_ZC_MSG_COLOR), SERVER_TYPE_MAP },
{ "PACKET_ZC_MVP_GETTING_ITEM", sizeof(struct PACKET_ZC_MVP_GETTING_ITEM), SERVER_TYPE_MAP },
{ "PACKET_ZC_MYITEMLIST_BUYING_STORE", sizeof(struct PACKET_ZC_MYITEMLIST_BUYING_STORE), SERVER_TYPE_MAP },
{ "PACKET_ZC_MYITEMLIST_BUYING_STORE_sub", sizeof(struct PACKET_ZC_MYITEMLIST_BUYING_STORE_sub), SERVER_TYPE_MAP },
{ "PACKET_ZC_NOTIFY_CHAT", sizeof(struct PACKET_ZC_NOTIFY_CHAT), SERVER_TYPE_MAP },
{ "PACKET_ZC_NOTIFY_CLAN_CHAT", sizeof(struct PACKET_ZC_NOTIFY_CLAN_CHAT), SERVER_TYPE_MAP },
{ "PACKET_ZC_NOTIFY_CLAN_CONNECTINFO", sizeof(struct PACKET_ZC_NOTIFY_CLAN_CONNECTINFO), SERVER_TYPE_MAP },
{ "PACKET_ZC_NOTIFY_PLAYERCHAT", sizeof(struct PACKET_ZC_NOTIFY_PLAYERCHAT), SERVER_TYPE_MAP },
{ "PACKET_ZC_NOTIFY_UNREADMAIL", sizeof(struct PACKET_ZC_NOTIFY_UNREADMAIL), SERVER_TYPE_MAP },
{ "PACKET_ZC_NOTIFY_WEAPONITEMLIST", sizeof(struct PACKET_ZC_NOTIFY_WEAPONITEMLIST), SERVER_TYPE_MAP },
{ "PACKET_ZC_NOTIFY_WEAPONITEMLIST_sub", sizeof(struct PACKET_ZC_NOTIFY_WEAPONITEMLIST_sub), SERVER_TYPE_MAP },
{ "PACKET_ZC_OPEN_UI", sizeof(struct PACKET_ZC_OPEN_UI), SERVER_TYPE_MAP },
{ "PACKET_ZC_OVERWEIGHT_PERCENT", sizeof(struct PACKET_ZC_OVERWEIGHT_PERCENT), SERVER_TYPE_MAP },
{ "PACKET_ZC_PC_CASH_POINT_ITEMLIST", sizeof(struct PACKET_ZC_PC_CASH_POINT_ITEMLIST), SERVER_TYPE_MAP },
{ "PACKET_ZC_PC_CASH_POINT_ITEMLIST_sub", sizeof(struct PACKET_ZC_PC_CASH_POINT_ITEMLIST_sub), SERVER_TYPE_MAP },
{ "PACKET_ZC_PC_PURCHASE_ITEMLIST", sizeof(struct PACKET_ZC_PC_PURCHASE_ITEMLIST), SERVER_TYPE_MAP },
{ "PACKET_ZC_PC_PURCHASE_ITEMLIST_FROMMC", sizeof(struct PACKET_ZC_PC_PURCHASE_ITEMLIST_FROMMC), SERVER_TYPE_MAP },
{ "PACKET_ZC_PC_PURCHASE_ITEMLIST_FROMMC_sub", sizeof(struct PACKET_ZC_PC_PURCHASE_ITEMLIST_FROMMC_sub), SERVER_TYPE_MAP },
{ "PACKET_ZC_PC_PURCHASE_ITEMLIST_sub", sizeof(struct PACKET_ZC_PC_PURCHASE_ITEMLIST_sub), SERVER_TYPE_MAP },
{ "PACKET_ZC_PC_PURCHASE_MYITEMLIST", sizeof(struct PACKET_ZC_PC_PURCHASE_MYITEMLIST), SERVER_TYPE_MAP },
{ "PACKET_ZC_PC_PURCHASE_MYITEMLIST_sub", sizeof(struct PACKET_ZC_PC_PURCHASE_MYITEMLIST_sub), SERVER_TYPE_MAP },
{ "PACKET_ZC_PRIVATE_AIRSHIP_RESPONSE", sizeof(struct PACKET_ZC_PRIVATE_AIRSHIP_RESPONSE), SERVER_TYPE_MAP },
{ "PACKET_ZC_PROPERTY_HOMUN", sizeof(struct PACKET_ZC_PROPERTY_HOMUN), SERVER_TYPE_MAP },
{ "PACKET_ZC_READ_MAIL", sizeof(struct PACKET_ZC_READ_MAIL), SERVER_TYPE_MAP },
{ "PACKET_ZC_REPAIRITEMLIST", sizeof(struct PACKET_ZC_REPAIRITEMLIST), SERVER_TYPE_MAP },
{ "PACKET_ZC_REPAIRITEMLIST_sub", sizeof(struct PACKET_ZC_REPAIRITEMLIST_sub), SERVER_TYPE_MAP },
{ "PACKET_ZC_SEARCH_STORE_INFO_ACK", sizeof(struct PACKET_ZC_SEARCH_STORE_INFO_ACK), SERVER_TYPE_MAP },
{ "PACKET_ZC_SEARCH_STORE_INFO_ACK_sub", sizeof(struct PACKET_ZC_SEARCH_STORE_INFO_ACK_sub), SERVER_TYPE_MAP },
{ "PACKET_ZC_SKILL_SCALE", sizeof(struct PACKET_ZC_SKILL_SCALE), SERVER_TYPE_MAP },
{ "PACKET_ZC_SPRITE_CHANGE", sizeof(struct PACKET_ZC_SPRITE_CHANGE), SERVER_TYPE_MAP },
{ "PACKET_ZC_STYLE_CHANGE_RES", sizeof(struct PACKET_ZC_STYLE_CHANGE_RES), SERVER_TYPE_MAP },
{ "PACKET_ZC_UI_ACTION", sizeof(struct PACKET_ZC_UI_ACTION), SERVER_TYPE_MAP },
{ "PACKET_ZC_UPDATE_ITEM_FROM_BUYING_STORE", sizeof(struct PACKET_ZC_UPDATE_ITEM_FROM_BUYING_STORE), SERVER_TYPE_MAP },
{ "PACKET_ZC_USE_ITEM_ACK", sizeof(struct PACKET_ZC_USE_ITEM_ACK), SERVER_TYPE_MAP },
{ "PACKET_ZC_WARPLIST", sizeof(struct PACKET_ZC_WARPLIST), SERVER_TYPE_MAP },
{ "PACKET_ZC_WARPLIST_sub", sizeof(struct PACKET_ZC_WARPLIST_sub), SERVER_TYPE_MAP },
{ "PACKET_ZC_WRITE_MAIL_RESULT", sizeof(struct PACKET_ZC_WRITE_MAIL_RESULT), SERVER_TYPE_MAP },
{ "ZC_INVENTORY_END", sizeof(struct ZC_INVENTORY_END), SERVER_TYPE_MAP },
{ "ZC_INVENTORY_START", sizeof(struct ZC_INVENTORY_START), SERVER_TYPE_MAP },
{ "ZC_PROGRESS_ACTOR", sizeof(struct ZC_PROGRESS_ACTOR), SERVER_TYPE_MAP },
{ "ZC_STORE_ITEMLIST_EQUIP", sizeof(struct ZC_STORE_ITEMLIST_EQUIP), SERVER_TYPE_MAP },
{ "ZC_STORE_ITEMLIST_NORMAL", sizeof(struct ZC_STORE_ITEMLIST_NORMAL), SERVER_TYPE_MAP },
{ "ach_list_info", sizeof(struct ach_list_info), SERVER_TYPE_MAP },
{ "mail_item", sizeof(struct mail_item), SERVER_TYPE_MAP },
{ "maillistinfo", sizeof(struct maillistinfo), SERVER_TYPE_MAP },
{ "packet_ZC_REFUSE_LOGIN", sizeof(struct packet_ZC_REFUSE_LOGIN), SERVER_TYPE_MAP },
{ "packet_achievement_list", sizeof(struct packet_achievement_list), SERVER_TYPE_MAP },
{ "packet_achievement_reward_ack", sizeof(struct packet_achievement_reward_ack), SERVER_TYPE_MAP },
{ "packet_achievement_update", sizeof(struct packet_achievement_update), SERVER_TYPE_MAP },
{ "packet_additem", sizeof(struct packet_additem), SERVER_TYPE_MAP },
{ "packet_authok", sizeof(struct packet_authok), SERVER_TYPE_MAP },
{ "packet_banking_check", sizeof(struct packet_banking_check), SERVER_TYPE_MAP },
{ "packet_banking_deposit_ack", sizeof(struct packet_banking_deposit_ack), SERVER_TYPE_MAP },
{ "packet_banking_deposit_req", sizeof(struct packet_banking_deposit_req), SERVER_TYPE_MAP },
{ "packet_banking_withdraw_ack", sizeof(struct packet_banking_withdraw_ack), SERVER_TYPE_MAP },
{ "packet_banking_withdraw_req", sizeof(struct packet_banking_withdraw_req), SERVER_TYPE_MAP },
{ "packet_bgqueue_ack", sizeof(struct packet_bgqueue_ack), SERVER_TYPE_MAP },
{ "packet_bgqueue_battlebegin_ack", sizeof(struct packet_bgqueue_battlebegin_ack), SERVER_TYPE_MAP },
{ "packet_bgqueue_battlebegins", sizeof(struct packet_bgqueue_battlebegins), SERVER_TYPE_MAP },
{ "packet_bgqueue_checkstate", sizeof(struct packet_bgqueue_checkstate), SERVER_TYPE_MAP },
{ "packet_bgqueue_notice_delete", sizeof(struct packet_bgqueue_notice_delete), SERVER_TYPE_MAP },
{ "packet_bgqueue_notify_entry", sizeof(struct packet_bgqueue_notify_entry), SERVER_TYPE_MAP },
{ "packet_bgqueue_register", sizeof(struct packet_bgqueue_register), SERVER_TYPE_MAP },
{ "packet_bgqueue_revoke_req", sizeof(struct packet_bgqueue_revoke_req), SERVER_TYPE_MAP },
{ "packet_bgqueue_update_info", sizeof(struct packet_bgqueue_update_info), SERVER_TYPE_MAP },
{ "packet_cart_additem_ack", sizeof(struct packet_cart_additem_ack), SERVER_TYPE_MAP },
{ "packet_chat_message", sizeof(struct packet_chat_message), SERVER_TYPE_MAP },
{ "packet_damage", sizeof(struct packet_damage), SERVER_TYPE_MAP },
{ "packet_dropflooritem", sizeof(struct packet_dropflooritem), SERVER_TYPE_MAP },
{ "packet_equip_item", sizeof(struct packet_equip_item), SERVER_TYPE_MAP },
{ "packet_equipitem_ack", sizeof(struct packet_equipitem_ack), SERVER_TYPE_MAP },
{ "packet_gm_monster_item", sizeof(struct packet_gm_monster_item), SERVER_TYPE_MAP },
{ "packet_graffiti_entry", sizeof(struct packet_graffiti_entry), SERVER_TYPE_MAP },
{ "packet_hotkey", sizeof(struct packet_hotkey), SERVER_TYPE_MAP },
{ "packet_idle_unit", sizeof(struct packet_idle_unit), SERVER_TYPE_MAP },
{ "packet_idle_unit2", sizeof(struct packet_idle_unit2), SERVER_TYPE_MAP },
{ "packet_item_drop_announce", sizeof(struct packet_item_drop_announce), SERVER_TYPE_MAP },
{ "packet_itemlist_equip", sizeof(struct packet_itemlist_equip), SERVER_TYPE_MAP },
{ "packet_itemlist_normal", sizeof(struct packet_itemlist_normal), SERVER_TYPE_MAP },
{ "packet_maptypeproperty2", sizeof(struct packet_maptypeproperty2), SERVER_TYPE_MAP },
{ "packet_mission_info_sub", sizeof(struct packet_mission_info_sub), SERVER_TYPE_MAP },
{ "packet_monster_hp", sizeof(struct packet_monster_hp), SERVER_TYPE_MAP },
{ "packet_notify_bounditem", sizeof(struct packet_notify_bounditem), SERVER_TYPE_MAP },
{ "packet_npc_market_open", sizeof(struct packet_npc_market_open), SERVER_TYPE_MAP },
{ "packet_npc_market_purchase", sizeof(struct packet_npc_market_purchase), SERVER_TYPE_MAP },
{ "packet_npc_market_result_ack", sizeof(struct packet_npc_market_result_ack), SERVER_TYPE_MAP },
{ "packet_package_item_announce", sizeof(struct packet_package_item_announce), SERVER_TYPE_MAP },
{ "packet_party_leader_changed", sizeof(struct packet_party_leader_changed), SERVER_TYPE_MAP },
{ "packet_quest_add_header", sizeof(struct packet_quest_add_header), SERVER_TYPE_MAP },
{ "packet_quest_hunt_info", sizeof(struct packet_quest_hunt_info), SERVER_TYPE_MAP },
{ "packet_quest_hunt_info_sub", sizeof(struct packet_quest_hunt_info_sub), SERVER_TYPE_MAP },
{ "packet_quest_hunt_sub", sizeof(struct packet_quest_hunt_sub), SERVER_TYPE_MAP },
{ "packet_quest_list_header", sizeof(struct packet_quest_list_header), SERVER_TYPE_MAP },
{ "packet_quest_list_info", sizeof(struct packet_quest_list_info), SERVER_TYPE_MAP },
{ "packet_quest_update_header", sizeof(struct packet_quest_update_header), SERVER_TYPE_MAP },
{ "packet_quest_update_hunt", sizeof(struct packet_quest_update_hunt), SERVER_TYPE_MAP },
{ "packet_reqname_ack", sizeof(struct packet_reqname_ack), SERVER_TYPE_MAP },
{ "packet_reqnameall_ack", sizeof(struct packet_reqnameall_ack), SERVER_TYPE_MAP },
{ "packet_roulette_close_ack", sizeof(struct packet_roulette_close_ack), SERVER_TYPE_MAP },
{ "packet_roulette_generate_ack", sizeof(struct packet_roulette_generate_ack), SERVER_TYPE_MAP },
{ "packet_roulette_info_ack", sizeof(struct packet_roulette_info_ack), SERVER_TYPE_MAP },
{ "packet_roulette_itemrecv_ack", sizeof(struct packet_roulette_itemrecv_ack), SERVER_TYPE_MAP },
{ "packet_roulette_itemrecv_req", sizeof(struct packet_roulette_itemrecv_req), SERVER_TYPE_MAP },
{ "packet_roulette_open_ack", sizeof(struct packet_roulette_open_ack), SERVER_TYPE_MAP },
{ "packet_sc_notick", sizeof(struct packet_sc_notick), SERVER_TYPE_MAP },
{ "packet_script_clear", sizeof(struct packet_script_clear), SERVER_TYPE_MAP },
{ "packet_skill_entry", sizeof(struct packet_skill_entry), SERVER_TYPE_MAP },
{ "packet_spawn_unit", sizeof(struct packet_spawn_unit), SERVER_TYPE_MAP },
{ "packet_spawn_unit2", sizeof(struct packet_spawn_unit2), SERVER_TYPE_MAP },
{ "packet_status_change", sizeof(struct packet_status_change), SERVER_TYPE_MAP },
{ "packet_status_change2", sizeof(struct packet_status_change2), SERVER_TYPE_MAP },
{ "packet_status_change_end", sizeof(struct packet_status_change_end), SERVER_TYPE_MAP },
{ "packet_unequipitem_ack", sizeof(struct packet_unequipitem_ack), SERVER_TYPE_MAP },
{ "packet_unit_walking", sizeof(struct packet_unit_walking), SERVER_TYPE_MAP },
{ "packet_viewequip_ack", sizeof(struct packet_viewequip_ack), SERVER_TYPE_MAP },
{ "packet_whisper_message", sizeof(struct packet_whisper_message), SERVER_TYPE_MAP },
{ "packet_wis_end", sizeof(struct packet_wis_end), SERVER_TYPE_MAP },
{ "pet_evolution_items", sizeof(struct pet_evolution_items), SERVER_TYPE_MAP },
#else
#define MAP_PACKETS_STRUCT_H
#endif // MAP_PACKETS_STRUCT_H
#ifdef MAP_PARTY_H
{ "party_booking_ad_info", sizeof(struct party_booking_ad_info), SERVER_TYPE_MAP },
{ "party_booking_detail", sizeof(struct party_booking_detail), SERVER_TYPE_MAP },
{ "party_data", sizeof(struct party_data), SERVER_TYPE_MAP },
{ "party_interface", sizeof(struct party_interface), SERVER_TYPE_MAP },
{ "party_member_data", sizeof(struct party_member_data), SERVER_TYPE_MAP },
#else
#define MAP_PARTY_H
#endif // MAP_PARTY_H
#ifdef MAP_PATH_H
{ "path_interface", sizeof(struct path_interface), SERVER_TYPE_MAP },
{ "shootpath_data", sizeof(struct shootpath_data), SERVER_TYPE_MAP },
{ "walkpath_data", sizeof(struct walkpath_data), SERVER_TYPE_MAP },
#else
#define MAP_PATH_H
#endif // MAP_PATH_H
#ifdef MAP_PC_GROUPS_H
{ "GroupSettings", sizeof(struct GroupSettings), SERVER_TYPE_MAP },
{ "pc_groups_interface", sizeof(struct pc_groups_interface), SERVER_TYPE_MAP },
{ "pc_groups_new_permission", sizeof(struct pc_groups_new_permission), SERVER_TYPE_MAP },
{ "pc_groups_permission_table", sizeof(struct pc_groups_permission_table), SERVER_TYPE_MAP },
#else
#define MAP_PC_GROUPS_H
#endif // MAP_PC_GROUPS_H
#ifdef MAP_PC_H
{ "autotrade_vending", sizeof(struct autotrade_vending), SERVER_TYPE_MAP },
{ "class_exp_group", sizeof(struct class_exp_group), SERVER_TYPE_MAP },
{ "class_exp_tables", sizeof(struct class_exp_tables), SERVER_TYPE_MAP },
{ "item_cd", sizeof(struct item_cd), SERVER_TYPE_MAP },
{ "map_session_data", sizeof(struct map_session_data), SERVER_TYPE_MAP },
{ "pc_combos", sizeof(struct pc_combos), SERVER_TYPE_MAP },
{ "pc_interface", sizeof(struct pc_interface), SERVER_TYPE_MAP },
{ "s_add_drop", sizeof(struct s_add_drop), SERVER_TYPE_MAP },
{ "s_addeffect", sizeof(struct s_addeffect), SERVER_TYPE_MAP },
{ "s_addeffectonskill", sizeof(struct s_addeffectonskill), SERVER_TYPE_MAP },
{ "s_autobonus", sizeof(struct s_autobonus), SERVER_TYPE_MAP },
{ "s_autospell", sizeof(struct s_autospell), SERVER_TYPE_MAP },
{ "sg_data", sizeof(struct sg_data), SERVER_TYPE_MAP },
{ "skill_tree_entry", sizeof(struct skill_tree_entry), SERVER_TYPE_MAP },
{ "skill_tree_requirement", sizeof(struct skill_tree_requirement), SERVER_TYPE_MAP },
{ "weapon_data", sizeof(struct weapon_data), SERVER_TYPE_MAP },
#else
#define MAP_PC_H
#endif // MAP_PC_H
#ifdef MAP_PET_H
{ "pet_bonus", sizeof(struct pet_bonus), SERVER_TYPE_MAP },
{ "pet_data", sizeof(struct pet_data), SERVER_TYPE_MAP },
{ "pet_evolve_data", sizeof(struct pet_evolve_data), SERVER_TYPE_MAP },
{ "pet_interface", sizeof(struct pet_interface), SERVER_TYPE_MAP },
{ "pet_loot", sizeof(struct pet_loot), SERVER_TYPE_MAP },
{ "pet_recovery", sizeof(struct pet_recovery), SERVER_TYPE_MAP },
{ "pet_skill_attack", sizeof(struct pet_skill_attack), SERVER_TYPE_MAP },
{ "pet_skill_support", sizeof(struct pet_skill_support), SERVER_TYPE_MAP },
{ "s_pet_db", sizeof(struct s_pet_db), SERVER_TYPE_MAP },
#else
#define MAP_PET_H
#endif // MAP_PET_H
#ifdef MAP_QUEST_H
{ "quest_db", sizeof(struct quest_db), SERVER_TYPE_MAP },
{ "quest_dropitem", sizeof(struct quest_dropitem), SERVER_TYPE_MAP },
{ "quest_interface", sizeof(struct quest_interface), SERVER_TYPE_MAP },
{ "quest_objective", sizeof(struct quest_objective), SERVER_TYPE_MAP },
#else
#define MAP_QUEST_H
#endif // MAP_QUEST_H
#ifdef MAP_RODEX_H
{ "rodex_interface", sizeof(struct rodex_interface), SERVER_TYPE_MAP },
#else
#define MAP_RODEX_H
#endif // MAP_RODEX_H
#ifdef MAP_SCRIPT_H
{ "Script_Config", sizeof(struct Script_Config), SERVER_TYPE_MAP },
{ "casecheck_data", sizeof(struct casecheck_data), SERVER_TYPE_MAP },
{ "reg_db", sizeof(struct reg_db), SERVER_TYPE_MAP },
{ "script_array", sizeof(struct script_array), SERVER_TYPE_MAP },
{ "script_buf", sizeof(struct script_buf), SERVER_TYPE_MAP },
{ "script_code", sizeof(struct script_code), SERVER_TYPE_MAP },
{ "script_data", sizeof(struct script_data), SERVER_TYPE_MAP },
{ "script_function", sizeof(struct script_function), SERVER_TYPE_MAP },
{ "script_interface", sizeof(struct script_interface), SERVER_TYPE_MAP },
{ "script_label_entry", sizeof(struct script_label_entry), SERVER_TYPE_MAP },
{ "script_queue", sizeof(struct script_queue), SERVER_TYPE_MAP },
{ "script_queue_iterator", sizeof(struct script_queue_iterator), SERVER_TYPE_MAP },
{ "script_retinfo", sizeof(struct script_retinfo), SERVER_TYPE_MAP },
{ "script_stack", sizeof(struct script_stack), SERVER_TYPE_MAP },
{ "script_state", sizeof(struct script_state), SERVER_TYPE_MAP },
{ "script_string_buf", sizeof(struct script_string_buf), SERVER_TYPE_MAP },
{ "script_syntax_data", sizeof(struct script_syntax_data), SERVER_TYPE_MAP },
{ "str_data_struct", sizeof(struct str_data_struct), SERVER_TYPE_MAP },
{ "string_translation", sizeof(struct string_translation), SERVER_TYPE_MAP },
{ "string_translation_entry", sizeof(struct string_translation_entry), SERVER_TYPE_MAP },
#else
#define MAP_SCRIPT_H
#endif // MAP_SCRIPT_H
#ifdef MAP_SEARCHSTORE_H
{ "s_search_store_info", sizeof(struct s_search_store_info), SERVER_TYPE_MAP },
{ "s_search_store_info_item", sizeof(struct s_search_store_info_item), SERVER_TYPE_MAP },
{ "searchstore_interface", sizeof(struct searchstore_interface), SERVER_TYPE_MAP },
#else
#define MAP_SEARCHSTORE_H
#endif // MAP_SEARCHSTORE_H
#ifdef MAP_SKILL_H
{ "s_skill_abra_db", sizeof(struct s_skill_abra_db), SERVER_TYPE_MAP },
{ "s_skill_arrow_db", sizeof(struct s_skill_arrow_db), SERVER_TYPE_MAP },
{ "s_skill_changematerial_db", sizeof(struct s_skill_changematerial_db), SERVER_TYPE_MAP },
{ "s_skill_db", sizeof(struct s_skill_db), SERVER_TYPE_MAP },
{ "s_skill_dbs", sizeof(struct s_skill_dbs), SERVER_TYPE_MAP },
{ "s_skill_improvise_db", sizeof(struct s_skill_improvise_db), SERVER_TYPE_MAP },
{ "s_skill_magicmushroom_db", sizeof(struct s_skill_magicmushroom_db), SERVER_TYPE_MAP },
{ "s_skill_produce_db", sizeof(struct s_skill_produce_db), SERVER_TYPE_MAP },
{ "s_skill_spellbook_db", sizeof(struct s_skill_spellbook_db), SERVER_TYPE_MAP },
{ "s_skill_unit_layout", sizeof(struct s_skill_unit_layout), SERVER_TYPE_MAP },
{ "skill_cd", sizeof(struct skill_cd), SERVER_TYPE_MAP },
{ "skill_cd_entry", sizeof(struct skill_cd_entry), SERVER_TYPE_MAP },
{ "skill_condition", sizeof(struct skill_condition), SERVER_TYPE_MAP },
{ "skill_interface", sizeof(struct skill_interface), SERVER_TYPE_MAP },
{ "skill_timerskill", sizeof(struct skill_timerskill), SERVER_TYPE_MAP },
{ "skill_unit", sizeof(struct skill_unit), SERVER_TYPE_MAP },
{ "skill_unit_group", sizeof(struct skill_unit_group), SERVER_TYPE_MAP },
{ "skill_unit_group_tickset", sizeof(struct skill_unit_group_tickset), SERVER_TYPE_MAP },
{ "skill_unit_save", sizeof(struct skill_unit_save), SERVER_TYPE_MAP },
#else
#define MAP_SKILL_H
#endif // MAP_SKILL_H
#ifdef MAP_STATUS_H
{ "regen_data", sizeof(struct regen_data), SERVER_TYPE_MAP },
{ "regen_data_sub", sizeof(struct regen_data_sub), SERVER_TYPE_MAP },
{ "s_refine_info", sizeof(struct s_refine_info), SERVER_TYPE_MAP },
{ "s_status_dbs", sizeof(struct s_status_dbs), SERVER_TYPE_MAP },
{ "sc_display_entry", sizeof(struct sc_display_entry), SERVER_TYPE_MAP },
{ "status_change", sizeof(struct status_change), SERVER_TYPE_MAP },
{ "status_change_entry", sizeof(struct status_change_entry), SERVER_TYPE_MAP },
{ "status_data", sizeof(struct status_data), SERVER_TYPE_MAP },
{ "status_interface", sizeof(struct status_interface), SERVER_TYPE_MAP },
{ "weapon_atk", sizeof(struct weapon_atk), SERVER_TYPE_MAP },
#else
#define MAP_STATUS_H
#endif // MAP_STATUS_H
#ifdef MAP_STORAGE_H
{ "guild_storage_interface", sizeof(struct guild_storage_interface), SERVER_TYPE_MAP },
{ "storage_interface", sizeof(struct storage_interface), SERVER_TYPE_MAP },
#else
#define MAP_STORAGE_H
#endif // MAP_STORAGE_H
#ifdef MAP_TRADE_H
{ "trade_interface", sizeof(struct trade_interface), SERVER_TYPE_MAP },
#else
#define MAP_TRADE_H
#endif // MAP_TRADE_H
#ifdef MAP_UNIT_H
{ "unit_data", sizeof(struct unit_data), SERVER_TYPE_MAP },
{ "unit_interface", sizeof(struct unit_interface), SERVER_TYPE_MAP },
{ "view_data", sizeof(struct view_data), SERVER_TYPE_MAP },
#else
#define MAP_UNIT_H
#endif // MAP_UNIT_H
#ifdef MAP_VENDING_H
{ "s_vending", sizeof(struct s_vending), SERVER_TYPE_MAP },
{ "vending_interface", sizeof(struct vending_interface), SERVER_TYPE_MAP },
#else
#define MAP_VENDING_H
#endif // MAP_VENDING_H
};
HPExport unsigned int HPMDataCheckLen = ARRAYLENGTH(HPMDataCheck);
HPExport int HPMDataCheckVer = 1;
#endif /* HPM_DATA_CHECK_H */
|
