
/* ======================================================================== */
/* STRUCT */

/* ------------------------------------------------------------------------ */
/* Object */
#define CLASS_Object            ((knh_class_t)0)
#define STRUCT_Object           ((knh_struct_t)0)
#define IS_Object(o)            ((o)->h.cid == CLASS_Object)
#define TYPE_Object             CLASS_Object
#define NNTYPE_Object           NNTYPE_cid(CLASS_Object)
#define NATYPE_Object           NATYPE_cid(CLASS_Object)
#define CFLAG_Object            ((knh_flag_t)0)
#define FLAG_Object             KNH_FLAG_CF2OF(CFLAG_Object)

/* ------------------------------------------------------------------------ */
/* Boolean */
#define CLASS_Boolean           ((knh_class_t)1)
#define STRUCT_Boolean          ((knh_struct_t)1)
#define IS_Boolean(o)           ((o)->h.cid == CLASS_Boolean)
#define IS_bBoolean(o)          ((o)->h.bcid == CLASS_Boolean)
#define TYPE_Boolean            CLASS_Boolean
#define NNTYPE_Boolean          NNTYPE_cid(CLASS_Boolean)
#define NATYPE_Boolean          NATYPE_cid(CLASS_Boolean)
#define CFLAG_Boolean           ((knh_flag_t)FLAG_Class_Immutable)
#define FLAG_Boolean            KNH_FLAG_CF2OF(CFLAG_Boolean)

/* ------------------------------------------------------------------------ */
/* Number */
#define CLASS_Number            ((knh_class_t)2)
#define STRUCT_Number           ((knh_struct_t)2)
#define IS_Number(o)            ((o)->h.cid == CLASS_Number)
#define IS_bNumber(o)           ((o)->h.bcid == CLASS_Number)
#define TYPE_Number             CLASS_Number
#define NNTYPE_Number           NNTYPE_cid(CLASS_Number)
#define NATYPE_Number           NATYPE_cid(CLASS_Number)
#define CFLAG_Number            ((knh_flag_t)0)
#define FLAG_Number             KNH_FLAG_CF2OF(CFLAG_Number)

/* ------------------------------------------------------------------------ */
/* Int */
#define CLASS_Int               ((knh_class_t)3)
#define STRUCT_Int              ((knh_struct_t)3)
#define IS_Int(o)               ((o)->h.cid == CLASS_Int)
#define IS_bInt(o)              ((o)->h.bcid == CLASS_Int)
#define TYPE_Int                CLASS_Int
#define NNTYPE_Int              NNTYPE_cid(CLASS_Int)
#define NATYPE_Int              NATYPE_cid(CLASS_Int)
#define CFLAG_Int               ((knh_flag_t)FLAG_Class_Immutable)
#define FLAG_Int                KNH_FLAG_CF2OF(CFLAG_Int)

/* ------------------------------------------------------------------------ */
/* Float */
#define CLASS_Float             ((knh_class_t)4)
#define STRUCT_Float            ((knh_struct_t)4)
#define IS_Float(o)             ((o)->h.cid == CLASS_Float)
#define IS_bFloat(o)            ((o)->h.bcid == CLASS_Float)
#define TYPE_Float              CLASS_Float
#define NNTYPE_Float            NNTYPE_cid(CLASS_Float)
#define NATYPE_Float            NATYPE_cid(CLASS_Float)
#define CFLAG_Float             ((knh_flag_t)FLAG_Class_Immutable)
#define FLAG_Float              KNH_FLAG_CF2OF(CFLAG_Float)

/* ------------------------------------------------------------------------ */
/* String */
#define CLASS_String            ((knh_class_t)5)
#define STRUCT_String           ((knh_struct_t)5)
#define IS_String(o)            ((o)->h.cid == CLASS_String)
#define IS_bString(o)           ((o)->h.bcid == CLASS_String)
#define TYPE_String             CLASS_String
#define NNTYPE_String           NNTYPE_cid(CLASS_String)
#define NATYPE_String           NATYPE_cid(CLASS_String)
#define CFLAG_String            ((knh_flag_t)FLAG_Class_Immutable)
#define FLAG_String             KNH_FLAG_CF2OF(CFLAG_String)

/* ------------------------------------------------------------------------ */
/* Bytes */
#define CLASS_Bytes             ((knh_class_t)6)
#define STRUCT_Bytes            ((knh_struct_t)6)
#define IS_Bytes(o)             ((o)->h.cid == CLASS_Bytes)
#define IS_bBytes(o)            ((o)->h.bcid == CLASS_Bytes)
#define TYPE_Bytes              CLASS_Bytes
#define NNTYPE_Bytes            NNTYPE_cid(CLASS_Bytes)
#define NATYPE_Bytes            NATYPE_cid(CLASS_Bytes)
#define CFLAG_Bytes             ((knh_flag_t)0)
#define FLAG_Bytes              KNH_FLAG_CF2OF(CFLAG_Bytes)

/* ------------------------------------------------------------------------ */
/* Pair */
#define CLASS_Pair              ((knh_class_t)7)
#define STRUCT_Pair             ((knh_struct_t)7)
#define IS_Pair(o)              ((o)->h.cid == CLASS_Pair)
#define IS_bPair(o)             ((o)->h.bcid == CLASS_Pair)
#define TYPE_Pair               CLASS_Pair
#define NNTYPE_Pair             NNTYPE_cid(CLASS_Pair)
#define NATYPE_Pair             NATYPE_cid(CLASS_Pair)
#define CFLAG_Pair              ((knh_flag_t)FLAG_Class_Immutable)
#define FLAG_Pair               KNH_FLAG_CF2OF(CFLAG_Pair)

/* ------------------------------------------------------------------------ */
/* Tuple */
#define CLASS_Tuple             ((knh_class_t)8)
#define STRUCT_Tuple            ((knh_struct_t)8)
#define IS_Tuple(o)             ((o)->h.cid == CLASS_Tuple)
#define IS_bTuple(o)            ((o)->h.bcid == CLASS_Tuple)
#define TYPE_Tuple              CLASS_Tuple
#define NNTYPE_Tuple            NNTYPE_cid(CLASS_Tuple)
#define NATYPE_Tuple            NATYPE_cid(CLASS_Tuple)
#define CFLAG_Tuple             ((knh_flag_t)FLAG_Class_Immutable)
#define FLAG_Tuple              KNH_FLAG_CF2OF(CFLAG_Tuple)

/* ------------------------------------------------------------------------ */
/* Range */
#define CLASS_Range             ((knh_class_t)9)
#define STRUCT_Range            ((knh_struct_t)9)
#define IS_Range(o)             ((o)->h.cid == CLASS_Range)
#define IS_bRange(o)            ((o)->h.bcid == CLASS_Range)
#define TYPE_Range              CLASS_Range
#define NNTYPE_Range            NNTYPE_cid(CLASS_Range)
#define NATYPE_Range            NATYPE_cid(CLASS_Range)
#define CFLAG_Range             ((knh_flag_t)FLAG_Class_Immutable)
#define FLAG_Range              KNH_FLAG_CF2OF(CFLAG_Range)

/* ------------------------------------------------------------------------ */
/* Array */
#define CLASS_Array             ((knh_class_t)10)
#define STRUCT_Array            ((knh_struct_t)10)
#define IS_Array(o)             ((o)->h.cid == CLASS_Array)
#define IS_bArray(o)            ((o)->h.bcid == CLASS_Array)
#define TYPE_Array              CLASS_Array
#define NNTYPE_Array            NNTYPE_cid(CLASS_Array)
#define NATYPE_Array            NATYPE_cid(CLASS_Array)
#define CFLAG_Array             ((knh_flag_t)0)
#define FLAG_Array              KNH_FLAG_CF2OF(CFLAG_Array)

/* ------------------------------------------------------------------------ */
/* IArray */
#define CLASS_IArray            ((knh_class_t)11)
#define STRUCT_IArray           ((knh_struct_t)11)
#define IS_IArray(o)            ((o)->h.cid == CLASS_IArray)
#define IS_bIArray(o)           ((o)->h.bcid == CLASS_IArray)
#define TYPE_IArray             CLASS_IArray
#define NNTYPE_IArray           NNTYPE_cid(CLASS_IArray)
#define NATYPE_IArray           NATYPE_cid(CLASS_IArray)
#define CFLAG_IArray            ((knh_flag_t)0)
#define FLAG_IArray             KNH_FLAG_CF2OF(CFLAG_IArray)

/* ------------------------------------------------------------------------ */
/* FArray */
#define CLASS_FArray            ((knh_class_t)12)
#define STRUCT_FArray           ((knh_struct_t)12)
#define IS_FArray(o)            ((o)->h.cid == CLASS_FArray)
#define IS_bFArray(o)           ((o)->h.bcid == CLASS_FArray)
#define TYPE_FArray             CLASS_FArray
#define NNTYPE_FArray           NNTYPE_cid(CLASS_FArray)
#define NATYPE_FArray           NATYPE_cid(CLASS_FArray)
#define CFLAG_FArray            ((knh_flag_t)0)
#define FLAG_FArray             KNH_FLAG_CF2OF(CFLAG_FArray)

/* ------------------------------------------------------------------------ */
/* Iterator */
#define CLASS_Iterator          ((knh_class_t)13)
#define STRUCT_Iterator         ((knh_struct_t)13)
#define IS_Iterator(o)          ((o)->h.cid == CLASS_Iterator)
#define IS_bIterator(o)         ((o)->h.bcid == CLASS_Iterator)
#define TYPE_Iterator           CLASS_Iterator
#define NNTYPE_Iterator         NNTYPE_cid(CLASS_Iterator)
#define NATYPE_Iterator         NATYPE_cid(CLASS_Iterator)
#define CFLAG_Iterator          ((knh_flag_t)0)
#define FLAG_Iterator           KNH_FLAG_CF2OF(CFLAG_Iterator)

/* ------------------------------------------------------------------------ */
/* DictMap */
#define CLASS_DictMap           ((knh_class_t)14)
#define STRUCT_DictMap          ((knh_struct_t)14)
#define IS_DictMap(o)           ((o)->h.cid == CLASS_DictMap)
#define IS_bDictMap(o)          ((o)->h.bcid == CLASS_DictMap)
#define TYPE_DictMap            CLASS_DictMap
#define NNTYPE_DictMap          NNTYPE_cid(CLASS_DictMap)
#define NATYPE_DictMap          NATYPE_cid(CLASS_DictMap)
#define CFLAG_DictMap           ((knh_flag_t)0)
#define FLAG_DictMap            KNH_FLAG_CF2OF(CFLAG_DictMap)

/* ------------------------------------------------------------------------ */
/* DictSet */
#define CLASS_DictSet           ((knh_class_t)15)
#define STRUCT_DictSet          ((knh_struct_t)15)
#define IS_DictSet(o)           ((o)->h.cid == CLASS_DictSet)
#define IS_bDictSet(o)          ((o)->h.bcid == CLASS_DictSet)
#define TYPE_DictSet            CLASS_DictSet
#define NNTYPE_DictSet          NNTYPE_cid(CLASS_DictSet)
#define NATYPE_DictSet          NATYPE_cid(CLASS_DictSet)
#define CFLAG_DictSet           ((knh_flag_t)0)
#define FLAG_DictSet            KNH_FLAG_CF2OF(CFLAG_DictSet)

/* ------------------------------------------------------------------------ */
/* HashMap */
#define CLASS_HashMap           ((knh_class_t)16)
#define STRUCT_HashMap          ((knh_struct_t)16)
#define IS_HashMap(o)           ((o)->h.cid == CLASS_HashMap)
#define IS_bHashMap(o)          ((o)->h.bcid == CLASS_HashMap)
#define TYPE_HashMap            CLASS_HashMap
#define NNTYPE_HashMap          NNTYPE_cid(CLASS_HashMap)
#define NATYPE_HashMap          NATYPE_cid(CLASS_HashMap)
#define CFLAG_HashMap           ((knh_flag_t)0)
#define FLAG_HashMap            KNH_FLAG_CF2OF(CFLAG_HashMap)

/* ------------------------------------------------------------------------ */
/* HashSet */
#define CLASS_HashSet           ((knh_class_t)17)
#define STRUCT_HashSet          ((knh_struct_t)17)
#define IS_HashSet(o)           ((o)->h.cid == CLASS_HashSet)
#define IS_bHashSet(o)          ((o)->h.bcid == CLASS_HashSet)
#define TYPE_HashSet            CLASS_HashSet
#define NNTYPE_HashSet          NNTYPE_cid(CLASS_HashSet)
#define NATYPE_HashSet          NATYPE_cid(CLASS_HashSet)
#define CFLAG_HashSet           ((knh_flag_t)0)
#define FLAG_HashSet            KNH_FLAG_CF2OF(CFLAG_HashSet)

/* ------------------------------------------------------------------------ */
/* DictIdx */
#define CLASS_DictIdx           ((knh_class_t)18)
#define STRUCT_DictIdx          ((knh_struct_t)18)
#define IS_DictIdx(o)           ((o)->h.cid == CLASS_DictIdx)
#define IS_bDictIdx(o)          ((o)->h.bcid == CLASS_DictIdx)
#define TYPE_DictIdx            CLASS_DictIdx
#define NNTYPE_DictIdx          NNTYPE_cid(CLASS_DictIdx)
#define NATYPE_DictIdx          NATYPE_cid(CLASS_DictIdx)
#define CFLAG_DictIdx           ((knh_flag_t)FLAG_Class_Private)
#define FLAG_DictIdx            KNH_FLAG_CF2OF(CFLAG_DictIdx)

/* ------------------------------------------------------------------------ */
/* Class */
#define CLASS_Class             ((knh_class_t)19)
#define STRUCT_Class            ((knh_struct_t)19)
#define IS_Class(o)             ((o)->h.cid == CLASS_Class)
#define IS_bClass(o)            ((o)->h.bcid == CLASS_Class)
#define TYPE_Class              CLASS_Class
#define NNTYPE_Class            NNTYPE_cid(CLASS_Class)
#define NATYPE_Class            NATYPE_cid(CLASS_Class)
#define CFLAG_Class             ((knh_flag_t)FLAG_Class_Immutable)
#define FLAG_Class              KNH_FLAG_CF2OF(CFLAG_Class)

/* ------------------------------------------------------------------------ */
/* ClassStruct */
#define CLASS_ClassStruct       ((knh_class_t)20)
#define STRUCT_ClassStruct      ((knh_struct_t)20)
#define IS_ClassStruct(o)       ((o)->h.cid == CLASS_ClassStruct)
#define IS_bClassStruct(o)      ((o)->h.bcid == CLASS_ClassStruct)
#define TYPE_ClassStruct        CLASS_ClassStruct
#define NNTYPE_ClassStruct      NNTYPE_cid(CLASS_ClassStruct)
#define NATYPE_ClassStruct      NATYPE_cid(CLASS_ClassStruct)
#define CFLAG_ClassStruct       ((knh_flag_t)FLAG_Class_Private)
#define FLAG_ClassStruct        KNH_FLAG_CF2OF(CFLAG_ClassStruct)

/* ------------------------------------------------------------------------ */
/* MethodField */
#define CLASS_MethodField       ((knh_class_t)21)
#define STRUCT_MethodField      ((knh_struct_t)21)
#define IS_MethodField(o)       ((o)->h.cid == CLASS_MethodField)
#define IS_bMethodField(o)      ((o)->h.bcid == CLASS_MethodField)
#define TYPE_MethodField        CLASS_MethodField
#define NNTYPE_MethodField      NNTYPE_cid(CLASS_MethodField)
#define NATYPE_MethodField      NATYPE_cid(CLASS_MethodField)
#define CFLAG_MethodField       ((knh_flag_t)FLAG_Class_Private)
#define FLAG_MethodField        KNH_FLAG_CF2OF(CFLAG_MethodField)

/* ------------------------------------------------------------------------ */
/* Method */
#define CLASS_Method            ((knh_class_t)22)
#define STRUCT_Method           ((knh_struct_t)22)
#define IS_Method(o)            ((o)->h.cid == CLASS_Method)
#define IS_bMethod(o)           ((o)->h.bcid == CLASS_Method)
#define TYPE_Method             CLASS_Method
#define NNTYPE_Method           NNTYPE_cid(CLASS_Method)
#define NATYPE_Method           NATYPE_cid(CLASS_Method)
#define CFLAG_Method            ((knh_flag_t)0)
#define FLAG_Method             KNH_FLAG_CF2OF(CFLAG_Method)

/* ------------------------------------------------------------------------ */
/* Mapper */
#define CLASS_Mapper            ((knh_class_t)23)
#define STRUCT_Mapper           ((knh_struct_t)23)
#define IS_Mapper(o)            ((o)->h.cid == CLASS_Mapper)
#define IS_bMapper(o)           ((o)->h.bcid == CLASS_Mapper)
#define TYPE_Mapper             CLASS_Mapper
#define NNTYPE_Mapper           NNTYPE_cid(CLASS_Mapper)
#define NATYPE_Mapper           NATYPE_cid(CLASS_Mapper)
#define CFLAG_Mapper            ((knh_flag_t)0)
#define FLAG_Mapper             KNH_FLAG_CF2OF(CFLAG_Mapper)

/* ------------------------------------------------------------------------ */
/* ClassMap */
#define CLASS_ClassMap          ((knh_class_t)24)
#define STRUCT_ClassMap         ((knh_struct_t)24)
#define IS_ClassMap(o)          ((o)->h.cid == CLASS_ClassMap)
#define IS_bClassMap(o)         ((o)->h.bcid == CLASS_ClassMap)
#define TYPE_ClassMap           CLASS_ClassMap
#define NNTYPE_ClassMap         NNTYPE_cid(CLASS_ClassMap)
#define NATYPE_ClassMap         NATYPE_cid(CLASS_ClassMap)
#define CFLAG_ClassMap          ((knh_flag_t)FLAG_Class_Private)
#define FLAG_ClassMap           KNH_FLAG_CF2OF(CFLAG_ClassMap)

/* ------------------------------------------------------------------------ */
/* Closure */
#define CLASS_Closure           ((knh_class_t)25)
#define STRUCT_Closure          ((knh_struct_t)25)
#define IS_Closure(o)           ((o)->h.cid == CLASS_Closure)
#define IS_bClosure(o)          ((o)->h.bcid == CLASS_Closure)
#define TYPE_Closure            CLASS_Closure
#define NNTYPE_Closure          NNTYPE_cid(CLASS_Closure)
#define NATYPE_Closure          NATYPE_cid(CLASS_Closure)
#define CFLAG_Closure           ((knh_flag_t)0)
#define FLAG_Closure            KNH_FLAG_CF2OF(CFLAG_Closure)

/* ------------------------------------------------------------------------ */
/* AffineConv */
#define CLASS_AffineConv        ((knh_class_t)26)
#define STRUCT_AffineConv       ((knh_struct_t)26)
#define IS_AffineConv(o)        ((o)->h.cid == CLASS_AffineConv)
#define IS_bAffineConv(o)       ((o)->h.bcid == CLASS_AffineConv)
#define TYPE_AffineConv         CLASS_AffineConv
#define NNTYPE_AffineConv       NNTYPE_cid(CLASS_AffineConv)
#define NATYPE_AffineConv       NATYPE_cid(CLASS_AffineConv)
#define CFLAG_AffineConv        ((knh_flag_t)FLAG_Class_Immutable|FLAG_Class_Private)
#define FLAG_AffineConv         KNH_FLAG_CF2OF(CFLAG_AffineConv)

/* ------------------------------------------------------------------------ */
/* Regex */
#define CLASS_Regex             ((knh_class_t)27)
#define STRUCT_Regex            ((knh_struct_t)27)
#define IS_Regex(o)             ((o)->h.cid == CLASS_Regex)
#define IS_bRegex(o)            ((o)->h.bcid == CLASS_Regex)
#define TYPE_Regex              CLASS_Regex
#define NNTYPE_Regex            NNTYPE_cid(CLASS_Regex)
#define NATYPE_Regex            NATYPE_cid(CLASS_Regex)
#define CFLAG_Regex             ((knh_flag_t)FLAG_Class_Immutable)
#define FLAG_Regex              KNH_FLAG_CF2OF(CFLAG_Regex)

/* ------------------------------------------------------------------------ */
/* BytesConv */
#define CLASS_BytesConv         ((knh_class_t)28)
#define STRUCT_BytesConv        ((knh_struct_t)28)
#define IS_BytesConv(o)         ((o)->h.cid == CLASS_BytesConv)
#define IS_bBytesConv(o)        ((o)->h.bcid == CLASS_BytesConv)
#define TYPE_BytesConv          CLASS_BytesConv
#define NNTYPE_BytesConv        NNTYPE_cid(CLASS_BytesConv)
#define NATYPE_BytesConv        NATYPE_cid(CLASS_BytesConv)
#define CFLAG_BytesConv         ((knh_flag_t)FLAG_Class_Private)
#define FLAG_BytesConv          KNH_FLAG_CF2OF(CFLAG_BytesConv)

/* ------------------------------------------------------------------------ */
/* ClassSpec */
#define CLASS_ClassSpec         ((knh_class_t)29)
#define STRUCT_ClassSpec        ((knh_struct_t)29)
#define IS_ClassSpec(o)         ((o)->h.cid == CLASS_ClassSpec)
#define IS_bClassSpec(o)        ((o)->h.bcid == CLASS_ClassSpec)
#define TYPE_ClassSpec          CLASS_ClassSpec
#define NNTYPE_ClassSpec        NNTYPE_cid(CLASS_ClassSpec)
#define NATYPE_ClassSpec        NATYPE_cid(CLASS_ClassSpec)
#define CFLAG_ClassSpec         ((knh_flag_t)FLAG_Class_Private)
#define FLAG_ClassSpec          KNH_FLAG_CF2OF(CFLAG_ClassSpec)

/* ------------------------------------------------------------------------ */
/* InputStream */
#define CLASS_InputStream       ((knh_class_t)30)
#define STRUCT_InputStream      ((knh_struct_t)30)
#define IS_InputStream(o)       ((o)->h.cid == CLASS_InputStream)
#define IS_bInputStream(o)      ((o)->h.bcid == CLASS_InputStream)
#define TYPE_InputStream        CLASS_InputStream
#define NNTYPE_InputStream      NNTYPE_cid(CLASS_InputStream)
#define NATYPE_InputStream      NATYPE_cid(CLASS_InputStream)
#define CFLAG_InputStream       ((knh_flag_t)0)
#define FLAG_InputStream        KNH_FLAG_CF2OF(CFLAG_InputStream)

/* ------------------------------------------------------------------------ */
/* OutputStream */
#define CLASS_OutputStream      ((knh_class_t)31)
#define STRUCT_OutputStream     ((knh_struct_t)31)
#define IS_OutputStream(o)      ((o)->h.cid == CLASS_OutputStream)
#define IS_bOutputStream(o)     ((o)->h.bcid == CLASS_OutputStream)
#define TYPE_OutputStream       CLASS_OutputStream
#define NNTYPE_OutputStream     NNTYPE_cid(CLASS_OutputStream)
#define NATYPE_OutputStream     NATYPE_cid(CLASS_OutputStream)
#define CFLAG_OutputStream      ((knh_flag_t)0)
#define FLAG_OutputStream       KNH_FLAG_CF2OF(CFLAG_OutputStream)

/* ------------------------------------------------------------------------ */
/* Socket */
#define CLASS_Socket            ((knh_class_t)32)
#define STRUCT_Socket           ((knh_struct_t)32)
#define IS_Socket(o)            ((o)->h.cid == CLASS_Socket)
#define IS_bSocket(o)           ((o)->h.bcid == CLASS_Socket)
#define TYPE_Socket             CLASS_Socket
#define NNTYPE_Socket           NNTYPE_cid(CLASS_Socket)
#define NATYPE_Socket           NATYPE_cid(CLASS_Socket)
#define CFLAG_Socket            ((knh_flag_t)0)
#define FLAG_Socket             KNH_FLAG_CF2OF(CFLAG_Socket)

/* ------------------------------------------------------------------------ */
/* Connection */
#define CLASS_Connection        ((knh_class_t)33)
#define STRUCT_Connection       ((knh_struct_t)33)
#define IS_Connection(o)        ((o)->h.cid == CLASS_Connection)
#define IS_bConnection(o)       ((o)->h.bcid == CLASS_Connection)
#define TYPE_Connection         CLASS_Connection
#define NNTYPE_Connection       NNTYPE_cid(CLASS_Connection)
#define NATYPE_Connection       NATYPE_cid(CLASS_Connection)
#define CFLAG_Connection        ((knh_flag_t)0)
#define FLAG_Connection         KNH_FLAG_CF2OF(CFLAG_Connection)

/* ------------------------------------------------------------------------ */
/* ResultSet */
#define CLASS_ResultSet         ((knh_class_t)34)
#define STRUCT_ResultSet        ((knh_struct_t)34)
#define IS_ResultSet(o)         ((o)->h.cid == CLASS_ResultSet)
#define IS_bResultSet(o)        ((o)->h.bcid == CLASS_ResultSet)
#define TYPE_ResultSet          CLASS_ResultSet
#define NNTYPE_ResultSet        NNTYPE_cid(CLASS_ResultSet)
#define NATYPE_ResultSet        NATYPE_cid(CLASS_ResultSet)
#define CFLAG_ResultSet         ((knh_flag_t)0)
#define FLAG_ResultSet          KNH_FLAG_CF2OF(CFLAG_ResultSet)

/* ------------------------------------------------------------------------ */
/* Exception */
#define CLASS_Exception         ((knh_class_t)35)
#define STRUCT_Exception        ((knh_struct_t)35)
#define IS_Exception(o)         ((o)->h.cid == CLASS_Exception)
#define IS_bException(o)        ((o)->h.bcid == CLASS_Exception)
#define TYPE_Exception          CLASS_Exception
#define NNTYPE_Exception        NNTYPE_cid(CLASS_Exception)
#define NATYPE_Exception        NATYPE_cid(CLASS_Exception)
#define CFLAG_Exception         ((knh_flag_t)0)
#define FLAG_Exception          KNH_FLAG_CF2OF(CFLAG_Exception)

/* ------------------------------------------------------------------------ */
/* ExceptionHandler */
#define CLASS_ExceptionHandler  ((knh_class_t)36)
#define STRUCT_ExceptionHandler ((knh_struct_t)36)
#define IS_ExceptionHandler(o)  ((o)->h.cid == CLASS_ExceptionHandler)
#define IS_bExceptionHandler(o) ((o)->h.bcid == CLASS_ExceptionHandler)
#define TYPE_ExceptionHandler   CLASS_ExceptionHandler
#define NNTYPE_ExceptionHandler NNTYPE_cid(CLASS_ExceptionHandler)
#define NATYPE_ExceptionHandler NATYPE_cid(CLASS_ExceptionHandler)
#define CFLAG_ExceptionHandler  ((knh_flag_t)FLAG_Class_Private)
#define FLAG_ExceptionHandler   KNH_FLAG_CF2OF(CFLAG_ExceptionHandler)

/* ------------------------------------------------------------------------ */
/* Script */
#define CLASS_Script            ((knh_class_t)37)
#define STRUCT_Script           ((knh_struct_t)37)
#define IS_Script(o)            ((o)->h.cid == CLASS_Script)
#define IS_bScript(o)           ((o)->h.bcid == CLASS_Script)
#define TYPE_Script             CLASS_Script
#define NNTYPE_Script           NNTYPE_cid(CLASS_Script)
#define NATYPE_Script           NATYPE_cid(CLASS_Script)
#define CFLAG_Script            ((knh_flag_t)FLAG_Class_Private)
#define FLAG_Script             KNH_FLAG_CF2OF(CFLAG_Script)

/* ------------------------------------------------------------------------ */
/* NameSpace */
#define CLASS_NameSpace         ((knh_class_t)38)
#define STRUCT_NameSpace        ((knh_struct_t)38)
#define IS_NameSpace(o)         ((o)->h.cid == CLASS_NameSpace)
#define IS_bNameSpace(o)        ((o)->h.bcid == CLASS_NameSpace)
#define TYPE_NameSpace          CLASS_NameSpace
#define NNTYPE_NameSpace        NNTYPE_cid(CLASS_NameSpace)
#define NATYPE_NameSpace        NATYPE_cid(CLASS_NameSpace)
#define CFLAG_NameSpace         ((knh_flag_t)0)
#define FLAG_NameSpace          KNH_FLAG_CF2OF(CFLAG_NameSpace)

/* ------------------------------------------------------------------------ */
/* System */
#define CLASS_System            ((knh_class_t)39)
#define STRUCT_System           ((knh_struct_t)39)
#define IS_System(o)            ((o)->h.cid == CLASS_System)
#define IS_bSystem(o)           ((o)->h.bcid == CLASS_System)
#define TYPE_System             CLASS_System
#define NNTYPE_System           NNTYPE_cid(CLASS_System)
#define NATYPE_System           NATYPE_cid(CLASS_System)
#define CFLAG_System            ((knh_flag_t)FLAG_Class_Singleton)
#define FLAG_System             KNH_FLAG_CF2OF(CFLAG_System)

/* ------------------------------------------------------------------------ */
/* Context */
#define CLASS_Context           ((knh_class_t)40)
#define STRUCT_Context          ((knh_struct_t)40)
#define IS_Context(o)           ((o)->h.cid == CLASS_Context)
#define IS_bContext(o)          ((o)->h.bcid == CLASS_Context)
#define TYPE_Context            CLASS_Context
#define NNTYPE_Context          NNTYPE_cid(CLASS_Context)
#define NATYPE_Context          NATYPE_cid(CLASS_Context)
#define CFLAG_Context           ((knh_flag_t)0)
#define FLAG_Context            KNH_FLAG_CF2OF(CFLAG_Context)

/* ------------------------------------------------------------------------ */
/* Token */
#define CLASS_Token             ((knh_class_t)41)
#define STRUCT_Token            ((knh_struct_t)41)
#define IS_Token(o)             ((o)->h.cid == CLASS_Token)
#define IS_bToken(o)            ((o)->h.bcid == CLASS_Token)
#define TYPE_Token              CLASS_Token
#define NNTYPE_Token            NNTYPE_cid(CLASS_Token)
#define NATYPE_Token            NATYPE_cid(CLASS_Token)
#define CFLAG_Token             ((knh_flag_t)0)
#define FLAG_Token              KNH_FLAG_CF2OF(CFLAG_Token)

/* ------------------------------------------------------------------------ */
/* Stmt */
#define CLASS_Stmt              ((knh_class_t)42)
#define STRUCT_Stmt             ((knh_struct_t)42)
#define IS_Stmt(o)              ((o)->h.cid == CLASS_Stmt)
#define IS_bStmt(o)             ((o)->h.bcid == CLASS_Stmt)
#define TYPE_Stmt               CLASS_Stmt
#define NNTYPE_Stmt             NNTYPE_cid(CLASS_Stmt)
#define NATYPE_Stmt             NATYPE_cid(CLASS_Stmt)
#define CFLAG_Stmt              ((knh_flag_t)0)
#define FLAG_Stmt               KNH_FLAG_CF2OF(CFLAG_Stmt)

/* ------------------------------------------------------------------------ */
/* Gamma */
#define CLASS_Gamma               ((knh_class_t)43)
#define STRUCT_Gamma              ((knh_struct_t)43)
#define IS_Gamma(o)               ((o)->h.cid == CLASS_Gamma)
#define IS_bGamma(o)              ((o)->h.bcid == CLASS_Gamma)
#define TYPE_Gamma                CLASS_Gamma
#define NNTYPE_Gamma              NNTYPE_cid(CLASS_Gamma)
#define NATYPE_Gamma              NATYPE_cid(CLASS_Gamma)
#define CFLAG_Gamma               ((knh_flag_t)FLAG_Class_Private)
#define FLAG_Gamma                KNH_FLAG_CF2OF(CFLAG_Gamma)

/* ------------------------------------------------------------------------ */
/* KLRCode */
#define CLASS_KLRCode           ((knh_class_t)44)
#define STRUCT_KLRCode          ((knh_struct_t)44)
#define IS_KLRCode(o)           ((o)->h.cid == CLASS_KLRCode)
#define IS_bKLRCode(o)          ((o)->h.bcid == CLASS_KLRCode)
#define TYPE_KLRCode            CLASS_KLRCode
#define NNTYPE_KLRCode          NNTYPE_cid(CLASS_KLRCode)
#define NATYPE_KLRCode          NATYPE_cid(CLASS_KLRCode)
#define CFLAG_KLRCode           ((knh_flag_t)0)
#define FLAG_KLRCode            KNH_FLAG_CF2OF(CFLAG_KLRCode)

/* ------------------------------------------------------------------------ */
/* Any */
#define CLASS_Any               ((knh_class_t)45)
#define STRUCT_Any              ((knh_struct_t)45)
#define IS_Any(o)               ((o)->h.cid == CLASS_Any)
#define IS_bAny(o)              ((o)->h.bcid == CLASS_Any)
#define TYPE_Any                NATYPE_cid(CLASS_Any)
#define NNTYPE_Any              NATYPE_cid(CLASS_Any)
#define NATYPE_Any              NATYPE_cid(CLASS_Any)
#define CFLAG_Any               ((knh_flag_t)0)
#define FLAG_Any                KNH_FLAG_CF2OF(CFLAG_Any)

/* ------------------------------------------------------------------------ */
/* This */
#define CLASS_This              ((knh_class_t)46)
#define STRUCT_This             ((knh_struct_t)46)
#define IS_This(o)              ((o)->h.cid == CLASS_This)
#define IS_bThis(o)             ((o)->h.bcid == CLASS_This)
#define TYPE_This               CLASS_This
#define NNTYPE_This             NNTYPE_cid(CLASS_This)
#define NATYPE_This             NATYPE_cid(CLASS_This)
#define CFLAG_This              ((knh_flag_t)0)
#define FLAG_This               KNH_FLAG_CF2OF(CFLAG_This)

/* ------------------------------------------------------------------------ */
/* Tvoid */
#define CLASS_Tvoid             ((knh_class_t)47)
#define STRUCT_Tvoid            ((knh_struct_t)47)
#define IS_Tvoid(o)             ((o)->h.cid == CLASS_Tvoid)
#define IS_bTvoid(o)            ((o)->h.bcid == CLASS_Tvoid)
#define TYPE_Tvoid              CLASS_Tvoid
#define NNTYPE_Tvoid            NNTYPE_cid(CLASS_Tvoid)
#define NATYPE_Tvoid            NATYPE_cid(CLASS_Tvoid)
#define CFLAG_Tvoid             ((knh_flag_t)0)
#define FLAG_Tvoid              KNH_FLAG_CF2OF(CFLAG_Tvoid)

/* ------------------------------------------------------------------------ */
/* T0 */
#define CLASS_T0                ((knh_class_t)48)
#define STRUCT_T0               ((knh_struct_t)48)
#define IS_T0(o)                ((o)->h.cid == CLASS_T0)
#define IS_bT0(o)               ((o)->h.bcid == CLASS_T0)
#define TYPE_T0                 CLASS_T0
#define NNTYPE_T0               NNTYPE_cid(CLASS_T0)
#define NATYPE_T0               NATYPE_cid(CLASS_T0)
#define CFLAG_T0                ((knh_flag_t)0)
#define FLAG_T0                 KNH_FLAG_CF2OF(CFLAG_T0)

/* ------------------------------------------------------------------------ */
/* T1 */
#define CLASS_T1                ((knh_class_t)49)
#define STRUCT_T1               ((knh_struct_t)49)
#define IS_T1(o)                ((o)->h.cid == CLASS_T1)
#define IS_bT1(o)               ((o)->h.bcid == CLASS_T1)
#define TYPE_T1                 CLASS_T1
#define NNTYPE_T1               NNTYPE_cid(CLASS_T1)
#define NATYPE_T1               NATYPE_cid(CLASS_T1)
#define CFLAG_T1                ((knh_flag_t)0)
#define FLAG_T1                 KNH_FLAG_CF2OF(CFLAG_T1)

/* ------------------------------------------------------------------------ */
/* T2 */
#define CLASS_T2                ((knh_class_t)50)
#define STRUCT_T2               ((knh_struct_t)50)
#define IS_T2(o)                ((o)->h.cid == CLASS_T2)
#define IS_bT2(o)               ((o)->h.bcid == CLASS_T2)
#define TYPE_T2                 CLASS_T2
#define NNTYPE_T2               NNTYPE_cid(CLASS_T2)
#define NATYPE_T2               NATYPE_cid(CLASS_T2)
#define CFLAG_T2                ((knh_flag_t)0)
#define FLAG_T2                 KNH_FLAG_CF2OF(CFLAG_T2)

/* ------------------------------------------------------------------------ */
/* T3 */
#define CLASS_T3                ((knh_class_t)51)
#define STRUCT_T3               ((knh_struct_t)51)
#define IS_T3(o)                ((o)->h.cid == CLASS_T3)
#define IS_bT3(o)               ((o)->h.bcid == CLASS_T3)
#define TYPE_T3                 CLASS_T3
#define NNTYPE_T3               NNTYPE_cid(CLASS_T3)
#define NATYPE_T3               NATYPE_cid(CLASS_T3)
#define CFLAG_T3                ((knh_flag_t)0)
#define FLAG_T3                 KNH_FLAG_CF2OF(CFLAG_T3)

/* ------------------------------------------------------------------------ */
/* Tvar */
#define CLASS_Tvar              ((knh_class_t)52)
#define STRUCT_Tvar             ((knh_struct_t)52)
#define IS_Tvar(o)              ((o)->h.cid == CLASS_Tvar)
#define IS_bTvar(o)             ((o)->h.bcid == CLASS_Tvar)
#define TYPE_Tvar               CLASS_Tvar
#define NNTYPE_Tvar             NNTYPE_cid(CLASS_Tvar)
#define NATYPE_Tvar             NATYPE_cid(CLASS_Tvar)
#define CFLAG_Tvar              ((knh_flag_t)0)
#define FLAG_Tvar               KNH_FLAG_CF2OF(CFLAG_Tvar)

/* ======================================================================== */
/* CLASS */

/* ------------------------------------------------------------------------ */
/* Object */
#define CLASS_Object            ((knh_class_t)0)
#define STRUCT_Object           ((knh_struct_t)0)
#define IS_Object(o)            ((o)->h.cid == CLASS_Object)
#define TYPE_Object             CLASS_Object
#define NNTYPE_Object           NNTYPE_cid(CLASS_Object)
#define NATYPE_Object           NATYPE_cid(CLASS_Object)
#define CFLAG_Object            ((knh_flag_t)0)
#define FLAG_Object             KNH_FLAG_CF2OF(CFLAG_Object)

/* ------------------------------------------------------------------------ */
/* Pair */
#define CLASS_Pair              ((knh_class_t)KNH_TCLASS_SIZE-(1+1))
#define STRUCT_Pair             STRUCT_String
#define IS_Pair(o)              ((o)->h.cid == CLASS_Pair)
#define TYPE_Pair               CLASS_Pair
#define NNTYPE_Pair             NNTYPE_cid(CLASS_Pair)
#define NATYPE_Pair             NATYPE_cid(CLASS_Pair)
#define CFLAG_Pair              ((knh_flag_t)0)
#define FLAG_Pair               KNH_FLAG_CF2OF(CFLAG_Pair)

/* ------------------------------------------------------------------------ */
/* Pair */
#define CLASS_Pair              ((knh_class_t)KNH_TCLASS_SIZE-(2+1))
#define STRUCT_Pair             STRUCT_String
#define IS_Pair(o)              ((o)->h.cid == CLASS_Pair)
#define TYPE_Pair               CLASS_Pair
#define NNTYPE_Pair             NNTYPE_cid(CLASS_Pair)
#define NATYPE_Pair             NATYPE_cid(CLASS_Pair)
#define CFLAG_Pair              ((knh_flag_t)0)
#define FLAG_Pair               KNH_FLAG_CF2OF(CFLAG_Pair)

/* ------------------------------------------------------------------------ */
/* Pair */
#define CLASS_Pair              ((knh_class_t)KNH_TCLASS_SIZE-(3+1))
#define STRUCT_Pair             STRUCT_T1
#define IS_Pair(o)              ((o)->h.cid == CLASS_Pair)
#define TYPE_Pair               CLASS_Pair
#define NNTYPE_Pair             NNTYPE_cid(CLASS_Pair)
#define NATYPE_Pair             NATYPE_cid(CLASS_Pair)
#define CFLAG_Pair              ((knh_flag_t)0)
#define FLAG_Pair               KNH_FLAG_CF2OF(CFLAG_Pair)

/* ------------------------------------------------------------------------ */
/* Closure */
#define CLASS_Closure           ((knh_class_t)KNH_TCLASS_SIZE-(4+1))
#define STRUCT_Closure          STRUCT_Int!
#define IS_Closure(o)           ((o)->h.cid == CLASS_Closure)
#define TYPE_Closure            CLASS_Closure
#define NNTYPE_Closure          NNTYPE_cid(CLASS_Closure)
#define NATYPE_Closure          NATYPE_cid(CLASS_Closure)
#define CFLAG_Closure           ((knh_flag_t)0)
#define FLAG_Closure            KNH_FLAG_CF2OF(CFLAG_Closure)

/* ======================================================================== */
/* FLAG */
#define FLAG_Object_Release             (knh_flag_t)(1<<0)

#define knh_Object_isRelease(o)  (((o)->h.flag & FLAG_Object_Release) == FLAG_Object_Release)
#define knh_Object_isDebug(o)  (((o)->h.flag & FLAG_Object_Release) != FLAG_Object_Release)#define FLAG_Object_Immutable           (knh_flag_t)(1<<1)

#define knh_Object_isImmutable(o)  (((o)->h.flag & FLAG_Object_Immutable) == FLAG_Object_Immutable)#define FLAG_Object_Cyclic              (knh_flag_t)(1<<2)

#define knh_Object_isCyclic(o)  (((o)->h.flag & FLAG_Object_Cyclic) == FLAG_Object_Cyclic)
#define knh_Object_setCyclic(o,b) if(b) (o)->h.flag |= FLAG_Object_Cyclic; else (o)->h.flag &= ~(FLAG_Object_Cyclic);#define FLAG_Object_Undefined           (knh_flag_t)(1<<3)

#define knh_Object_isUndefined(o)  (((o)->h.flag & FLAG_Object_Undefined) == FLAG_Object_Undefined)#define FLAG_Object_Modified            (knh_flag_t)(1<<4)

#define knh_Object_isModified(o)  (((o)->h.flag & FLAG_Object_Modified) == FLAG_Object_Modified)
#define knh_Object_setModified(o,b) if(b) (o)->h.flag |= FLAG_Object_Modified; else (o)->h.flag &= ~(FLAG_Object_Modified);#define FLAG_Object_Shared              (knh_flag_t)(1<<5)

#define knh_Object_isShared(o)  (((o)->h.flag & FLAG_Object_Shared) == FLAG_Object_Shared)
#define knh_Object_setShared(o,b) if(b) (o)->h.flag |= FLAG_Object_Shared; else (o)->h.flag &= ~(FLAG_Object_Shared);#define FLAG_Object_Local4              (knh_flag_t)(1<<11)

#define knh_Object_isLocal4(o)  (((o)->h.flag & FLAG_Object_Local4) == FLAG_Object_Local4)
#define knh_Object_setLocal4(o,b) if(b) (o)->h.flag |= FLAG_Object_Local4; else (o)->h.flag &= ~(FLAG_Object_Local4);#define FLAG_Object_Local3              (knh_flag_t)(1<<12)

#define knh_Object_isLocal3(o)  (((o)->h.flag & FLAG_Object_Local3) == FLAG_Object_Local3)
#define knh_Object_setLocal3(o,b) if(b) (o)->h.flag |= FLAG_Object_Local3; else (o)->h.flag &= ~(FLAG_Object_Local3);#define FLAG_Object_Local2              (knh_flag_t)(1<<13)

#define knh_Object_isLocal2(o)  (((o)->h.flag & FLAG_Object_Local2) == FLAG_Object_Local2)
#define knh_Object_setLocal2(o,b) if(b) (o)->h.flag |= FLAG_Object_Local2; else (o)->h.flag &= ~(FLAG_Object_Local2);#define FLAG_Object_Local1              (knh_flag_t)(1<<14)

#define knh_Object_isLocal1(o)  (((o)->h.flag & FLAG_Object_Local1) == FLAG_Object_Local1)
#define knh_Object_setLocal1(o,b) if(b) (o)->h.flag |= FLAG_Object_Local1; else (o)->h.flag &= ~(FLAG_Object_Local1);#define FLAG_String_TextSgm             FLAG_Object_Local1

#define knh_String_isTextSgm(o)  (((o)->h.flag & FLAG_String_TextSgm) == FLAG_String_TextSgm)
#define knh_String_setTextSgm(o,b) if(b) (o)->h.flag |= FLAG_String_TextSgm; else (o)->h.flag &= ~(FLAG_String_TextSgm);#define FLAG_String_Ascii               FLAG_Object_Local2

#define knh_String_isAscii(o)  (((o)->h.flag & FLAG_String_Ascii) == FLAG_String_Ascii)
#define knh_String_setAscii(o,b) if(b) (o)->h.flag |= FLAG_String_Ascii; else (o)->h.flag &= ~(FLAG_String_Ascii);#define FLAG_Tuple_Triple               FLAG_Object_Local1

#define knh_Tuple_isTriple(o)  (((o)->h.flag & FLAG_Tuple_Triple) == FLAG_Tuple_Triple)
#define knh_Tuple_setTriple(o,b) if(b) (o)->h.flag |= FLAG_Tuple_Triple; else (o)->h.flag &= ~(FLAG_Tuple_Triple);#define FLAG_Range_Inclusive            FLAG_Object_Local1

#define knh_Range_isInclusive(o)  (((o)->h.flag & FLAG_Range_Inclusive) == FLAG_Range_Inclusive)
#define knh_Range_setInclusive(o,b) if(b) (o)->h.flag |= FLAG_Range_Inclusive; else (o)->h.flag &= ~(FLAG_Range_Inclusive);#define FLAG_Array_Dimension            FLAG_Object_Local1

#define knh_Array_hasDimension(o)  (((o)->h.flag & FLAG_Array_Dimension) == FLAG_Array_Dimension)
#define knh_Array_setDimension(o,b) if(b) (o)->h.flag |= FLAG_Array_Dimension; else (o)->h.flag &= ~(FLAG_Array_Dimension);#define FLAG_IArray_Dimension           FLAG_Object_Local1

#define knh_IArray_hasDimension(o)  (((o)->h.flag & FLAG_IArray_Dimension) == FLAG_IArray_Dimension)
#define knh_IArray_setDimension(o,b) if(b) (o)->h.flag |= FLAG_IArray_Dimension; else (o)->h.flag &= ~(FLAG_IArray_Dimension);#define FLAG_FArray_Dimension           FLAG_Object_Local1

#define knh_FArray_hasDimension(o)  (((o)->h.flag & FLAG_FArray_Dimension) == FLAG_FArray_Dimension)
#define knh_FArray_setDimension(o,b) if(b) (o)->h.flag |= FLAG_FArray_Dimension; else (o)->h.flag &= ~(FLAG_FArray_Dimension);#define FLAG_DictMap_IgnoreCase         FLAG_Object_Local1

#define knh_DictMap_isIgnoreCase(o)  (((o)->h.flag & FLAG_DictMap_IgnoreCase) == FLAG_DictMap_IgnoreCase)
#define knh_DictMap_setIgnoreCase(o,b) if(b) (o)->h.flag |= FLAG_DictMap_IgnoreCase; else (o)->h.flag &= ~(FLAG_DictMap_IgnoreCase);#define FLAG_DictSet_IgnoreCase         FLAG_Object_Local1

#define knh_DictSet_isIgnoreCase(o)  (((o)->h.flag & FLAG_DictSet_IgnoreCase) == FLAG_DictSet_IgnoreCase)
#define knh_DictSet_setIgnoreCase(o,b) if(b) (o)->h.flag |= FLAG_DictSet_IgnoreCase; else (o)->h.flag &= ~(FLAG_DictSet_IgnoreCase);#define FLAG_Class_Release              (knh_flag_t)(1<<0)

#define knh_class_isRelease(o)  (((pClassTable(o))->cflag & FLAG_Class_Release) == FLAG_Class_Release)
#define knh_class_isDebug(o)  (((pClassTable(o))->cflag & FLAG_Class_Release) != FLAG_Class_Release)#define FLAG_Class_Immutable            (knh_flag_t)(1<<1)

#define knh_class_isImmutable(o)  (((pClassTable(o))->cflag & FLAG_Class_Immutable) == FLAG_Class_Immutable)#define FLAG_Class_Cyclic               (knh_flag_t)(1<<2)

#define knh_class_isCyclic(o)  (((pClassTable(o))->cflag & FLAG_Class_Cyclic) == FLAG_Class_Cyclic)
#define knh_class_setCyclic(o,b) if(b) (pClassTable(o))->cflag |= FLAG_Class_Cyclic; else (pClassTable(o))->cflag &= ~(FLAG_Class_Cyclic);#define FLAG_Class_MetaClass            (knh_flag_t)(1<<3)

#define knh_class_isMetaClass(o)  (((pClassTable(o))->cflag & FLAG_Class_MetaClass) == FLAG_Class_MetaClass)#define FLAG_Class_Private              (knh_flag_t)(1<<4)

#define knh_class_isPrivate(o)  (((pClassTable(o))->cflag & FLAG_Class_Private) == FLAG_Class_Private)
#define knh_class_isPublic(o)  (((pClassTable(o))->cflag & FLAG_Class_Private) != FLAG_Class_Private)#define FLAG_Class_Final                (knh_flag_t)(1<<5)

#define knh_class_isFinal(o)  (((pClassTable(o))->cflag & FLAG_Class_Final) == FLAG_Class_Final)#define FLAG_Class_Singleton            (knh_flag_t)(1<<6)

#define knh_class_isSingleton(o)  (((pClassTable(o))->cflag & FLAG_Class_Singleton) == FLAG_Class_Singleton)#define FLAG_Class_Interface            (knh_flag_t)(1<<7)

#define knh_class_isInterface(o)  (((pClassTable(o))->cflag & FLAG_Class_Interface) == FLAG_Class_Interface)#define FLAG_Class_TypeVariable         (knh_flag_t)(1<<8)

#define knh_class_isTypeVariable(o)  (((pClassTable(o))->cflag & FLAG_Class_TypeVariable) == FLAG_Class_TypeVariable)
#define knh_class_setTypeVariable(o,b) if(b) (pClassTable(o))->cflag |= FLAG_Class_TypeVariable; else (pClassTable(o))->cflag &= ~(FLAG_Class_TypeVariable);#define FLAG_ClassStruct_Hidden         (knh_flag_t)(1<<0)

#define knh_ClassStruct_isHidden(o,n)  (((o)->fields[n].flag & FLAG_ClassStruct_Hidden) == FLAG_ClassStruct_Hidden)
#define knh_ClassStruct_setHidden(o,n,b) if(b) (o)->fields[n].flag |= FLAG_ClassStruct_Hidden; else (o)->fields[n].flag &= ~(FLAG_ClassStruct_Hidden);#define FLAG_ClassStruct_Protected      (knh_flag_t)(1<<1)

#define knh_ClassStruct_isProtected(o,n)  (((o)->fields[n].flag & FLAG_ClassStruct_Protected) == FLAG_ClassStruct_Protected)
#define knh_ClassStruct_setProtected(o,n,b) if(b) (o)->fields[n].flag |= FLAG_ClassStruct_Protected; else (o)->fields[n].flag &= ~(FLAG_ClassStruct_Protected);#define FLAG_ClassStruct_Getter         (knh_flag_t)(1<<2)

#define knh_ClassStruct_isGetter(o,n)  (((o)->fields[n].flag & FLAG_ClassStruct_Getter) == FLAG_ClassStruct_Getter)
#define knh_ClassStruct_setGetter(o,n,b) if(b) (o)->fields[n].flag |= FLAG_ClassStruct_Getter; else (o)->fields[n].flag &= ~(FLAG_ClassStruct_Getter);#define FLAG_ClassStruct_Setter         (knh_flag_t)(1<<3)

#define knh_ClassStruct_isSetter(o,n)  (((o)->fields[n].flag & FLAG_ClassStruct_Setter) == FLAG_ClassStruct_Setter)
#define knh_ClassStruct_setSetter(o,n,b) if(b) (o)->fields[n].flag |= FLAG_ClassStruct_Setter; else (o)->fields[n].flag &= ~(FLAG_ClassStruct_Setter);#define FLAG_ClassStruct_Key            (knh_flag_t)(1<<4)

#define knh_ClassStruct_isKey(o,n)  (((o)->fields[n].flag & FLAG_ClassStruct_Key) == FLAG_ClassStruct_Key)
#define knh_ClassStruct_setKey(o,n,b) if(b) (o)->fields[n].flag |= FLAG_ClassStruct_Key; else (o)->fields[n].flag &= ~(FLAG_ClassStruct_Key);#define FLAG_Method_Private             (knh_flag_t)(1<<0)

#define knh_Method_isPrivate(o)  ((DP(o)->flag & FLAG_Method_Private) == FLAG_Method_Private)
#define knh_Method_isPublic(o)  ((DP(o)->flag & FLAG_Method_Private) != FLAG_Method_Private)
#define knh_Method_setPrivate(o,b) if(b) DP(o)->flag |= FLAG_Method_Private; else DP(o)->flag &= ~(FLAG_Method_Private);
#define knh_Method_setPublic(o,b)  if(b) DP(o)->flag &= ~(FLAG_Method_Private); else DP(o)->flag |= FLAG_Method_Private;#define FLAG_Method_Virtual             (knh_flag_t)(1<<1)

#define knh_Method_isVirtual(o)  ((DP(o)->flag & FLAG_Method_Virtual) == FLAG_Method_Virtual)
#define knh_Method_isFinal(o)  ((DP(o)->flag & FLAG_Method_Virtual) != FLAG_Method_Virtual)
#define knh_Method_setVirtual(o,b) if(b) DP(o)->flag |= FLAG_Method_Virtual; else DP(o)->flag &= ~(FLAG_Method_Virtual);
#define knh_Method_setFinal(o,b)  if(b) DP(o)->flag &= ~(FLAG_Method_Virtual); else DP(o)->flag |= FLAG_Method_Virtual;#define FLAG_Method_Release             (knh_flag_t)(1<<2)

#define knh_Method_isRelease(o)  ((DP(o)->flag & FLAG_Method_Release) == FLAG_Method_Release)
#define knh_Method_isDebug(o)  ((DP(o)->flag & FLAG_Method_Release) != FLAG_Method_Release)
#define knh_Method_setRelease(o,b) if(b) DP(o)->flag |= FLAG_Method_Release; else DP(o)->flag &= ~(FLAG_Method_Release);
#define knh_Method_setDebug(o,b)  if(b) DP(o)->flag &= ~(FLAG_Method_Release); else DP(o)->flag |= FLAG_Method_Release;#define FLAG_Method_Const               (knh_flag_t)(1<<3)

#define knh_Method_isConst(o)  ((DP(o)->flag & FLAG_Method_Const) == FLAG_Method_Const)#define FLAG_Method_Static              (knh_flag_t)(1<<4)

#define knh_Method_isStatic(o)  ((DP(o)->flag & FLAG_Method_Static) == FLAG_Method_Static)#define FLAG_Method_NullBase            (knh_flag_t)(1<<5)

#define knh_Method_isNullBase(o)  ((DP(o)->flag & FLAG_Method_NullBase) == FLAG_Method_NullBase)#define FLAG_Method_VarArgs             (knh_flag_t)(1<<6)

#define knh_Method_isVarArgs(o)  ((DP(o)->flag & FLAG_Method_VarArgs) == FLAG_Method_VarArgs)
#define knh_Method_setVarArgs(o,b) if(b) DP(o)->flag |= FLAG_Method_VarArgs; else DP(o)->flag &= ~(FLAG_Method_VarArgs);#define FLAG_Method_Generator           (knh_flag_t)(1<<7)

#define knh_Method_isGenerator(o)  ((DP(o)->flag & FLAG_Method_Generator) == FLAG_Method_Generator)
#define knh_Method_setGenerator(o,b) if(b) DP(o)->flag |= FLAG_Method_Generator; else DP(o)->flag &= ~(FLAG_Method_Generator);#define FLAG_Method_Aspect              (knh_flag_t)(1<<8)

#define knh_Method_isAspect(o)  ((DP(o)->flag & FLAG_Method_Aspect) == FLAG_Method_Aspect)
#define knh_Method_setAspect(o,b) if(b) DP(o)->flag |= FLAG_Method_Aspect; else DP(o)->flag &= ~(FLAG_Method_Aspect);#define FLAG_Method_ObjectCode          (knh_flag_t)(1<<9)

#define knh_Method_isObjectCode(o)  ((DP(o)->flag & FLAG_Method_ObjectCode) == FLAG_Method_ObjectCode)
#define knh_Method_setObjectCode(o,b) if(b) DP(o)->flag |= FLAG_Method_ObjectCode; else DP(o)->flag &= ~(FLAG_Method_ObjectCode);#define FLAG_Method_Hidden              (knh_flag_t)(1<<10)

#define knh_Method_isHidden(o)  ((DP(o)->flag & FLAG_Method_Hidden) == FLAG_Method_Hidden)
#define knh_Method_setHidden(o,b) if(b) DP(o)->flag |= FLAG_Method_Hidden; else DP(o)->flag &= ~(FLAG_Method_Hidden);#define FLAG_Method_Tricky              (knh_flag_t)(1<<11)

#define knh_Method_isTricky(o)  ((DP(o)->flag & FLAG_Method_Tricky) == FLAG_Method_Tricky)
#define knh_Method_setTricky(o,b) if(b) DP(o)->flag |= FLAG_Method_Tricky; else DP(o)->flag &= ~(FLAG_Method_Tricky);#define FLAG_Mapper_Interface           (knh_flag_t)(1<<0)

#define knh_Mapper_isInterface(o)  ((DP(o)->flag & FLAG_Mapper_Interface) == FLAG_Mapper_Interface)
#define knh_Mapper_setInterface(o,b) if(b) DP(o)->flag |= FLAG_Mapper_Interface; else DP(o)->flag &= ~(FLAG_Mapper_Interface);#define FLAG_Mapper_ICast               (knh_flag_t)(1<<1)

#define knh_Mapper_isICast(o)  ((DP(o)->flag & FLAG_Mapper_ICast) == FLAG_Mapper_ICast)#define FLAG_Mapper_Significant         (knh_flag_t)(1<<2)

#define knh_Mapper_isSignificant(o)  ((DP(o)->flag & FLAG_Mapper_Significant) == FLAG_Mapper_Significant)
#define knh_Mapper_setSignificant(o,b) if(b) DP(o)->flag |= FLAG_Mapper_Significant; else DP(o)->flag &= ~(FLAG_Mapper_Significant);#define FLAG_Mapper_Final               (knh_flag_t)(1<<3)

#define knh_Mapper_isFinal(o)  ((DP(o)->flag & FLAG_Mapper_Final) == FLAG_Mapper_Final)
#define knh_Mapper_isFinal(o,b) if(b) DP(o)->flag |= FLAG_Mapper_Final; else DP(o)->flag &= ~(FLAG_Mapper_Final);#define FLAG_Mapper_Synonym             (knh_flag_t)(1<<4)

#define knh_Mapper_isSynonym(o)  ((DP(o)->flag & FLAG_Mapper_Synonym) == FLAG_Mapper_Synonym)
#define knh_Mapper_setSynonym(o,b) if(b) DP(o)->flag |= FLAG_Mapper_Synonym; else DP(o)->flag &= ~(FLAG_Mapper_Synonym);#define FLAG_Mapper_LossLess            (knh_flag_t)(1<<5)

#define knh_Mapper_isLossLess(o)  ((DP(o)->flag & FLAG_Mapper_LossLess) == FLAG_Mapper_LossLess)
#define knh_Mapper_setLossLess(o,b) if(b) DP(o)->flag |= FLAG_Mapper_LossLess; else DP(o)->flag &= ~(FLAG_Mapper_LossLess);#define FLAG_Mapper_Total               (knh_flag_t)(1<<6)

#define knh_Mapper_isTotal(o)  ((DP(o)->flag & FLAG_Mapper_Total) == FLAG_Mapper_Total)
#define knh_Mapper_isPartial(o)  ((DP(o)->flag & FLAG_Mapper_Total) != FLAG_Mapper_Total)
#define knh_Mapper_setTotal(o,b) if(b) DP(o)->flag |= FLAG_Mapper_Total; else DP(o)->flag &= ~(FLAG_Mapper_Total);
#define knh_Mapper_setPartial(o,b)  if(b) DP(o)->flag &= ~(FLAG_Mapper_Total); else DP(o)->flag |= FLAG_Mapper_Total;#define FLAG_Mapper_Const               (knh_flag_t)(1<<7)

#define knh_Mapper_isConst(o)  ((DP(o)->flag & FLAG_Mapper_Const) == FLAG_Mapper_Const)
#define knh_Mapper_isTemporal(o)  ((DP(o)->flag & FLAG_Mapper_Const) != FLAG_Mapper_Const)
#define knh_Mapper_setConst(o,b) if(b) DP(o)->flag |= FLAG_Mapper_Const; else DP(o)->flag &= ~(FLAG_Mapper_Const);
#define knh_Mapper_setTemporal(o,b)  if(b) DP(o)->flag &= ~(FLAG_Mapper_Const); else DP(o)->flag |= FLAG_Mapper_Const;#define FLAG_Mapper_Local               (knh_flag_t)(1<<8)

#define knh_Mapper_isLocal(o)  ((DP(o)->flag & FLAG_Mapper_Local) == FLAG_Mapper_Local)
#define knh_Mapper_setLocal(o,b) if(b) DP(o)->flag |= FLAG_Mapper_Local; else DP(o)->flag &= ~(FLAG_Mapper_Local);#define FLAG_Mapper_Derived             (knh_flag_t)(1<<9)

#define knh_Mapper_isDerived(o)  ((DP(o)->flag & FLAG_Mapper_Derived) == FLAG_Mapper_Derived)
#define knh_Mapper_setDerived(o,b) if(b) DP(o)->flag |= FLAG_Mapper_Derived; else DP(o)->flag &= ~(FLAG_Mapper_Derived);#define FLAG_Mapper_MapMap              (knh_flag_t)(1<<10)

#define knh_Mapper_isMapMap(o)  ((DP(o)->flag & FLAG_Mapper_MapMap) == FLAG_Mapper_MapMap)
#define knh_Mapper_setMapMap(o,b) if(b) DP(o)->flag |= FLAG_Mapper_MapMap; else DP(o)->flag &= ~(FLAG_Mapper_MapMap);#define FLAG_ClassMap_Sorted            FLAG_Object_Local1

#define knh_ClassMap_isSorted(o)  (((o)->h.flag & FLAG_ClassMap_Sorted) == FLAG_ClassMap_Sorted)
#define knh_ClassMap_setSorted(o,b) if(b) (o)->h.flag |= FLAG_ClassMap_Sorted; else (o)->h.flag &= ~(FLAG_ClassMap_Sorted);#define FLAG_Closure_StoredEnv          FLAG_Object_Local1

#define knh_Closure_isStoredEnv(o)  (((o)->h.flag & FLAG_Closure_StoredEnv) == FLAG_Closure_StoredEnv)
#define knh_Closure_setStoredEnv(o,b) if(b) (o)->h.flag |= FLAG_Closure_StoredEnv; else (o)->h.flag &= ~(FLAG_Closure_StoredEnv);#define FLAG_InputStream_FILE           FLAG_Object_Local1

#define knh_InputStream_isFILE(o)  (((o)->h.flag & FLAG_InputStream_FILE) == FLAG_InputStream_FILE)
#define knh_InputStream_setFILE(o,b) if(b) (o)->h.flag |= FLAG_InputStream_FILE; else (o)->h.flag &= ~(FLAG_InputStream_FILE);#define FLAG_OutputStream_BOL           FLAG_Object_Local1

#define knh_OutputStream_isBOL(o)  (((o)->h.flag & FLAG_OutputStream_BOL) == FLAG_OutputStream_BOL)
#define knh_OutputStream_setBOL(o,b) if(b) (o)->h.flag |= FLAG_OutputStream_BOL; else (o)->h.flag &= ~(FLAG_OutputStream_BOL);#define FLAG_OutputStream_AutoFlush     FLAG_Object_Local2

#define knh_OutputStream_isAutoFlush(o)  (((o)->h.flag & FLAG_OutputStream_AutoFlush) == FLAG_OutputStream_AutoFlush)
#define knh_OutputStream_setAutoFlush(o,b) if(b) (o)->h.flag |= FLAG_OutputStream_AutoFlush; else (o)->h.flag &= ~(FLAG_OutputStream_AutoFlush);#define FLAG_OutputStream_StoringBuffer FLAG_Object_Local3

#define knh_OutputStream_isStoringBuffer(o)  (((o)->h.flag & FLAG_OutputStream_StoringBuffer) == FLAG_OutputStream_StoringBuffer)
#define knh_OutputStream_setStoringBuffer(o,b) if(b) (o)->h.flag |= FLAG_OutputStream_StoringBuffer; else (o)->h.flag &= ~(FLAG_OutputStream_StoringBuffer);#define FLAG_Exception_Logging          (knh_flag_t)(1<<0)

#define knh_Exception_isLogging(o)  ((DP(o)->flag & FLAG_Exception_Logging) == FLAG_Exception_Logging)#define FLAG_Exception_Caught           (knh_flag_t)(1<<1)

#define knh_Exception_isCaught(o)  ((DP(o)->flag & FLAG_Exception_Caught) == FLAG_Exception_Caught)
#define knh_Exception_setCaught(o,b) if(b) DP(o)->flag |= FLAG_Exception_Caught; else DP(o)->flag &= ~(FLAG_Exception_Caught);#define FLAG_ExceptionHandler_Jumpable  FLAG_Object_Local1

#define knh_ExceptionHandler_isJumpable(o)  (((o)->h.flag & FLAG_ExceptionHandler_Jumpable) == FLAG_ExceptionHandler_Jumpable)
#define knh_ExceptionHandler_setJumpable(o,b) if(b) (o)->h.flag |= FLAG_ExceptionHandler_Jumpable; else (o)->h.flag &= ~(FLAG_ExceptionHandler_Jumpable);#define FLAG_ExceptionHandler_Catching  FLAG_Object_Local2

#define knh_ExceptionHandler_isCatching(o)  (((o)->h.flag & FLAG_ExceptionHandler_Catching) == FLAG_ExceptionHandler_Catching)
#define knh_ExceptionHandler_setCatching(o,b) if(b) (o)->h.flag |= FLAG_ExceptionHandler_Catching; else (o)->h.flag &= ~(FLAG_ExceptionHandler_Catching);#define FLAG_Context_Strict             (knh_flag_t)(1<<0)

#define knh_Context_isStrict(o)  ((((Context*)o)->flag & FLAG_Context_Strict) == FLAG_Context_Strict)
#define knh_Context_setStrict(o,b) if(b) ((Context*)o)->flag |= FLAG_Context_Strict; else ((Context*)o)->flag &= ~(FLAG_Context_Strict);#define FLAG_Context_Debug              (knh_flag_t)(1<<1)

#define knh_Context_isDebug(o)  ((((Context*)o)->flag & FLAG_Context_Debug) == FLAG_Context_Debug)
#define knh_Context_setDebug(o,b) if(b) ((Context*)o)->flag |= FLAG_Context_Debug; else ((Context*)o)->flag &= ~(FLAG_Context_Debug);#define FLAG_Context_Verbose            (knh_flag_t)(1<<2)

#define knh_Context_isVerbose(o)  ((((Context*)o)->flag & FLAG_Context_Verbose) == FLAG_Context_Verbose)
#define knh_Context_setVerbose(o,b) if(b) ((Context*)o)->flag |= FLAG_Context_Verbose; else ((Context*)o)->flag &= ~(FLAG_Context_Verbose);#define FLAG_Context_Interactive        (knh_flag_t)(1<<3)

#define knh_Context_isInteractive(o)  ((((Context*)o)->flag & FLAG_Context_Interactive) == FLAG_Context_Interactive)
#define knh_Context_setInteractive(o,b) if(b) ((Context*)o)->flag |= FLAG_Context_Interactive; else ((Context*)o)->flag &= ~(FLAG_Context_Interactive);#define FLAG_Context_Compiling          (knh_flag_t)(1<<4)

#define knh_Context_isCompiling(o)  ((((Context*)o)->flag & FLAG_Context_Compiling) == FLAG_Context_Compiling)
#define knh_Context_setCompiling(o,b) if(b) ((Context*)o)->flag |= FLAG_Context_Compiling; else ((Context*)o)->flag &= ~(FLAG_Context_Compiling);#define FLAG_Token_BOL                  (knh_flag_t)(1<<0)

#define knh_Token_isBOL(o)  ((SP(o)->flag & FLAG_Token_BOL) == FLAG_Token_BOL)
#define knh_Token_setBOL(o,b) if(b) SP(o)->flag |= FLAG_Token_BOL; else SP(o)->flag &= ~(FLAG_Token_BOL);#define FLAG_Token_TailWildCard         (knh_flag_t)(1<<1)

#define knh_Token_isTailWildCard(o)  ((SP(o)->flag & FLAG_Token_TailWildCard) == FLAG_Token_TailWildCard)
#define knh_Token_setTailWildCard(o,b) if(b) SP(o)->flag |= FLAG_Token_TailWildCard; else SP(o)->flag &= ~(FLAG_Token_TailWildCard);#define FLAG_Token_TopDot               (knh_flag_t)(1<<2)

#define knh_Token_isTopDot(o)  ((SP(o)->flag & FLAG_Token_TopDot) == FLAG_Token_TopDot)
#define knh_Token_setTopDot(o,b) if(b) SP(o)->flag |= FLAG_Token_TopDot; else SP(o)->flag &= ~(FLAG_Token_TopDot);#define FLAG_Token_Getter               (knh_flag_t)(1<<3)

#define knh_Token_isGetter(o)  ((SP(o)->flag & FLAG_Token_Getter) == FLAG_Token_Getter)
#define knh_Token_setGetter(o,b) if(b) SP(o)->flag |= FLAG_Token_Getter; else SP(o)->flag &= ~(FLAG_Token_Getter);#define FLAG_Token_Setter               (knh_flag_t)(1<<4)

#define knh_Token_isSetter(o)  ((SP(o)->flag & FLAG_Token_Setter) == FLAG_Token_Setter)
#define knh_Token_setSetter(o,b) if(b) SP(o)->flag |= FLAG_Token_Setter; else SP(o)->flag &= ~(FLAG_Token_Setter);#define FLAG_Token_ExceptionType        (knh_flag_t)(1<<5)

#define knh_Token_isExceptionType(o)  ((SP(o)->flag & FLAG_Token_ExceptionType) == FLAG_Token_ExceptionType)
#define knh_Token_setExceptionType(o,b) if(b) SP(o)->flag |= FLAG_Token_ExceptionType; else SP(o)->flag &= ~(FLAG_Token_ExceptionType);#define FLAG_Token_NotNullType          (knh_flag_t)(1<<6)

#define knh_Token_isNotNullType(o)  ((SP(o)->flag & FLAG_Token_NotNullType) == FLAG_Token_NotNullType)
#define knh_Token_setNotNullType(o,b) if(b) SP(o)->flag |= FLAG_Token_NotNullType; else SP(o)->flag &= ~(FLAG_Token_NotNullType);#define FLAG_Token_NullableType         (knh_flag_t)(1<<7)

#define knh_Token_isNullableType(o)  ((SP(o)->flag & FLAG_Token_NullableType) == FLAG_Token_NullableType)
#define knh_Token_setNullableType(o,b) if(b) SP(o)->flag |= FLAG_Token_NullableType; else SP(o)->flag &= ~(FLAG_Token_NullableType);#define FLAG_Stmt_Adposition            (knh_flag_t)(1<<0)

#define knh_Stmt_isAdposition(o)  ((SP(o)->flag & FLAG_Stmt_Adposition) == FLAG_Stmt_Adposition)
#define knh_Stmt_setAdposition(o,b) if(b) SP(o)->flag |= FLAG_Stmt_Adposition; else SP(o)->flag &= ~(FLAG_Stmt_Adposition);#define FLAG_Stmt_Literal               (knh_flag_t)(1<<1)

#define knh_Stmt_isLiteral(o)  ((SP(o)->flag & FLAG_Stmt_Literal) == FLAG_Stmt_Literal)
#define knh_Stmt_setLiteral(o,b) if(b) SP(o)->flag |= FLAG_Stmt_Literal; else SP(o)->flag &= ~(FLAG_Stmt_Literal);#define FLAG_Stmt_ToReturn              (knh_flag_t)(1<<2)

#define knh_Stmt_isToReturn(o)  ((SP(o)->flag & FLAG_Stmt_ToReturn) == FLAG_Stmt_ToReturn)
#define knh_Stmt_setToReturn(o,b) if(b) SP(o)->flag |= FLAG_Stmt_ToReturn; else SP(o)->flag &= ~(FLAG_Stmt_ToReturn);#define FLAG_Stmt_Untyped               (knh_flag_t)(1<<3)

#define knh_Stmt_isUntyped(o)  ((SP(o)->flag & FLAG_Stmt_Untyped) == FLAG_Stmt_Untyped)
#define knh_Stmt_setUntyped(o,b) if(b) SP(o)->flag |= FLAG_Stmt_Untyped; else SP(o)->flag &= ~(FLAG_Stmt_Untyped);#define FLAG_Stmt_Expr                  (knh_flag_t)(1<<4)

#define knh_Stmt_isExpr(o)  ((SP(o)->flag & FLAG_Stmt_Expr) == FLAG_Stmt_Expr)
#define knh_Stmt_setExpr(o,b) if(b) SP(o)->flag |= FLAG_Stmt_Expr; else SP(o)->flag &= ~(FLAG_Stmt_Expr);#define FLAG_Stmt_Memo1                 (knh_flag_t)(1<<5)

#define knh_Stmt_isMemo1(o)  ((SP(o)->flag & FLAG_Stmt_Memo1) == FLAG_Stmt_Memo1)
#define knh_Stmt_setMemo1(o,b) if(b) SP(o)->flag |= FLAG_Stmt_Memo1; else SP(o)->flag &= ~(FLAG_Stmt_Memo1);#define FLAG_Gamma_Cancelled              (knh_flag_t)(1<<0)

#define knh_Gamma_isCancelled(o)  ((DP(o)->flag & FLAG_Gamma_Cancelled) == FLAG_Gamma_Cancelled)
#define knh_Gamma_setCancelled(o,b) if(b) DP(o)->flag |= FLAG_Gamma_Cancelled; else DP(o)->flag &= ~(FLAG_Gamma_Cancelled);#define FLAG_Gamma_PROCEED                (knh_flag_t)(1<<1)

#define knh_Gamma_hasPROCEED(o)  ((DP(o)->flag & FLAG_Gamma_PROCEED) == FLAG_Gamma_PROCEED)
#define knh_Gamma_foundPROCEED(o,b) if(b) DP(o)->flag |= FLAG_Gamma_PROCEED; else DP(o)->flag &= ~(FLAG_Gamma_PROCEED);#define FLAG_Gamma_RETURN                 (knh_flag_t)(1<<2)

#define knh_Gamma_hasRETURN(o)  ((DP(o)->flag & FLAG_Gamma_RETURN) == FLAG_Gamma_RETURN)
#define knh_Gamma_foundRETURN(o,b) if(b) DP(o)->flag |= FLAG_Gamma_RETURN; else DP(o)->flag &= ~(FLAG_Gamma_RETURN);#define FLAG_Gamma_YEILD                  (knh_flag_t)(1<<3)

#define knh_Gamma_hasYEILD(o)  ((DP(o)->flag & FLAG_Gamma_YEILD) == FLAG_Gamma_YEILD)
#define knh_Gamma_foundYEILD(o,b) if(b) DP(o)->flag |= FLAG_Gamma_YEILD; else DP(o)->flag &= ~(FLAG_Gamma_YEILD);
/* ======================================================================== */
/* EXPT */
#define EXPT_Exception          1
#define EXPT_Fatal              2
#define EXPT_OutOfMemory        3
#define EXPT_Security           4
#define EXPT_Null               5
#define EXPT_OutOfIndex         6
#define EXPT_IO                 7
#define EXPT_Script             8
#define EXPT_Syntax             9
#define EXPT_Type               10
#define EXPT_Assert             11

/* ======================================================================== */
/* FIELDN */
#define FIELDN_         0

/* ======================================================================== */
/* METHODN */

/* ======================================================================== */
/* TS */
#define TS_EMPTY        (ctx->share)->tString[0]
#define TS_TAB          (ctx->share)->tString[1]
#define TS_EOL          (ctx->share)->tString[2]
#define TS_BEGIN        (ctx->share)->tString[3]
#define TS_END          (ctx->share)->tString[4]
#define TS_true         (ctx->share)->tString[5]
#define TS_false        (ctx->share)->tString[6]
#define TS_null         (ctx->share)->tString[7]
#define TS_main         (ctx->share)->tString[8]
#define TS_ENCODING     (ctx->share)->tString[9]
#define TS_DEVNULL      (ctx->share)->tString[10]
#define TS_DEVSTDIN     (ctx->share)->tString[11]
#define TS_DEVSTDERR    (ctx->share)->tString[12]
#define TS_DEVSTDOUT    (ctx->share)->tString[13]
#define TS_ATlabel      (ctx->share)->tString[14]
#define TS_Comment      (ctx->share)->tString[15]
#define TS_LP           (ctx->share)->tString[16]
#define TS_RP           (ctx->share)->tString[17]
#define TS_LB           (ctx->share)->tString[18]
#define TS_RB           (ctx->share)->tString[19]
#define TS_LS           (ctx->share)->tString[20]
#define TS_RS           (ctx->share)->tString[21]

/* ======================================================================== */
/* flag */

static METHOD Object_isRelease(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Object_isRelease((knh_Object_t*)sfp[0].o));
}

static METHOD Object_isDebug(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, !(knh_Object_isRelease((knh_Object_t*)sfp[0].o)));
}

static METHOD Object_isImmutable(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Object_isImmutable((knh_Object_t*)sfp[0].o));
}

static METHOD Object_isUndefined(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Object_isUndefined((knh_Object_t*)sfp[0].o));
}

static METHOD Object_isModified(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Object_isModified((knh_Object_t*)sfp[0].o));
}

static METHOD Object_setModified(Ctx *ctx, knh_sfp_t *sfp)
{
	knh_Object_setModified((knh_Object_t*)sfp[0].o, p_bool(sfp[1]));
	KNH_RETURN_void(ctx, sfp);
}

static METHOD Object_isShared(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Object_isShared((knh_Object_t*)sfp[0].o));
}

static METHOD Object_setShared(Ctx *ctx, knh_sfp_t *sfp)
{
	knh_Object_setShared((knh_Object_t*)sfp[0].o, p_bool(sfp[1]));
	KNH_RETURN_void(ctx, sfp);
}

static METHOD String_isAscii(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_String_isAscii((knh_String_t*)sfp[0].o));
}

static METHOD DictMap_isIgnoreCase(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_DictMap_isIgnoreCase((knh_DictMap_t*)sfp[0].o));
}

static METHOD DictSet_isIgnoreCase(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_DictSet_isIgnoreCase((knh_DictSet_t*)sfp[0].o));
}

static METHOD Class_isRelease(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_class_isRelease(knh_Class_cid(sfp[0].c)));
}

static METHOD Class_isDebug(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, !(knh_class_isRelease(knh_Class_cid(sfp[0].c))));
}

static METHOD Class_isImmutable(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_class_isImmutable(knh_Class_cid(sfp[0].c)));
}

static METHOD Class_isMetaClass(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_class_isMetaClass(knh_Class_cid(sfp[0].c)));
}

static METHOD Class_isPrivate(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_class_isPrivate(knh_Class_cid(sfp[0].c)));
}

static METHOD Class_isPublic(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, !(knh_class_isPrivate(knh_Class_cid(sfp[0].c))));
}

static METHOD Class_isFinal(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_class_isFinal(knh_Class_cid(sfp[0].c)));
}

static METHOD Class_isSingleton(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_class_isSingleton(knh_Class_cid(sfp[0].c)));
}

static METHOD Class_isInterface(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_class_isInterface(knh_Class_cid(sfp[0].c)));
}

static METHOD Method_isPrivate(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Method_isPrivate((knh_Method_t*)sfp[0].o));
}

static METHOD Method_isPublic(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, !(knh_Method_isPrivate((knh_Method_t*)sfp[0].o)));
}

static METHOD Method_isVirtual(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Method_isVirtual((knh_Method_t*)sfp[0].o));
}

static METHOD Method_isFinal(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, !(knh_Method_isVirtual((knh_Method_t*)sfp[0].o)));
}

static METHOD Method_isConst(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Method_isConst((knh_Method_t*)sfp[0].o));
}

static METHOD Method_isStatic(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Method_isStatic((knh_Method_t*)sfp[0].o));
}

static METHOD Method_isVarArgs(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Method_isVarArgs((knh_Method_t*)sfp[0].o));
}

static METHOD Mapper_isInterface(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Mapper_isInterface((knh_Mapper_t*)sfp[0].o));
}

static METHOD Mapper_isICast(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Mapper_isICast((knh_Mapper_t*)sfp[0].o));
}

static METHOD Mapper_isSignificant(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Mapper_isSignificant((knh_Mapper_t*)sfp[0].o));
}

static METHOD Mapper_isFinal(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Mapper_isFinal((knh_Mapper_t*)sfp[0].o));
}

static METHOD Mapper_isSynonym(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Mapper_isSynonym((knh_Mapper_t*)sfp[0].o));
}

static METHOD Mapper_isLossLess(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Mapper_isLossLess((knh_Mapper_t*)sfp[0].o));
}

static METHOD Mapper_isTotal(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Mapper_isTotal((knh_Mapper_t*)sfp[0].o));
}

static METHOD Mapper_isPartial(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, !(knh_Mapper_isTotal((knh_Mapper_t*)sfp[0].o)));
}

static METHOD Mapper_isConst(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Mapper_isConst((knh_Mapper_t*)sfp[0].o));
}

static METHOD Mapper_isTemporal(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, !(knh_Mapper_isConst((knh_Mapper_t*)sfp[0].o)));
}

static METHOD Mapper_isLocal(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Mapper_isLocal((knh_Mapper_t*)sfp[0].o));
}

static METHOD Mapper_isDerived(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Mapper_isDerived((knh_Mapper_t*)sfp[0].o));
}

static METHOD OutputStream_isAutoFlush(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_OutputStream_isAutoFlush((knh_OutputStream_t*)sfp[0].o));
}

static METHOD OutputStream_setAutoFlush(Ctx *ctx, knh_sfp_t *sfp)
{
	knh_OutputStream_setAutoFlush((knh_OutputStream_t*)sfp[0].o, p_bool(sfp[1]));
	KNH_RETURN_void(ctx, sfp);
}

static METHOD OutputStream_isStoringBuffer(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_OutputStream_isStoringBuffer((knh_OutputStream_t*)sfp[0].o));
}

static METHOD OutputStream_setStoringBuffer(Ctx *ctx, knh_sfp_t *sfp)
{
	knh_OutputStream_setStoringBuffer((knh_OutputStream_t*)sfp[0].o, p_bool(sfp[1]));
	KNH_RETURN_void(ctx, sfp);
}

static METHOD Exception_isLogging(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Exception_isLogging((knh_Exception_t*)sfp[0].o));
}

static METHOD Context_isStrict(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Context_isStrict((knh_Context_t*)sfp[0].o));
}

static METHOD Context_setStrict(Ctx *ctx, knh_sfp_t *sfp)
{
	knh_Context_setStrict((knh_Context_t*)sfp[0].o, p_bool(sfp[1]));
	KNH_RETURN_void(ctx, sfp);
}

static METHOD Context_isDebug(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Context_isDebug((knh_Context_t*)sfp[0].o));
}

static METHOD Context_setDebug(Ctx *ctx, knh_sfp_t *sfp)
{
	knh_Context_setDebug((knh_Context_t*)sfp[0].o, p_bool(sfp[1]));
	KNH_RETURN_void(ctx, sfp);
}

static METHOD Context_isVerbose(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Context_isVerbose((knh_Context_t*)sfp[0].o));
}

static METHOD Context_setVerbose(Ctx *ctx, knh_sfp_t *sfp)
{
	knh_Context_setVerbose((knh_Context_t*)sfp[0].o, p_bool(sfp[1]));
	KNH_RETURN_void(ctx, sfp);
}

static METHOD Context_isInteractive(Ctx *ctx, knh_sfp_t *sfp)
{
	KNH_RETURN_Boolean(ctx, sfp, knh_Context_isInteractive((knh_Context_t*)sfp[0].o));
}

/* ======================================================================== */
/* data */

static char * StringData[] = {
	"", /* TS_EMPTY */
	"\t", /* TS_TAB */
	""KONOHA_OS_LINEFEED"", /* TS_EOL */
	"BEGIN", /* TS_BEGIN */
	"END", /* TS_END */
	"true", /* TS_true */
	"false", /* TS_false */
	"null", /* TS_null */
	"main", /* TS_main */
	""KONOHA_ENCODING"", /* TS_ENCODING */
	"/dev/null", /* TS_DEVNULL */
	"/dev/stdin", /* TS_DEVSTDIN */
	"/dev/stderr", /* TS_DEVSTDERR */
	"/dev/stdout", /* TS_DEVSTDOUT */
	"@label", /* TS_ATlabel */
	"Comment", /* TS_Comment */
	"(", /* TS_LP */
	")", /* TS_RP */
	"{", /* TS_LB */
	"}", /* TS_RB */
	"[", /* TS_LS */
	"]", /* TS_RS */
	NULL
};

static char * StructNameData[] = {
	"Object",
	"Boolean",
	"Number",
	"Int",
	"Float",
	"String",
	"Bytes",
	"Pair",
	"Tuple",
	"Range",
	"Array",
	"IArray",
	"FArray",
	"Iterator",
	"DictMap",
	"DictSet",
	"HashMap",
	"HashSet",
	"DictIdx",
	"Class",
	"ClassStruct",
	"MethodField",
	"Method",
	"Mapper",
	"ClassMap",
	"Closure",
	"AffineConv",
	"Regex",
	"BytesConv",
	"ClassSpec",
	"InputStream",
	"OutputStream",
	"Socket",
	"Connection",
	"ResultSet",
	"Exception",
	"ExceptionHandler",
	"Script",
	"NameSpace",
	"System",
	"Context",
	"Token",
	"Stmt",
	"Gamma",
	"KLRCode",
	"Any",
	"This",
	"Tvoid",
	"T0",
	"T1",
	"T2",
	"T3",
	"Tvar",
	NULL
};

static knh_StructData_t StructData[] = {
	{
		"Object", STRUCT_Object, FLAG_Object, 0,
		(knh_fstruct_init)knh_ObjectField_init,
		(knh_fstruct_copy)knh_ObjectField_copy, 
		(knh_fstruct_traverse)knh_ObjectField_traverse,
		(knh_fstruct_compareTo)knh_ObjectField_compareTo,
		(knh_fstruct_hashCode)knh_ObjectField_hashCode,
		(knh_fstruct_newClass)knh_ObjectField_newClass,
		knh_ObjectField_getkey
	},
	{
		"Boolean", STRUCT_Boolean, FLAG_Boolean, 0,
		(knh_fstruct_init)knh_Boolean_init,
		(knh_fstruct_copy)knh_Boolean_copy, 
		(knh_fstruct_traverse)knh_Boolean_traverse,
		(knh_fstruct_compareTo)knh_Boolean_compareTo,
		(knh_fstruct_hashCode)knh_Boolean_hashCode,
		(knh_fstruct_newClass)knh_Boolean_newClass,
		knh_Boolean_getkey
	},
	{
		"Number", STRUCT_Number, FLAG_Number, 0,
		(knh_fstruct_init)knh_Number_init,
		(knh_fstruct_copy)knh_Number_copy, 
		(knh_fstruct_traverse)knh_Number_traverse,
		(knh_fstruct_compareTo)knh_Number_compareTo,
		(knh_fstruct_hashCode)knh_Number_hashCode,
		(knh_fstruct_newClass)knh_Number_newClass,
		knh_Number_getkey
	},
	{
		"Int", STRUCT_Int, FLAG_Int, 0,
		(knh_fstruct_init)knh_Int_init,
		(knh_fstruct_copy)knh_Int_copy, 
		(knh_fstruct_traverse)knh_Int_traverse,
		(knh_fstruct_compareTo)knh_Int_compareTo,
		(knh_fstruct_hashCode)knh_Int_hashCode,
		(knh_fstruct_newClass)knh_Int_newClass,
		knh_Int_getkey
	},
	{
		"Float", STRUCT_Float, FLAG_Float, 0,
		(knh_fstruct_init)knh_Float_init,
		(knh_fstruct_copy)knh_Float_copy, 
		(knh_fstruct_traverse)knh_Float_traverse,
		(knh_fstruct_compareTo)knh_Float_compareTo,
		(knh_fstruct_hashCode)knh_Float_hashCode,
		(knh_fstruct_newClass)knh_Float_newClass,
		knh_Float_getkey
	},
	{
		"String", STRUCT_String, FLAG_String, 0,
		(knh_fstruct_init)knh_String_init,
		(knh_fstruct_copy)knh_String_copy, 
		(knh_fstruct_traverse)knh_String_traverse,
		(knh_fstruct_compareTo)knh_String_compareTo,
		(knh_fstruct_hashCode)knh_String_hashCode,
		(knh_fstruct_newClass)knh_String_newClass,
		knh_String_getkey
	},
	{
		"Bytes", STRUCT_Bytes, FLAG_Bytes, 0,
		(knh_fstruct_init)knh_Bytes_init,
		(knh_fstruct_copy)knh_Bytes_copy, 
		(knh_fstruct_traverse)knh_Bytes_traverse,
		(knh_fstruct_compareTo)knh_Bytes_compareTo,
		(knh_fstruct_hashCode)knh_Bytes_hashCode,
		(knh_fstruct_newClass)knh_Bytes_newClass,
		knh_Bytes_getkey
	},
	{
		"Pair", STRUCT_Pair, FLAG_Pair, 0,
		(knh_fstruct_init)knh_Pair_init,
		(knh_fstruct_copy)knh_Pair_copy, 
		(knh_fstruct_traverse)knh_Pair_traverse,
		(knh_fstruct_compareTo)knh_Pair_compareTo,
		(knh_fstruct_hashCode)knh_Pair_hashCode,
		(knh_fstruct_newClass)knh_Pair_newClass,
		knh_Pair_getkey
	},
	{
		"Tuple", STRUCT_Tuple, FLAG_Tuple, 0,
		(knh_fstruct_init)knh_Tuple_init,
		(knh_fstruct_copy)knh_Tuple_copy, 
		(knh_fstruct_traverse)knh_Tuple_traverse,
		(knh_fstruct_compareTo)knh_Tuple_compareTo,
		(knh_fstruct_hashCode)knh_Tuple_hashCode,
		(knh_fstruct_newClass)knh_Tuple_newClass,
		knh_Tuple_getkey
	},
	{
		"Range", STRUCT_Range, FLAG_Range, 0,
		(knh_fstruct_init)knh_Range_init,
		(knh_fstruct_copy)knh_Range_copy, 
		(knh_fstruct_traverse)knh_Range_traverse,
		(knh_fstruct_compareTo)knh_Range_compareTo,
		(knh_fstruct_hashCode)knh_Range_hashCode,
		(knh_fstruct_newClass)knh_Range_newClass,
		knh_Range_getkey
	},
	{
		"Array", STRUCT_Array, FLAG_Array, 0,
		(knh_fstruct_init)knh_Array_init,
		(knh_fstruct_copy)knh_Array_copy, 
		(knh_fstruct_traverse)knh_Array_traverse,
		(knh_fstruct_compareTo)knh_Array_compareTo,
		(knh_fstruct_hashCode)knh_Array_hashCode,
		(knh_fstruct_newClass)knh_Array_newClass,
		knh_Array_getkey
	},
	{
		"IArray", STRUCT_IArray, FLAG_IArray, 0,
		(knh_fstruct_init)knh_IArray_init,
		(knh_fstruct_copy)knh_IArray_copy, 
		(knh_fstruct_traverse)knh_IArray_traverse,
		(knh_fstruct_compareTo)knh_IArray_compareTo,
		(knh_fstruct_hashCode)knh_IArray_hashCode,
		(knh_fstruct_newClass)knh_IArray_newClass,
		knh_IArray_getkey
	},
	{
		"FArray", STRUCT_FArray, FLAG_FArray, 0,
		(knh_fstruct_init)knh_FArray_init,
		(knh_fstruct_copy)knh_FArray_copy, 
		(knh_fstruct_traverse)knh_FArray_traverse,
		(knh_fstruct_compareTo)knh_FArray_compareTo,
		(knh_fstruct_hashCode)knh_FArray_hashCode,
		(knh_fstruct_newClass)knh_FArray_newClass,
		knh_FArray_getkey
	},
	{
		"Iterator", STRUCT_Iterator, FLAG_Iterator, sizeof(knh_Iterator_struct),
		(knh_fstruct_init)knh_Iterator_init,
		(knh_fstruct_copy)knh_Iterator_copy, 
		(knh_fstruct_traverse)knh_Iterator_traverse,
		(knh_fstruct_compareTo)knh_Iterator_compareTo,
		(knh_fstruct_hashCode)knh_Iterator_hashCode,
		(knh_fstruct_newClass)knh_Iterator_newClass,
		knh_Iterator_getkey
	},
	{
		"DictMap", STRUCT_DictMap, FLAG_DictMap, 0,
		(knh_fstruct_init)knh_DictMap_init,
		(knh_fstruct_copy)knh_DictMap_copy, 
		(knh_fstruct_traverse)knh_DictMap_traverse,
		(knh_fstruct_compareTo)knh_DictMap_compareTo,
		(knh_fstruct_hashCode)knh_DictMap_hashCode,
		(knh_fstruct_newClass)knh_DictMap_newClass,
		knh_DictMap_getkey
	},
	{
		"DictSet", STRUCT_DictSet, FLAG_DictSet, 0,
		(knh_fstruct_init)knh_DictSet_init,
		(knh_fstruct_copy)knh_DictSet_copy, 
		(knh_fstruct_traverse)knh_DictSet_traverse,
		(knh_fstruct_compareTo)knh_DictSet_compareTo,
		(knh_fstruct_hashCode)knh_DictSet_hashCode,
		(knh_fstruct_newClass)knh_DictSet_newClass,
		knh_DictSet_getkey
	},
	{
		"HashMap", STRUCT_HashMap, FLAG_HashMap, sizeof(knh_HashMap_struct),
		(knh_fstruct_init)knh_HashMap_init,
		(knh_fstruct_copy)knh_HashMap_copy, 
		(knh_fstruct_traverse)knh_HashMap_traverse,
		(knh_fstruct_compareTo)knh_HashMap_compareTo,
		(knh_fstruct_hashCode)knh_HashMap_hashCode,
		(knh_fstruct_newClass)knh_HashMap_newClass,
		knh_HashMap_getkey
	},
	{
		"HashSet", STRUCT_HashSet, FLAG_HashSet, sizeof(knh_HashSet_struct),
		(knh_fstruct_init)knh_HashSet_init,
		(knh_fstruct_copy)knh_HashSet_copy, 
		(knh_fstruct_traverse)knh_HashSet_traverse,
		(knh_fstruct_compareTo)knh_HashSet_compareTo,
		(knh_fstruct_hashCode)knh_HashSet_hashCode,
		(knh_fstruct_newClass)knh_HashSet_newClass,
		knh_HashSet_getkey
	},
	{
		"DictIdx", STRUCT_DictIdx, FLAG_DictIdx, 0,
		(knh_fstruct_init)knh_DictIdx_init,
		(knh_fstruct_copy)knh_DictIdx_copy, 
		(knh_fstruct_traverse)knh_DictIdx_traverse,
		(knh_fstruct_compareTo)knh_DictIdx_compareTo,
		(knh_fstruct_hashCode)knh_DictIdx_hashCode,
		(knh_fstruct_newClass)knh_DictIdx_newClass,
		knh_DictIdx_getkey
	},
	{
		"Class", STRUCT_Class, FLAG_Class, 0,
		(knh_fstruct_init)knh_Class_init,
		(knh_fstruct_copy)knh_Class_copy, 
		(knh_fstruct_traverse)knh_Class_traverse,
		(knh_fstruct_compareTo)knh_Class_compareTo,
		(knh_fstruct_hashCode)knh_Class_hashCode,
		(knh_fstruct_newClass)knh_Class_newClass,
		knh_Class_getkey
	},
	{
		"ClassStruct", STRUCT_ClassStruct, FLAG_ClassStruct, 0,
		(knh_fstruct_init)knh_ClassStruct_init,
		(knh_fstruct_copy)knh_ClassStruct_copy, 
		(knh_fstruct_traverse)knh_ClassStruct_traverse,
		(knh_fstruct_compareTo)knh_ClassStruct_compareTo,
		(knh_fstruct_hashCode)knh_ClassStruct_hashCode,
		(knh_fstruct_newClass)knh_ClassStruct_newClass,
		knh_ClassStruct_getkey
	},
	{
		"MethodField", STRUCT_MethodField, FLAG_MethodField, 0,
		(knh_fstruct_init)knh_MethodField_init,
		(knh_fstruct_copy)knh_MethodField_copy, 
		(knh_fstruct_traverse)knh_MethodField_traverse,
		(knh_fstruct_compareTo)knh_MethodField_compareTo,
		(knh_fstruct_hashCode)knh_MethodField_hashCode,
		(knh_fstruct_newClass)knh_MethodField_newClass,
		knh_MethodField_getkey
	},
	{
		"Method", STRUCT_Method, FLAG_Method, sizeof(knh_Method_struct),
		(knh_fstruct_init)knh_Method_init,
		(knh_fstruct_copy)knh_Method_copy, 
		(knh_fstruct_traverse)knh_Method_traverse,
		(knh_fstruct_compareTo)knh_Method_compareTo,
		(knh_fstruct_hashCode)knh_Method_hashCode,
		(knh_fstruct_newClass)knh_Method_newClass,
		knh_Method_getkey
	},
	{
		"Mapper", STRUCT_Mapper, FLAG_Mapper, sizeof(knh_Mapper_struct),
		(knh_fstruct_init)knh_Mapper_init,
		(knh_fstruct_copy)knh_Mapper_copy, 
		(knh_fstruct_traverse)knh_Mapper_traverse,
		(knh_fstruct_compareTo)knh_Mapper_compareTo,
		(knh_fstruct_hashCode)knh_Mapper_hashCode,
		(knh_fstruct_newClass)knh_Mapper_newClass,
		knh_Mapper_getkey
	},
	{
		"ClassMap", STRUCT_ClassMap, FLAG_ClassMap, 0,
		(knh_fstruct_init)knh_ClassMap_init,
		(knh_fstruct_copy)knh_ClassMap_copy, 
		(knh_fstruct_traverse)knh_ClassMap_traverse,
		(knh_fstruct_compareTo)knh_ClassMap_compareTo,
		(knh_fstruct_hashCode)knh_ClassMap_hashCode,
		(knh_fstruct_newClass)knh_ClassMap_newClass,
		knh_ClassMap_getkey
	},
	{
		"Closure", STRUCT_Closure, FLAG_Closure, 0,
		(knh_fstruct_init)knh_Closure_init,
		(knh_fstruct_copy)knh_Closure_copy, 
		(knh_fstruct_traverse)knh_Closure_traverse,
		(knh_fstruct_compareTo)knh_Closure_compareTo,
		(knh_fstruct_hashCode)knh_Closure_hashCode,
		(knh_fstruct_newClass)knh_Closure_newClass,
		knh_Closure_getkey
	},
	{
		"AffineConv", STRUCT_AffineConv, FLAG_AffineConv, 0,
		(knh_fstruct_init)knh_AffineConv_init,
		(knh_fstruct_copy)knh_AffineConv_copy, 
		(knh_fstruct_traverse)knh_AffineConv_traverse,
		(knh_fstruct_compareTo)knh_AffineConv_compareTo,
		(knh_fstruct_hashCode)knh_AffineConv_hashCode,
		(knh_fstruct_newClass)knh_AffineConv_newClass,
		knh_AffineConv_getkey
	},
	{
		"Regex", STRUCT_Regex, FLAG_Regex, 0,
		(knh_fstruct_init)knh_Regex_init,
		(knh_fstruct_copy)knh_Regex_copy, 
		(knh_fstruct_traverse)knh_Regex_traverse,
		(knh_fstruct_compareTo)knh_Regex_compareTo,
		(knh_fstruct_hashCode)knh_Regex_hashCode,
		(knh_fstruct_newClass)knh_Regex_newClass,
		knh_Regex_getkey
	},
	{
		"BytesConv", STRUCT_BytesConv, FLAG_BytesConv, 0,
		(knh_fstruct_init)knh_BytesConv_init,
		(knh_fstruct_copy)knh_BytesConv_copy, 
		(knh_fstruct_traverse)knh_BytesConv_traverse,
		(knh_fstruct_compareTo)knh_BytesConv_compareTo,
		(knh_fstruct_hashCode)knh_BytesConv_hashCode,
		(knh_fstruct_newClass)knh_BytesConv_newClass,
		knh_BytesConv_getkey
	},
	{
		"ClassSpec", STRUCT_ClassSpec, FLAG_ClassSpec, sizeof(knh_ClassSpec_struct),
		(knh_fstruct_init)knh_ClassSpec_init,
		(knh_fstruct_copy)knh_ClassSpec_copy, 
		(knh_fstruct_traverse)knh_ClassSpec_traverse,
		(knh_fstruct_compareTo)knh_ClassSpec_compareTo,
		(knh_fstruct_hashCode)knh_ClassSpec_hashCode,
		(knh_fstruct_newClass)knh_ClassSpec_newClass,
		knh_ClassSpec_getkey
	},
	{
		"InputStream", STRUCT_InputStream, FLAG_InputStream, sizeof(knh_InputStream_struct),
		(knh_fstruct_init)knh_InputStream_init,
		(knh_fstruct_copy)knh_InputStream_copy, 
		(knh_fstruct_traverse)knh_InputStream_traverse,
		(knh_fstruct_compareTo)knh_InputStream_compareTo,
		(knh_fstruct_hashCode)knh_InputStream_hashCode,
		(knh_fstruct_newClass)knh_InputStream_newClass,
		knh_InputStream_getkey
	},
	{
		"OutputStream", STRUCT_OutputStream, FLAG_OutputStream, sizeof(knh_OutputStream_struct),
		(knh_fstruct_init)knh_OutputStream_init,
		(knh_fstruct_copy)knh_OutputStream_copy, 
		(knh_fstruct_traverse)knh_OutputStream_traverse,
		(knh_fstruct_compareTo)knh_OutputStream_compareTo,
		(knh_fstruct_hashCode)knh_OutputStream_hashCode,
		(knh_fstruct_newClass)knh_OutputStream_newClass,
		knh_OutputStream_getkey
	},
	{
		"Socket", STRUCT_Socket, FLAG_Socket, sizeof(knh_Socket_struct),
		(knh_fstruct_init)knh_Socket_init,
		(knh_fstruct_copy)knh_Socket_copy, 
		(knh_fstruct_traverse)knh_Socket_traverse,
		(knh_fstruct_compareTo)knh_Socket_compareTo,
		(knh_fstruct_hashCode)knh_Socket_hashCode,
		(knh_fstruct_newClass)knh_Socket_newClass,
		knh_Socket_getkey
	},
	{
		"Connection", STRUCT_Connection, FLAG_Connection, 0,
		(knh_fstruct_init)knh_Connection_init,
		(knh_fstruct_copy)knh_Connection_copy, 
		(knh_fstruct_traverse)knh_Connection_traverse,
		(knh_fstruct_compareTo)knh_Connection_compareTo,
		(knh_fstruct_hashCode)knh_Connection_hashCode,
		(knh_fstruct_newClass)knh_Connection_newClass,
		knh_Connection_getkey
	},
	{
		"ResultSet", STRUCT_ResultSet, FLAG_ResultSet, sizeof(knh_ResultSet_struct),
		(knh_fstruct_init)knh_ResultSet_init,
		(knh_fstruct_copy)knh_ResultSet_copy, 
		(knh_fstruct_traverse)knh_ResultSet_traverse,
		(knh_fstruct_compareTo)knh_ResultSet_compareTo,
		(knh_fstruct_hashCode)knh_ResultSet_hashCode,
		(knh_fstruct_newClass)knh_ResultSet_newClass,
		knh_ResultSet_getkey
	},
	{
		"Exception", STRUCT_Exception, FLAG_Exception, sizeof(knh_Exception_struct),
		(knh_fstruct_init)knh_Exception_init,
		(knh_fstruct_copy)knh_Exception_copy, 
		(knh_fstruct_traverse)knh_Exception_traverse,
		(knh_fstruct_compareTo)knh_Exception_compareTo,
		(knh_fstruct_hashCode)knh_Exception_hashCode,
		(knh_fstruct_newClass)knh_Exception_newClass,
		knh_Exception_getkey
	},
	{
		"ExceptionHandler", STRUCT_ExceptionHandler, FLAG_ExceptionHandler, sizeof(knh_ExceptionHandler_struct),
		(knh_fstruct_init)knh_ExceptionHandler_init,
		(knh_fstruct_copy)knh_ExceptionHandler_copy, 
		(knh_fstruct_traverse)knh_ExceptionHandler_traverse,
		(knh_fstruct_compareTo)knh_ExceptionHandler_compareTo,
		(knh_fstruct_hashCode)knh_ExceptionHandler_hashCode,
		(knh_fstruct_newClass)knh_ExceptionHandler_newClass,
		knh_ExceptionHandler_getkey
	},
	{
		"Script", STRUCT_Script, FLAG_Script, 0,
		(knh_fstruct_init)knh_Script_init,
		(knh_fstruct_copy)knh_Script_copy, 
		(knh_fstruct_traverse)knh_Script_traverse,
		(knh_fstruct_compareTo)knh_Script_compareTo,
		(knh_fstruct_hashCode)knh_Script_hashCode,
		(knh_fstruct_newClass)knh_Script_newClass,
		knh_Script_getkey
	},
	{
		"NameSpace", STRUCT_NameSpace, FLAG_NameSpace, sizeof(knh_NameSpace_struct),
		(knh_fstruct_init)knh_NameSpace_init,
		(knh_fstruct_copy)knh_NameSpace_copy, 
		(knh_fstruct_traverse)knh_NameSpace_traverse,
		(knh_fstruct_compareTo)knh_NameSpace_compareTo,
		(knh_fstruct_hashCode)knh_NameSpace_hashCode,
		(knh_fstruct_newClass)knh_NameSpace_newClass,
		knh_NameSpace_getkey
	},
	{
		"System", STRUCT_System, FLAG_System, sizeof(knh_System_struct),
		(knh_fstruct_init)knh_System_init,
		(knh_fstruct_copy)knh_System_copy, 
		(knh_fstruct_traverse)knh_System_traverse,
		(knh_fstruct_compareTo)knh_System_compareTo,
		(knh_fstruct_hashCode)knh_System_hashCode,
		(knh_fstruct_newClass)knh_System_newClass,
		knh_System_getkey
	},
	{
		"Context", STRUCT_Context, FLAG_Context, 0,
		(knh_fstruct_init)knh_Context_init,
		(knh_fstruct_copy)knh_Context_copy, 
		(knh_fstruct_traverse)knh_Context_traverse,
		(knh_fstruct_compareTo)knh_Context_compareTo,
		(knh_fstruct_hashCode)knh_Context_hashCode,
		(knh_fstruct_newClass)knh_Context_newClass,
		knh_Context_getkey
	},
	{
		"Token", STRUCT_Token, FLAG_Token, sizeof(knh_Token_struct),
		(knh_fstruct_init)knh_Token_init,
		(knh_fstruct_copy)knh_Token_copy, 
		(knh_fstruct_traverse)knh_Token_traverse,
		(knh_fstruct_compareTo)knh_Token_compareTo,
		(knh_fstruct_hashCode)knh_Token_hashCode,
		(knh_fstruct_newClass)knh_Token_newClass,
		knh_Token_getkey
	},
	{
		"Stmt", STRUCT_Stmt, FLAG_Stmt, sizeof(knh_Stmt_struct),
		(knh_fstruct_init)knh_Stmt_init,
		(knh_fstruct_copy)knh_Stmt_copy, 
		(knh_fstruct_traverse)knh_Stmt_traverse,
		(knh_fstruct_compareTo)knh_Stmt_compareTo,
		(knh_fstruct_hashCode)knh_Stmt_hashCode,
		(knh_fstruct_newClass)knh_Stmt_newClass,
		knh_Stmt_getkey
	},
	{
		"Gamma", STRUCT_Gamma, FLAG_Gamma, sizeof(knh_Gamma_struct),
		(knh_fstruct_init)knh_Gamma_init,
		(knh_fstruct_copy)knh_Gamma_copy, 
		(knh_fstruct_traverse)knh_Gamma_traverse,
		(knh_fstruct_compareTo)knh_Gamma_compareTo,
		(knh_fstruct_hashCode)knh_Gamma_hashCode,
		(knh_fstruct_newClass)knh_Gamma_newClass,
		knh_Gamma_getkey
	},
	{
		"KLRCode", STRUCT_KLRCode, FLAG_KLRCode, sizeof(knh_KLRCode_struct),
		(knh_fstruct_init)knh_KLRCode_init,
		(knh_fstruct_copy)knh_KLRCode_copy, 
		(knh_fstruct_traverse)knh_KLRCode_traverse,
		(knh_fstruct_compareTo)knh_KLRCode_compareTo,
		(knh_fstruct_hashCode)knh_KLRCode_hashCode,
		(knh_fstruct_newClass)knh_KLRCode_newClass,
		knh_KLRCode_getkey
	},
	{
		"Any", STRUCT_Any, FLAG_Any, 0,
		(knh_fstruct_init)knh_Any_init,
		(knh_fstruct_copy)knh_Any_copy, 
		(knh_fstruct_traverse)knh_Any_traverse,
		(knh_fstruct_compareTo)knh_Any_compareTo,
		(knh_fstruct_hashCode)knh_Any_hashCode,
		(knh_fstruct_newClass)knh_Any_newClass,
		knh_Any_getkey
	},
	{
		"This", STRUCT_This, FLAG_This, 0,
		(knh_fstruct_init)knh_This_init,
		(knh_fstruct_copy)knh_This_copy, 
		(knh_fstruct_traverse)knh_This_traverse,
		(knh_fstruct_compareTo)knh_This_compareTo,
		(knh_fstruct_hashCode)knh_This_hashCode,
		(knh_fstruct_newClass)knh_This_newClass,
		knh_This_getkey
	},
	{
		"Tvoid", STRUCT_Tvoid, FLAG_Tvoid, 0,
		(knh_fstruct_init)knh_Tvoid_init,
		(knh_fstruct_copy)knh_Tvoid_copy, 
		(knh_fstruct_traverse)knh_Tvoid_traverse,
		(knh_fstruct_compareTo)knh_Tvoid_compareTo,
		(knh_fstruct_hashCode)knh_Tvoid_hashCode,
		(knh_fstruct_newClass)knh_Tvoid_newClass,
		knh_Tvoid_getkey
	},
	{
		"T0", STRUCT_T0, FLAG_T0, 0,
		(knh_fstruct_init)knh_T0_init,
		(knh_fstruct_copy)knh_T0_copy, 
		(knh_fstruct_traverse)knh_T0_traverse,
		(knh_fstruct_compareTo)knh_T0_compareTo,
		(knh_fstruct_hashCode)knh_T0_hashCode,
		(knh_fstruct_newClass)knh_T0_newClass,
		knh_T0_getkey
	},
	{
		"T1", STRUCT_T1, FLAG_T1, 0,
		(knh_fstruct_init)knh_T1_init,
		(knh_fstruct_copy)knh_T1_copy, 
		(knh_fstruct_traverse)knh_T1_traverse,
		(knh_fstruct_compareTo)knh_T1_compareTo,
		(knh_fstruct_hashCode)knh_T1_hashCode,
		(knh_fstruct_newClass)knh_T1_newClass,
		knh_T1_getkey
	},
	{
		"T2", STRUCT_T2, FLAG_T2, 0,
		(knh_fstruct_init)knh_T2_init,
		(knh_fstruct_copy)knh_T2_copy, 
		(knh_fstruct_traverse)knh_T2_traverse,
		(knh_fstruct_compareTo)knh_T2_compareTo,
		(knh_fstruct_hashCode)knh_T2_hashCode,
		(knh_fstruct_newClass)knh_T2_newClass,
		knh_T2_getkey
	},
	{
		"T3", STRUCT_T3, FLAG_T3, 0,
		(knh_fstruct_init)knh_T3_init,
		(knh_fstruct_copy)knh_T3_copy, 
		(knh_fstruct_traverse)knh_T3_traverse,
		(knh_fstruct_compareTo)knh_T3_compareTo,
		(knh_fstruct_hashCode)knh_T3_hashCode,
		(knh_fstruct_newClass)knh_T3_newClass,
		knh_T3_getkey
	},
	{
		"Tvar", STRUCT_Tvar, FLAG_Tvar, 0,
		(knh_fstruct_init)knh_Tvar_init,
		(knh_fstruct_copy)knh_Tvar_copy, 
		(knh_fstruct_traverse)knh_Tvar_traverse,
		(knh_fstruct_compareTo)knh_Tvar_compareTo,
		(knh_fstruct_hashCode)knh_Tvar_hashCode,
		(knh_fstruct_newClass)knh_Tvar_newClass,
		knh_Tvar_getkey
	},
	{NULL}
};

static knh_ClassData_t ClassData[] = {
	{"Object", CLASS_Object, FLAG_Object, 
	   CLASS_ObjectField, CLASS_Object, 8, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Boolean", CLASS_Boolean, FLAG_Boolean, 
	   CLASS_Boolean, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Number", CLASS_Number, FLAG_Number, 
	   CLASS_Number, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Int", CLASS_Int, FLAG_Int, 
	   CLASS_Int, CLASS_Number, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Float", CLASS_Float, FLAG_Float, 
	   CLASS_Float, CLASS_Number, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"String", CLASS_String, FLAG_String, 
	   CLASS_String, CLASS_Object, 1, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Bytes", CLASS_Bytes, FLAG_Bytes, 
	   CLASS_Bytes, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Pair", CLASS_Pair, FLAG_Pair, 
	   CLASS_Pair, CLASS_Object, 0, 0, 0,
	   Any, Any, TYPE_void, TYPE_void},
	{"PairSS", CLASS_Pair, FLAG_Pair, 
	   CLASS_String, CLASS_String, 0, 0, 0,
	   String, TYPE_void, TYPE_void, TYPE_void},
	{"PairST1", CLASS_Pair, FLAG_Pair, 
	   CLASS_String, CLASS_String, 0, 0, 0,
	   T1, TYPE_void, TYPE_void, TYPE_void},
	{"PairT1T2", CLASS_Pair, FLAG_Pair, 
	   CLASS_T1, CLASS_T1, 0, 0, 0,
	   T2, TYPE_void, TYPE_void, TYPE_void},
	{"Tuple", CLASS_Tuple, FLAG_Tuple, 
	   CLASS_Tuple, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Range", CLASS_Range, FLAG_Range, 
	   CLASS_Range, CLASS_Object, 0, 0, 0,
	   Any, TYPE_void, TYPE_void, TYPE_void},
	{"Array", CLASS_Array, FLAG_Array, 
	   CLASS_Array, CLASS_Object, 0, 0, 0,
	   Any, TYPE_void, TYPE_void, TYPE_void},
	{"Cmpr", CLASS_Closure, FLAG_Closure, 
	   CLASS_Int!, CLASS_Int!, 0, 0, 0,
	   T1!, T1!, void, TYPE_Any},
	{"Int[]", CLASS_IArray, FLAG_IArray, 
	   CLASS_IArray, CLASS_Object, 0, 0, 0,
	   Float, TYPE_void, TYPE_void, TYPE_void},
	{"Float[]", CLASS_FArray, FLAG_FArray, 
	   CLASS_FArray, CLASS_Object, 0, 0, 0,
	   Float, TYPE_void, TYPE_void, TYPE_void},
	{"Iterator", CLASS_Iterator, FLAG_Iterator, 
	   CLASS_Iterator, CLASS_Object, 0, 0, 0,
	   Any, TYPE_void, TYPE_void, TYPE_void},
	{"DictMap", CLASS_DictMap, FLAG_DictMap, 
	   CLASS_DictMap, CLASS_Object, 1, 0, 0,
	   Any, TYPE_void, TYPE_void, TYPE_void},
	{"DictSet", CLASS_DictSet, FLAG_DictSet, 
	   CLASS_DictSet, CLASS_Object, 1, 0, 0,
	   Any, TYPE_void, TYPE_void, TYPE_void},
	{"HashMap", CLASS_HashMap, FLAG_HashMap, 
	   CLASS_HashMap, CLASS_Object, 0, 0, 0,
	   Any, Any, TYPE_void, TYPE_void},
	{"HashSet", CLASS_HashSet, FLAG_HashSet, 
	   CLASS_HashSet, CLASS_Object, 0, 0, 0,
	   Any, TYPE_void, TYPE_void, TYPE_void},
	{"DictIdx", CLASS_DictIdx, FLAG_DictIdx, 
	   CLASS_DictIdx, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Class", CLASS_Class, FLAG_Class, 
	   CLASS_Class, CLASS_Object, 9, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"ClassStruct", CLASS_ClassStruct, FLAG_ClassStruct, 
	   CLASS_ClassStruct, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"MethodField", CLASS_MethodField, FLAG_MethodField, 
	   CLASS_MethodField, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Method", CLASS_Method, FLAG_Method, 
	   CLASS_Method, CLASS_Object, 7, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Mapper", CLASS_Mapper, FLAG_Mapper, 
	   CLASS_Mapper, CLASS_Object, 12, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"ClassMap", CLASS_ClassMap, FLAG_ClassMap, 
	   CLASS_ClassMap, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Closure", CLASS_Closure, FLAG_Closure, 
	   CLASS_Closure, CLASS_Object, 0, 0, 0,
	   TYPE_Any, TYPE_Any, TYPE_Any, TYPE_Any},
	{"AffineConv", CLASS_AffineConv, FLAG_AffineConv, 
	   CLASS_AffineConv, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Regex", CLASS_Regex, FLAG_Regex, 
	   CLASS_Regex, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"BytesConv", CLASS_BytesConv, FLAG_BytesConv, 
	   CLASS_BytesConv, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"ClassSpec", CLASS_ClassSpec, FLAG_ClassSpec, 
	   CLASS_ClassSpec, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"InputStream", CLASS_InputStream, FLAG_InputStream, 
	   CLASS_InputStream, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"OutputStream", CLASS_OutputStream, FLAG_OutputStream, 
	   CLASS_OutputStream, CLASS_Object, 4, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Socket", CLASS_Socket, FLAG_Socket, 
	   CLASS_Socket, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Connection", CLASS_Connection, FLAG_Connection, 
	   CLASS_Connection, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"ResultSet", CLASS_ResultSet, FLAG_ResultSet, 
	   CLASS_ResultSet, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Exception", CLASS_Exception, FLAG_Exception, 
	   CLASS_Exception, CLASS_Object, 1, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"ExceptionHandler", CLASS_ExceptionHandler, FLAG_ExceptionHandler, 
	   CLASS_ExceptionHandler, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Script", CLASS_Script, FLAG_Script, 
	   CLASS_Script, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"NameSpace", CLASS_NameSpace, FLAG_NameSpace, 
	   CLASS_NameSpace, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"System", CLASS_System, FLAG_System, 
	   CLASS_System, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Context", CLASS_Context, FLAG_Context, 
	   CLASS_Context, CLASS_Object, 7, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Token", CLASS_Token, FLAG_Token, 
	   CLASS_Token, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Stmt", CLASS_Stmt, FLAG_Stmt, 
	   CLASS_Stmt, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Gamma", CLASS_Gamma, FLAG_Gamma, 
	   CLASS_Gamma, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"KLRCode", CLASS_KLRCode, FLAG_KLRCode, 
	   CLASS_KLRCode, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Any", CLASS_Any, FLAG_Any, 
	   CLASS_Any, CLASS_Object, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"This", CLASS_This, FLAG_This, 
	   CLASS_This, CLASS_Any, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Tvoid", CLASS_Tvoid, FLAG_Tvoid, 
	   CLASS_Tvoid, CLASS_Any, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"T0", CLASS_T0, FLAG_T0, 
	   CLASS_T0, CLASS_Any, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"T1", CLASS_T1, FLAG_T1, 
	   CLASS_T1, CLASS_Any, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"T2", CLASS_T2, FLAG_T2, 
	   CLASS_T2, CLASS_Any, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"T3", CLASS_T3, FLAG_T3, 
	   CLASS_T3, CLASS_Any, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{"Tvar", CLASS_Tvar, FLAG_Tvar, 
	   CLASS_Tvar, CLASS_Any, 0, 0, 0,
	   TYPE_void, TYPE_void, TYPE_void, TYPE_void},
	{NULL}
};

static knh_ExptData_t ExptData[] = {
	{"Exception!!", 0, EXPT_Exception, EXPT_Exception},
	{"Fatal!!", 0, EXPT_Fatal, EXPT_Exception},
	{"OutOfMemory!!", 0, EXPT_OutOfMemory, EXPT_Fatal},
	{"Security!!", 0, EXPT_Security, EXPT_Exception},
	{"Null!!", 0, EXPT_Null, EXPT_Exception},
	{"OutOfIndex!!", 0, EXPT_OutOfIndex, EXPT_Exception},
	{"IO!!", 0, EXPT_IO, EXPT_Exception},
	{"Script!!", 0, EXPT_Script, EXPT_Exception},
	{"Syntax!!", 0, EXPT_Syntax, EXPT_Script},
	{"Type!!", 0, EXPT_Type, EXPT_Script},
	{"Assert!!", 0, EXPT_Assert, EXPT_Script},
	{NULL}
};

static knh_FieldNameData_t FieldNameData[] = {
	{"", FIELDN_},
	{"ascii", FIELDN_ascii},
	{"autoFlush", FIELDN_autoFlush},
	{"const", FIELDN_const},
	{"debug", FIELDN_debug},
	{"derived", FIELDN_derived},
	{"final", FIELDN_final},
	{"flag", FIELDN_flag},
	{"iCast", FIELDN_iCast},
	{"ignoreCase", FIELDN_ignoreCase},
	{"immutable", FIELDN_immutable},
	{"interactive", FIELDN_interactive},
	{"interface", FIELDN_interface},
	{"local", FIELDN_local},
	{"logging", FIELDN_logging},
	{"lossLess", FIELDN_lossLess},
	{"metaClass", FIELDN_metaClass},
	{"modified", FIELDN_modified},
	{"partial", FIELDN_partial},
	{"private", FIELDN_private},
	{"public", FIELDN_public},
	{"release", FIELDN_release},
	{"shared", FIELDN_shared},
	{"significant", FIELDN_significant},
	{"singleton", FIELDN_singleton},
	{"static", FIELDN_static},
	{"storingBuffer", FIELDN_storingBuffer},
	{"strict", FIELDN_strict},
	{"synonym", FIELDN_synonym},
	{"temporal", FIELDN_temporal},
	{"total", FIELDN_total},
	{"undefined", FIELDN_undefined},
	{"varArgs", FIELDN_varArgs},
	{"verbose", FIELDN_verbose},
	{"virtual", FIELDN_virtual},
	{NULL}
};

static knh_MethodFieldData_t MethodFieldData[] = {
	{0, 0, TYPE_void},
	{1, 0, NNTYPE_Boolean},
	{2, 1, TYPE_void, NNTYPE_Boolean, FIELDN_flag},
	{-1}
};

static knh_MethodData_t MethodData[] = {
	{Object_isRelease, 0, CLASS_Object, METHODN_isRelease, 1, 0, NULL},
	{Object_isDebug, 0, CLASS_Object, METHODN_isDebug, 1, 0, NULL},
	{Object_isImmutable, 0, CLASS_Object, METHODN_isImmutable, 1, 0, NULL},
	{Object_isUndefined, 0, CLASS_Object, METHODN_isUndefined, 1, 0, NULL},
	{Object_isModified, 0, CLASS_Object, METHODN_isModified, 1, 0, NULL},
	{Object_setModified, 0, CLASS_Object, METHODN_setModified, 2, 0, NULL},
	{Object_isShared, 0, CLASS_Object, METHODN_isShared, 1, 0, NULL},
	{Object_setShared, 0, CLASS_Object, METHODN_setShared, 2, 0, NULL},
	{String_isAscii, 0, CLASS_String, METHODN_isAscii, 1, 0, NULL},
	{DictMap_isIgnoreCase, 0, CLASS_DictMap, METHODN_isIgnoreCase, 1, 0, NULL},
	{DictSet_isIgnoreCase, 0, CLASS_DictSet, METHODN_isIgnoreCase, 1, 0, NULL},
	{Class_isRelease, 0, CLASS_Class, METHODN_isRelease, 1, 0, NULL},
	{Class_isDebug, 0, CLASS_Class, METHODN_isDebug, 1, 0, NULL},
	{Class_isImmutable, 0, CLASS_Class, METHODN_isImmutable, 1, 0, NULL},
	{Class_isMetaClass, 0, CLASS_Class, METHODN_isMetaClass, 1, 0, NULL},
	{Class_isPrivate, 0, CLASS_Class, METHODN_isPrivate, 1, 0, NULL},
	{Class_isPublic, 0, CLASS_Class, METHODN_isPublic, 1, 0, NULL},
	{Class_isFinal, 0, CLASS_Class, METHODN_isFinal, 1, 0, NULL},
	{Class_isSingleton, 0, CLASS_Class, METHODN_isSingleton, 1, 0, NULL},
	{Class_isInterface, 0, CLASS_Class, METHODN_isInterface, 1, 0, NULL},
	{Method_isPrivate, 0, CLASS_Method, METHODN_isPrivate, 1, 0, NULL},
	{Method_isPublic, 0, CLASS_Method, METHODN_isPublic, 1, 0, NULL},
	{Method_isVirtual, 0, CLASS_Method, METHODN_isVirtual, 1, 0, NULL},
	{Method_isFinal, 0, CLASS_Method, METHODN_isFinal, 1, 0, NULL},
	{Method_isConst, 0, CLASS_Method, METHODN_isConst, 1, 0, NULL},
	{Method_isStatic, 0, CLASS_Method, METHODN_isStatic, 1, 0, NULL},
	{Method_isVarArgs, 0, CLASS_Method, METHODN_isVarArgs, 1, 0, NULL},
	{Mapper_isInterface, 0, CLASS_Mapper, METHODN_isInterface, 1, 0, NULL},
	{Mapper_isICast, 0, CLASS_Mapper, METHODN_isICast, 1, 0, NULL},
	{Mapper_isSignificant, 0, CLASS_Mapper, METHODN_isSignificant, 1, 0, NULL},
	{Mapper_isFinal, 0, CLASS_Mapper, METHODN_isFinal, 1, 0, NULL},
	{Mapper_isSynonym, 0, CLASS_Mapper, METHODN_isSynonym, 1, 0, NULL},
	{Mapper_isLossLess, 0, CLASS_Mapper, METHODN_isLossLess, 1, 0, NULL},
	{Mapper_isTotal, 0, CLASS_Mapper, METHODN_isTotal, 1, 0, NULL},
	{Mapper_isPartial, 0, CLASS_Mapper, METHODN_isPartial, 1, 0, NULL},
	{Mapper_isConst, 0, CLASS_Mapper, METHODN_isConst, 1, 0, NULL},
	{Mapper_isTemporal, 0, CLASS_Mapper, METHODN_isTemporal, 1, 0, NULL},
	{Mapper_isLocal, 0, CLASS_Mapper, METHODN_isLocal, 1, 0, NULL},
	{Mapper_isDerived, 0, CLASS_Mapper, METHODN_isDerived, 1, 0, NULL},
	{OutputStream_isAutoFlush, 0, CLASS_OutputStream, METHODN_isAutoFlush, 1, 0, NULL},
	{OutputStream_setAutoFlush, 0, CLASS_OutputStream, METHODN_setAutoFlush, 2, 0, NULL},
	{OutputStream_isStoringBuffer, 0, CLASS_OutputStream, METHODN_isStoringBuffer, 1, 0, NULL},
	{OutputStream_setStoringBuffer, 0, CLASS_OutputStream, METHODN_setStoringBuffer, 2, 0, NULL},
	{Exception_isLogging, 0, CLASS_Exception, METHODN_isLogging, 1, 0, NULL},
	{Context_isStrict, 0, CLASS_Context, METHODN_isStrict, 1, 0, NULL},
	{Context_setStrict, 0, CLASS_Context, METHODN_setStrict, 2, 0, NULL},
	{Context_isDebug, 0, CLASS_Context, METHODN_isDebug, 1, 0, NULL},
	{Context_setDebug, 0, CLASS_Context, METHODN_setDebug, 2, 0, NULL},
	{Context_isVerbose, 0, CLASS_Context, METHODN_isVerbose, 1, 0, NULL},
	{Context_setVerbose, 0, CLASS_Context, METHODN_setVerbose, 2, 0, NULL},
	{Context_isInteractive, 0, CLASS_Context, METHODN_isInteractive, 1, 0, NULL},
	{NULL}
};

static knh_MapperData_t MapperData[] = {
	{NULL}
};
