/* -----------------------------------------------------------------
 * Created automagically from ../PT.aisc
 * using aisc-script '../AISC/aisc_com.pa'
 * DO NOT EDIT THIS FILE!!!
 * ----------------------------------------------------------------- */

#ifndef _LIMITS_H
#include <limits.h>
#endif
#ifndef AISC_GLOBAL_H
#include <aisc_global.h>
#endif
#ifndef AISC_MAX_OBJECT
# define AISC_MAX_OBJECT         12
# define AISC_MAX_ATTR           37
# define MAX_AISC_SET_GET        16
# define AISC_MAX_STRING_LEN     1024
# define AISC_MESSAGE_BUFFER_LEN ((AISC_MAX_STRING_LEN/4+3)*(16+2))
# define AISC_MAGIC_NUMBER       0x61505400

struct aisc_com;

const int AISC_GET        = AISC_MAGIC_NUMBER+0;
const int AISC_SET        = AISC_MAGIC_NUMBER+1;
const int AISC_NSET       = AISC_MAGIC_NUMBER+2;
const int AISC_CREATE     = AISC_MAGIC_NUMBER+3;
const int AISC_FIND       = AISC_MAGIC_NUMBER+4;
const int AISC_COPY       = AISC_MAGIC_NUMBER+5;
const int AISC_DELETE     = AISC_MAGIC_NUMBER+6;
const int AISC_INIT       = AISC_MAGIC_NUMBER+7;
const int AISC_DEBUG_INFO = AISC_MAGIC_NUMBER+8;

const int AISC_CCOM_OK      = AISC_MAGIC_NUMBER+0;
const int AISC_CCOM_ERROR   = AISC_MAGIC_NUMBER+1;
const int AISC_CCOM_MESSAGE = AISC_MAGIC_NUMBER+2;

#endif


#define PT_ATTR_INT(a,b)          (((a)+(b))|0x1000000)
#define PT_ATTR_DOUBLE(a,b)       (((a)+(b))|0x2000000)
#define PT_ATTR_STRING(a,b)       (((a)+(b))|0x3000000)
#define PT_ATTR_COMMON(a,b)       (((a)+(b))|0x4000000)
#define PT_ATTR_TPROBE(a,b)       (((a)+(b))|0x4000000)
#define PT_ATTR_SEQUENCE(a,b)     (((a)+(b))|0x4000000)
#define PT_ATTR_PDC(a,b)          (((a)+(b))|0x4000000)
#define PT_ATTR_PEP(a,b)          (((a)+(b))|0x4000000)
#define PT_ATTR_FAMILYLIST(a,b)   (((a)+(b))|0x4000000)
#define PT_ATTR_FAMILYFINDER(a,b) (((a)+(b))|0x4000000)
#define PT_ATTR_MATCHLIST(a,b)    (((a)+(b))|0x4000000)
#define PT_ATTR_SPECIESLIST(a,b)  (((a)+(b))|0x4000000)
#define PT_ATTR_LOCS(a,b)         (((a)+(b))|0x4000000)
#define PT_ATTR_MAIN(a,b)         (((a)+(b))|0x4000000)
#define PT_ATTR_BYTES(a,b)        (((a)+(b))|0x5000000)

enum Aisc_Object_Type {
    PT_COMMON       = 0x10000*0,
    PT_TPROBE       = 0x10000*9,
    PT_SEQUENCE     = 0x10000*8,
    PT_PDC          = 0x10000*7,
    PT_PEP          = 0x10000*6,
    PT_FAMILYLIST   = 0x10000*5,
    PT_FAMILYFINDER = 0x10000*12,
    PT_MATCHLIST    = 0x10000*4,
    PT_SPECIESLIST  = 0x10000*3,
    PT_LOCS         = 0x10000*2,
    PT_MAIN         = 0x10000*1,
    PT_MAX          = 0x10000*12,
    PT_INDEX        = 0x10000*0x1ff
};

struct T_PT_COMMON : public AISC_Object {
    T_PT_COMMON() : AISC_Object(PT_COMMON) {}
    void assign(const T_PT_COMMON& o) { set(o.type(), o.get()); }
};
struct T_PT_TPROBE : public AISC_Object {
    T_PT_TPROBE() : AISC_Object(PT_TPROBE) {}
    void assign(const T_PT_TPROBE& o) { set(o.type(), o.get()); }
};
struct T_PT_SEQUENCE : public AISC_Object {
    T_PT_SEQUENCE() : AISC_Object(PT_SEQUENCE) {}
    void assign(const T_PT_SEQUENCE& o) { set(o.type(), o.get()); }
};
struct T_PT_PDC : public AISC_Object {
    T_PT_PDC() : AISC_Object(PT_PDC) {}
    void assign(const T_PT_PDC& o) { set(o.type(), o.get()); }
};
struct T_PT_PEP : public AISC_Object {
    T_PT_PEP() : AISC_Object(PT_PEP) {}
    void assign(const T_PT_PEP& o) { set(o.type(), o.get()); }
};
struct T_PT_FAMILYLIST : public AISC_Object {
    T_PT_FAMILYLIST() : AISC_Object(PT_FAMILYLIST) {}
    void assign(const T_PT_FAMILYLIST& o) { set(o.type(), o.get()); }
};
struct T_PT_FAMILYFINDER : public AISC_Object {
    T_PT_FAMILYFINDER() : AISC_Object(PT_FAMILYFINDER) {}
    void assign(const T_PT_FAMILYFINDER& o) { set(o.type(), o.get()); }
};
struct T_PT_MATCHLIST : public AISC_Object {
    T_PT_MATCHLIST() : AISC_Object(PT_MATCHLIST) {}
    void assign(const T_PT_MATCHLIST& o) { set(o.type(), o.get()); }
};
struct T_PT_SPECIESLIST : public AISC_Object {
    T_PT_SPECIESLIST() : AISC_Object(PT_SPECIESLIST) {}
    void assign(const T_PT_SPECIESLIST& o) { set(o.type(), o.get()); }
};
struct T_PT_LOCS : public AISC_Object {
    T_PT_LOCS() : AISC_Object(PT_LOCS) {}
    void assign(const T_PT_LOCS& o) { set(o.type(), o.get()); }
};
struct T_PT_MAIN : public AISC_Object {
    T_PT_MAIN() : AISC_Object(PT_MAIN) {}
    void assign(const T_PT_MAIN& o) { set(o.type(), o.get()); }
};

enum PT_COMMON_Attribute { // COMMON
    COMMON_KEY       = PT_ATTR_INT   (PT_COMMON, 0), //
    COMMON_KEYSTRING = PT_ATTR_STRING(PT_COMMON, 1), //
    COMMON_CNT       = PT_ATTR_INT   (PT_COMMON, 2), // S
    COMMON_PARENT    = PT_ATTR_INT   (PT_COMMON, 3), // S
    COMMON_LAST      = PT_ATTR_INT   (PT_COMMON, 4), // S
    COMMON_IDENT     = PT_ATTR_STRING(PT_COMMON, 5), //
    COMMON_FORCELONG = LONG_MAX
};

enum PT_TPROBE_Attribute { // TPROBE
    TPROBE_PRED        = PT_ATTR_TPROBE(PT_TPROBE, 0),  // DO
    TPROBE_NEXT        = PT_ATTR_TPROBE(PT_TPROBE, 1),  //
    TPROBE_KEY         = PT_ATTR_INT   (PT_TPROBE, 2),  // H
    TPROBE_KEYSTRING   = PT_ATTR_STRING(PT_TPROBE, 3),  // H
    TPROBE_CNT         = PT_ATTR_INT   (PT_TPROBE, 4),  // H S
    TPROBE_PARENT      = PT_ATTR_INT   (PT_TPROBE, 5),  // H S
    TPROBE_LAST        = PT_ATTR_INT   (PT_TPROBE, 6),  // H S
    TPROBE_IDENT       = PT_ATTR_STRING(PT_TPROBE, 7),  // H
    TPROBE_SEQUENCE    = PT_ATTR_STRING(PT_TPROBE, 8),  //
    TPROBE_QUALITY     = PT_ATTR_DOUBLE(PT_TPROBE, 9),  //
    TPROBE_GROUPSIZE   = PT_ATTR_INT   (PT_TPROBE, 10), //
    TPROBE_HAIRPIN     = PT_ATTR_INT   (PT_TPROBE, 11), //
    TPROBE_WHAIRPIN    = PT_ATTR_DOUBLE(PT_TPROBE, 12), //
    TPROBE_PERC        = PT_ATTR_INT   (PT_TPROBE, 13), // [PERC_SIZE]
    TPROBE_TEMPERATURE = PT_ATTR_DOUBLE(PT_TPROBE, 14), //
    TPROBE_MISHIT      = PT_ATTR_INT   (PT_TPROBE, 15), //
    TPROBE_APOS        = PT_ATTR_INT   (PT_TPROBE, 16), //
    TPROBE_ECOLI_POS   = PT_ATTR_INT   (PT_TPROBE, 17), //
    TPROBE_INFO        = PT_ATTR_STRING(PT_TPROBE, 19), //
    TPROBE_FORCELONG   = LONG_MAX
};

enum PT_SEQUENCE_Attribute { // SEQUENCE
    SEQUENCE_PRED      = PT_ATTR_SEQUENCE(PT_SEQUENCE, 0), // DO
    SEQUENCE_NEXT      = PT_ATTR_SEQUENCE(PT_SEQUENCE, 1), //
    SEQUENCE_KEY       = PT_ATTR_INT     (PT_SEQUENCE, 2), // H
    SEQUENCE_KEYSTRING = PT_ATTR_STRING  (PT_SEQUENCE, 3), // H
    SEQUENCE_CNT       = PT_ATTR_INT     (PT_SEQUENCE, 4), // H S
    SEQUENCE_PARENT    = PT_ATTR_INT     (PT_SEQUENCE, 5), // H S
    SEQUENCE_LAST      = PT_ATTR_INT     (PT_SEQUENCE, 6), // H S
    SEQUENCE_IDENT     = PT_ATTR_STRING  (PT_SEQUENCE, 7), // H
    SEQUENCE_SEQUENCE  = PT_ATTR_BYTES   (PT_SEQUENCE, 8), //
    SEQUENCE_FORCELONG = LONG_MAX
};

enum PT_PDC_Attribute { // PDC
    PDC_PRED           = PT_ATTR_PDC     (PT_PDC, 0),  // DO
    PDC_NEXT           = PT_ATTR_PDC     (PT_PDC, 1),  //
    PDC_KEY            = PT_ATTR_INT     (PT_PDC, 2),  // H
    PDC_KEYSTRING      = PT_ATTR_STRING  (PT_PDC, 3),  // H
    PDC_CNT            = PT_ATTR_INT     (PT_PDC, 4),  // H S
    PDC_PARENT         = PT_ATTR_INT     (PT_PDC, 5),  // H S
    PDC_LAST           = PT_ATTR_INT     (PT_PDC, 6),  // H S
    PDC_IDENT          = PT_ATTR_STRING  (PT_PDC, 7),  // H
    PDC_DTEDGE         = PT_ATTR_DOUBLE  (PT_PDC, 9),  //
    PDC_DT             = PT_ATTR_DOUBLE  (PT_PDC, 10), //
    PDC_LOOPLEN        = PT_ATTR_INT     (PT_PDC, 14), //
    PDC_MIN_PROBELEN   = PT_ATTR_INT     (PT_PDC, 15), //
    PDC_MINTEMP        = PT_ATTR_DOUBLE  (PT_PDC, 16), //
    PDC_MAXTEMP        = PT_ATTR_DOUBLE  (PT_PDC, 17), //
    PDC_MINGC          = PT_ATTR_DOUBLE  (PT_PDC, 18), //
    PDC_MAXGC          = PT_ATTR_DOUBLE  (PT_PDC, 19), //
    PDC_MAXBOND        = PT_ATTR_DOUBLE  (PT_PDC, 20), //
    PDC_MIN_ECOLIPOS   = PT_ATTR_INT     (PT_PDC, 21), //
    PDC_MAX_ECOLIPOS   = PT_ATTR_INT     (PT_PDC, 22), //
    PDC_MINTARGETS     = PT_ATTR_DOUBLE  (PT_PDC, 23), //
    PDC_MISHIT         = PT_ATTR_INT     (PT_PDC, 24), //
    PDC_CLIPRESULT     = PT_ATTR_INT     (PT_PDC, 25), //
    PDC_CHECKSUMS      = PT_ATTR_BYTES   (PT_PDC, 26), //
    PDC_NAMES          = PT_ATTR_BYTES   (PT_PDC, 27), //
    PDC_UNKNOWN_NAMES  = PT_ATTR_BYTES   (PT_PDC, 28), //
    PDC_SEQUENCE       = PT_ATTR_SEQUENCE(PT_PDC, 29), // DL
    PDC_SEQUENCE_CNT   = PT_ATTR_INT     (PT_PDC, 30), // DL
    PDC_GO             = PT_ATTR_INT     (PT_PDC, 31), //
    PDC_TPROBE         = PT_ATTR_TPROBE  (PT_PDC, 32), // DL
    PDC_TPROBE_CNT     = PT_ATTR_INT     (PT_PDC, 33), // DL
    PDC_MAX_RJ_TARGETS = PT_ATTR_DOUBLE  (PT_PDC, 34), //
    PDC_MIN_RJ_MISHIT  = PT_ATTR_INT     (PT_PDC, 35), //
    PDC_INFO_HEADER    = PT_ATTR_STRING  (PT_PDC, 36), //
    PDC_MAX_PROBELEN   = PT_ATTR_INT     (PT_PDC, 37), //
    PDC_FORCELONG      = LONG_MAX
};

enum PT_PEP_Attribute { // PEP
    PEP_PRED        = PT_ATTR_PEP   (PT_PEP, 0),  // DO
    PEP_NEXT        = PT_ATTR_PEP   (PT_PEP, 1),  //
    PEP_KEY         = PT_ATTR_INT   (PT_PEP, 2),  // H
    PEP_KEYSTRING   = PT_ATTR_STRING(PT_PEP, 3),  // H
    PEP_CNT         = PT_ATTR_INT   (PT_PEP, 4),  // H S
    PEP_PARENT      = PT_ATTR_INT   (PT_PEP, 5),  // H S
    PEP_LAST        = PT_ATTR_INT   (PT_PEP, 6),  // H S
    PEP_IDENT       = PT_ATTR_STRING(PT_PEP, 7),  // H
    PEP_PLENGTH     = PT_ATTR_INT   (PT_PEP, 8),  //
    PEP_NUMGET      = PT_ATTR_INT   (PT_PEP, 9),  //
    PEP_READABLE    = PT_ATTR_INT   (PT_PEP, 14), //
    PEP_SEPARATOR   = PT_ATTR_INT   (PT_PEP, 15), //
    PEP_TU          = PT_ATTR_INT   (PT_PEP, 16), //
    PEP_RESTART     = PT_ATTR_INT   (PT_PEP, 10), //
    PEP_NEXT_PROBE  = PT_ATTR_BYTES (PT_PEP, 11), //
    PEP_FIND_PROBES = PT_ATTR_INT   (PT_PEP, 12), //
    PEP_RESULT      = PT_ATTR_STRING(PT_PEP, 13), //
    PEP_FORCELONG   = LONG_MAX
};

enum PT_FAMILYLIST_Attribute { // FAMILYLIST
    FAMILYLIST_PRED        = PT_ATTR_FAMILYLIST(PT_FAMILYLIST, 0),  // DO
    FAMILYLIST_NEXT        = PT_ATTR_FAMILYLIST(PT_FAMILYLIST, 1),  //
    FAMILYLIST_KEY         = PT_ATTR_INT       (PT_FAMILYLIST, 2),  // H
    FAMILYLIST_KEYSTRING   = PT_ATTR_STRING    (PT_FAMILYLIST, 3),  // H
    FAMILYLIST_CNT         = PT_ATTR_INT       (PT_FAMILYLIST, 4),  // H S
    FAMILYLIST_PARENT      = PT_ATTR_INT       (PT_FAMILYLIST, 5),  // H S
    FAMILYLIST_LAST        = PT_ATTR_INT       (PT_FAMILYLIST, 6),  // H S
    FAMILYLIST_IDENT       = PT_ATTR_STRING    (PT_FAMILYLIST, 7),  // H
    FAMILYLIST_NAME        = PT_ATTR_STRING    (PT_FAMILYLIST, 8),  //
    FAMILYLIST_MATCHES     = PT_ATTR_INT       (PT_FAMILYLIST, 9),  //
    FAMILYLIST_REL_MATCHES = PT_ATTR_DOUBLE    (PT_FAMILYLIST, 10), //
    FAMILYLIST_FORCELONG   = LONG_MAX
};

enum PT_FAMILYFINDER_Attribute { // FAMILYFINDER
    FAMILYFINDER_PRED             = PT_ATTR_FAMILYFINDER(PT_FAMILYFINDER, 0),  // DO
    FAMILYFINDER_NEXT             = PT_ATTR_FAMILYFINDER(PT_FAMILYFINDER, 1),  //
    FAMILYFINDER_KEY              = PT_ATTR_INT         (PT_FAMILYFINDER, 2),  // H
    FAMILYFINDER_KEYSTRING        = PT_ATTR_STRING      (PT_FAMILYFINDER, 3),  // H
    FAMILYFINDER_CNT              = PT_ATTR_INT         (PT_FAMILYFINDER, 4),  // H S
    FAMILYFINDER_PARENT           = PT_ATTR_INT         (PT_FAMILYFINDER, 5),  // H S
    FAMILYFINDER_LAST             = PT_ATTR_INT         (PT_FAMILYFINDER, 6),  // H S
    FAMILYFINDER_IDENT            = PT_ATTR_STRING      (PT_FAMILYFINDER, 7),  // H
    FAMILYFINDER_FIND_FAMILY      = PT_ATTR_BYTES       (PT_FAMILYFINDER, 8),  //
    FAMILYFINDER_PROBE_LEN        = PT_ATTR_INT         (PT_FAMILYFINDER, 9),  //
    FAMILYFINDER_MISMATCH_NUMBER  = PT_ATTR_INT         (PT_FAMILYFINDER, 10), //
    FAMILYFINDER_FIND_TYPE        = PT_ATTR_INT         (PT_FAMILYFINDER, 11), //
    FAMILYFINDER_COMPLEMENT       = PT_ATTR_INT         (PT_FAMILYFINDER, 12), //
    FAMILYFINDER_FAMILY_LIST      = PT_ATTR_FAMILYLIST  (PT_FAMILYFINDER, 13), // DL
    FAMILYFINDER_FAMILY_LIST_CNT  = PT_ATTR_INT         (PT_FAMILYFINDER, 14), // DL
    FAMILYFINDER_FAMILY_LIST_SIZE = PT_ATTR_INT         (PT_FAMILYFINDER, 15), //
    FAMILYFINDER_SORT_TYPE        = PT_ATTR_INT         (PT_FAMILYFINDER, 16), //
    FAMILYFINDER_SORT_MAX         = PT_ATTR_INT         (PT_FAMILYFINDER, 17), //
    FAMILYFINDER_RANGE_STARTPOS   = PT_ATTR_INT         (PT_FAMILYFINDER, 18), //
    FAMILYFINDER_RANGE_ENDPOS     = PT_ATTR_INT         (PT_FAMILYFINDER, 19), //
    FAMILYFINDER_MIN_SCORE        = PT_ATTR_DOUBLE      (PT_FAMILYFINDER, 20), //
    FAMILYFINDER_REL_SCORING      = PT_ATTR_INT         (PT_FAMILYFINDER, 21), //
    FAMILYFINDER_ERROR            = PT_ATTR_STRING      (PT_FAMILYFINDER, 22), //
    FAMILYFINDER_FORCELONG        = LONG_MAX
};

enum PT_MATCHLIST_Attribute { // MATCHLIST
    MATCHLIST_PRED         = PT_ATTR_MATCHLIST(PT_MATCHLIST, 0),  // DO
    MATCHLIST_NEXT         = PT_ATTR_MATCHLIST(PT_MATCHLIST, 1),  //
    MATCHLIST_KEY          = PT_ATTR_INT      (PT_MATCHLIST, 2),  // H
    MATCHLIST_KEYSTRING    = PT_ATTR_STRING   (PT_MATCHLIST, 3),  // H
    MATCHLIST_CNT          = PT_ATTR_INT      (PT_MATCHLIST, 4),  // H S
    MATCHLIST_PARENT       = PT_ATTR_INT      (PT_MATCHLIST, 5),  // H S
    MATCHLIST_LAST         = PT_ATTR_INT      (PT_MATCHLIST, 6),  // H S
    MATCHLIST_IDENT        = PT_ATTR_STRING   (PT_MATCHLIST, 7),  // H
    MATCHLIST_ID           = PT_ATTR_INT      (PT_MATCHLIST, 8),  //
    MATCHLIST_NAME         = PT_ATTR_STRING   (PT_MATCHLIST, 9),  //
    MATCHLIST_POS          = PT_ATTR_INT      (PT_MATCHLIST, 10), //
    MATCHLIST_GPOS         = PT_ATTR_INT      (PT_MATCHLIST, 11), //
    MATCHLIST_MISMATCHES   = PT_ATTR_INT      (PT_MATCHLIST, 12), //
    MATCHLIST_FULLNAME     = PT_ATTR_STRING   (PT_MATCHLIST, 13), //
    MATCHLIST_WMISMATCHES  = PT_ATTR_DOUBLE   (PT_MATCHLIST, 14), //
    MATCHLIST_N_MISMATCHES = PT_ATTR_INT      (PT_MATCHLIST, 15), //
    MATCHLIST_DT           = PT_ATTR_DOUBLE   (PT_MATCHLIST, 16), //
    MATCHLIST_SEQUENCE     = PT_ATTR_INT      (PT_MATCHLIST, 17), //
    MATCHLIST_REVERSED     = PT_ATTR_INT      (PT_MATCHLIST, 18), //
    MATCHLIST_OVERLAY      = PT_ATTR_STRING   (PT_MATCHLIST, 19), //
    MATCHLIST_FORCELONG    = LONG_MAX
};

enum PT_SPECIESLIST_Attribute { // SPECIESLIST
    SPECIESLIST_PRED      = PT_ATTR_SPECIESLIST(PT_SPECIESLIST, 0), // DO
    SPECIESLIST_NEXT      = PT_ATTR_SPECIESLIST(PT_SPECIESLIST, 1), //
    SPECIESLIST_KEY       = PT_ATTR_INT        (PT_SPECIESLIST, 2), // H
    SPECIESLIST_KEYSTRING = PT_ATTR_STRING     (PT_SPECIESLIST, 3), // H
    SPECIESLIST_CNT       = PT_ATTR_INT        (PT_SPECIESLIST, 4), // H S
    SPECIESLIST_PARENT    = PT_ATTR_INT        (PT_SPECIESLIST, 5), // H S
    SPECIESLIST_LAST      = PT_ATTR_INT        (PT_SPECIESLIST, 6), // H S
    SPECIESLIST_IDENT     = PT_ATTR_STRING     (PT_SPECIESLIST, 7), // H
    SPECIESLIST_MEMBER    = PT_ATTR_INT        (PT_SPECIESLIST, 8), //
    SPECIESLIST_FORCELONG = LONG_MAX
};

enum PT_LOCS_Attribute { // LOCS
    LOCS_PRED                    = PT_ATTR_LOCS        (PT_LOCS, 0),  // DO
    LOCS_NEXT                    = PT_ATTR_LOCS        (PT_LOCS, 1),  //
    LOCS_KEY                     = PT_ATTR_INT         (PT_LOCS, 2),  // H
    LOCS_KEYSTRING               = PT_ATTR_STRING      (PT_LOCS, 3),  // H
    LOCS_CNT                     = PT_ATTR_INT         (PT_LOCS, 4),  // H S
    LOCS_PARENT                  = PT_ATTR_INT         (PT_LOCS, 5),  // H S
    LOCS_LAST                    = PT_ATTR_INT         (PT_LOCS, 6),  // H S
    LOCS_IDENT                   = PT_ATTR_STRING      (PT_LOCS, 7),  // H
    LOCS_SEARCHMATCH             = PT_ATTR_STRING      (PT_LOCS, 8),  //
    LOCS_MATCH_REVERSED          = PT_ATTR_INT         (PT_LOCS, 9),  //
    LOCS_MATCH_COMPLEMENT        = PT_ATTR_INT         (PT_LOCS, 10), //
    LOCS_MATCH_MAX_MISMATCHES    = PT_ATTR_INT         (PT_LOCS, 11), //
    LOCS_MATCH_MAX_HITS          = PT_ATTR_INT         (PT_LOCS, 12), //
    LOCS_MATCH_SORT_BY           = PT_ATTR_INT         (PT_LOCS, 13), //
    LOCS_MATCH_N_ACCEPT          = PT_ATTR_INT         (PT_LOCS, 14), //
    LOCS_MATCH_N_LIMIT           = PT_ATTR_INT         (PT_LOCS, 33), //
    LOCS_MATCH_LIST              = PT_ATTR_MATCHLIST   (PT_LOCS, 15), // DL
    LOCS_MATCH_LIST_CNT          = PT_ATTR_INT         (PT_LOCS, 16), // DL
    LOCS_MATCHES_TRUNCATED       = PT_ATTR_INT         (PT_LOCS, 17), //
    LOCS_MATCH_STRING            = PT_ATTR_BYTES       (PT_LOCS, 18), //
    LOCS_MP_MATCH_STRING         = PT_ATTR_BYTES       (PT_LOCS, 19), //
    LOCS_MP_ALL_SPECIES_STRING   = PT_ATTR_BYTES       (PT_LOCS, 20), //
    LOCS_MP_COUNT_ALL_SPECIES    = PT_ATTR_INT         (PT_LOCS, 21), //
    LOCS_ERROR                   = PT_ATTR_STRING      (PT_LOCS, 22), //
    LOCS_PROBE_NGROUP            = PT_ATTR_INT         (PT_LOCS, 23), //
    LOCS_PROBE_DESIGN_CONFIG     = PT_ATTR_PDC         (PT_LOCS, 24), // DL
    LOCS_PROBE_DESIGN_CONFIG_CNT = PT_ATTR_INT         (PT_LOCS, 25), // DL
    LOCS_PROBE_FIND_CONFIG       = PT_ATTR_PEP         (PT_LOCS, 26), // DL
    LOCS_PROBE_FIND_CONFIG_CNT   = PT_ATTR_INT         (PT_LOCS, 27), // DL
    LOCS_FFINDER                 = PT_ATTR_FAMILYFINDER(PT_LOCS, 28), // DL
    LOCS_FFINDER_CNT             = PT_ATTR_INT         (PT_LOCS, 29), // DL
    LOCS_USER                    = PT_ATTR_STRING      (PT_LOCS, 30), //
    LOCS_ADDRESS                 = PT_ATTR_STRING      (PT_LOCS, 31), //
    LOCS_LOGINTIME               = PT_ATTR_STRING      (PT_LOCS, 32), //
    LOCS_BONDVAL                 = PT_ATTR_DOUBLE      (PT_LOCS, 34), // S
    LOCS_SPLIT                   = PT_ATTR_DOUBLE      (PT_LOCS, 35), //
    LOCS_FORCELONG               = LONG_MAX
};

enum PT_MAIN_Attribute { // MAIN
    MAIN_LOCS            = PT_ATTR_LOCS       (PT_MAIN, 1),  // DL
    MAIN_LOCS_CNT        = PT_ATTR_INT        (PT_MAIN, 2),  // DL
    MAIN_SHUTDOWN        = PT_ATTR_STRING     (PT_MAIN, 3),  //
    MAIN_STARTER         = PT_ATTR_INT        (PT_MAIN, 4),  //
    MAIN_MESSAGE_TYPE    = PT_ATTR_INT        (PT_MAIN, 5),  //
    MAIN_MESSAGE         = PT_ATTR_STRING     (PT_MAIN, 6),  //
    MAIN_BROADCAST       = PT_ATTR_INT        (PT_MAIN, 7),  //
    MAIN_SPECIESLIST     = PT_ATTR_SPECIESLIST(PT_MAIN, 8),  // DL
    MAIN_SPECIESLIST_CNT = PT_ATTR_INT        (PT_MAIN, 9),  // DL
    MAIN_DUMP_NAME       = PT_ATTR_STRING     (PT_MAIN, 10), //
    MAIN_DUMP_INDEX      = PT_ATTR_INT        (PT_MAIN, 11), //
    MAIN_FORCELONG       = LONG_MAX
};

