zq2cw.h

This software performs code conversion of Chinese characters, including GB2312/GBK and BIG5. It a

      0x8FA0,  0x8FA1,  0x8FA2,  0x8FA3,  0x8FA4,  0x8FA5,  0x8FA6,  0x8FA7,  // 0x8FAx
      0x8FA8,  0x8FA9,  0x8FAA,  0x8FAB,  0x8FAC,  0x8FAD,  0x8FAE,  0x8FAF,  
      0x8FB0,  0x8FB1,  0x8FB2,  0x8FB3,  0x8FB4,  0x8FB5,  0x8FB6,  0x8FB7,  // 0x8FBx
      0x8FB8,  0x8FB9,  0x8FBA,  0x8FBB,  0x8FBC,  0x8FBD,  0x8FBE,  0x8FBF,  
      0x8FC0,  0x8FC1,  0x8FC2,  0x8FC3,  0x8FC4,  0x8FC5,  0x8FC6,  0x8FC7,  // 0x8FCx
      0x8FC8,  0x8FC9,  0x8FCA,  0x8FCB,  0x8FCC,  0x8FCD,  0x8FCE,  0x8FCF,  
      0x8FD0,  0x8FD1,  0x8FD2,  0x8FD3,  0x8FD4,  0x8FD5,  0x8FD6,  0x8FD7,  // 0x8FDx
      0x8FD8,  0x8FD9,  0x8FDA,  0x8FDB,  0x8FDC,  0x8FDD,  0x8FDE,  0x8FDF,  
      0x8FE0,  0x8FE1,  0x8FE2,  0x8FE3,  0x8FE4,  0x8FE5,  0x8FE6,  0x8FE7,  // 0x8FEx
      0x8FE8,  0x8FE9,  0x8FEA,  0x8FEB,  0x8FEC,  0x8FED,  0x8FEE,  0x8FEF,  
      0x8FF0,  0x8FF1,  0x8FF2,  0x8FF3,  0x8FF4,  0x8FF5,  0x8FF6,  0x8FF7,  // 0x8FFx
      0x8FF8,  0x8FF9,  0x8FFA,  0x8FFB,  0x8FFC,  0,       0,       0,       
} ;
#endif


#ifdef NH2CW_H
#define  Zq2cwTable_90  Nh2cwTable_90
#else
static const unsigned short Zq2cwTable_90 [] = {
      0x9040,  0x9041,  0x9042,  0x9043,  0x9044,  0x9045,  0x9046,  0x9047,  // 0x904x
      0x9048,  0x9049,  0x904A,  0x904B,  0x904C,  0x904D,  0x904E,  0x904F,  
      0x9050,  0x9051,  0x9052,  0x9053,  0x9054,  0x9055,  0x9056,  0x9057,  // 0x905x
      0x9058,  0x9059,  0x905A,  0x905B,  0x905C,  0x905D,  0x905E,  0x905F,  
      0x9060,  0x9061,  0x9062,  0x9063,  0x9064,  0x9065,  0x9066,  0x9067,  // 0x906x
      0x9068,  0x9069,  0x906A,  0x906B,  0x906C,  0x906D,  0x906E,  0x906F,  
      0x9070,  0x9071,  0x9072,  0x9073,  0x9074,  0x9075,  0x9076,  0x9077,  // 0x907x
      0x9078,  0x9079,  0x907A,  0x907B,  0x907C,  0x907D,  0x907E,  0,       
      0x9080,  0x9081,  0x9082,  0x9083,  0x9084,  0x9085,  0x9086,  0x9087,  // 0x908x
      0x9088,  0x9089,  0x908A,  0x908B,  0x908C,  0x908D,  0x908E,  0x908F,  
      0x9090,  0x9091,  0x9092,  0x9093,  0x9094,  0x9095,  0x9096,  0x9097,  // 0x909x
      0x9098,  0x9099,  0x909A,  0x909B,  0x909C,  0x909D,  0x909E,  0x909F,  
      0x90A0,  0x90A1,  0x90A2,  0x90A3,  0x90A4,  0x90A5,  0x90A6,  0x90A7,  // 0x90Ax
      0x90A8,  0x90A9,  0x90AA,  0x90AB,  0x90AC,  0x90AD,  0x90AE,  0x90AF,  
      0x90B0,  0x90B1,  0x90B2,  0x90B3,  0x90B4,  0x90B5,  0x90B6,  0x90B7,  // 0x90Bx
      0x90B8,  0x90B9,  0x90BA,  0x90BB,  0x90BC,  0x90BD,  0x90BE,  0x90BF,  
      0x90C0,  0x90C1,  0x90C2,  0x90C3,  0x90C4,  0x90C5,  0x90C6,  0x90C7,  // 0x90Cx
      0x90C8,  0x90C9,  0x90CA,  0x90CB,  0x90CC,  0x90CD,  0x90CE,  0x90CF,  
      0x90D0,  0x90D1,  0x90D2,  0x90D3,  0x90D4,  0x90D5,  0x90D6,  0x90D7,  // 0x90Dx
      0x90D8,  0x90D9,  0x90DA,  0x90DB,  0x90DC,  0x90DD,  0x90DE,  0x90DF,  
      0x90E0,  0x90E1,  0x90E2,  0x90E3,  0x90E4,  0x90E5,  0x90E6,  0x90E7,  // 0x90Ex
      0x90E8,  0x90E9,  0x90EA,  0x90EB,  0x90EC,  0x90ED,  0x90EE,  0x90EF,  
      0x90F0,  0x90F1,  0x90F2,  0x90F3,  0x90F4,  0x90F5,  0x90F6,  0x90F7,  // 0x90Fx
      0x90F8,  0x90F9,  0x90FA,  0x90FB,  0x90FC,  0,       0,       0,       
} ;
#endif


#ifdef NH2CW_H
#define  Zq2cwTable_91  Nh2cwTable_91
#else
static const unsigned short Zq2cwTable_91 [] = {
      0x9140,  0x9141,  0x9142,  0x9143,  0x9144,  0x9145,  0x9146,  0x9147,  // 0x914x
      0x9148,  0x9149,  0x914A,  0x914B,  0x914C,  0x914D,  0x914E,  0x914F,  
      0x9150,  0x9151,  0x9152,  0x9153,  0x9154,  0x9155,  0x9156,  0x9157,  // 0x915x
      0x9158,  0x9159,  0x915A,  0x915B,  0x915C,  0x915D,  0x915E,  0x915F,  
      0x9160,  0x9161,  0x9162,  0x9163,  0x9164,  0x9165,  0x9166,  0x9167,  // 0x916x
      0x9168,  0x9169,  0x916A,  0x916B,  0x916C,  0x916D,  0x916E,  0x916F,  
      0x9170,  0x9171,  0x9172,  0x9173,  0x9174,  0x9175,  0x9176,  0x9177,  // 0x917x
      0x9178,  0x9179,  0x917A,  0x917B,  0x917C,  0x917D,  0x917E,  0,       
      0x9180,  0x9181,  0x9182,  0x9183,  0x9184,  0x9185,  0x9186,  0x9187,  // 0x918x
      0x9188,  0x9189,  0x918A,  0x918B,  0x918C,  0x918D,  0x918E,  0x918F,  
      0x9190,  0x9191,  0x9192,  0x9193,  0x9194,  0x9195,  0x9196,  0x9197,  // 0x919x
      0x9198,  0x9199,  0x919A,  0x919B,  0x919C,  0x919D,  0x919E,  0x919F,  
      0x91A0,  0x91A1,  0x91A2,  0x91A3,  0x91A4,  0x91A5,  0x91A6,  0x91A7,  // 0x91Ax
      0x91A8,  0x91A9,  0x91AA,  0x91AB,  0x91AC,  0x91AD,  0x91AE,  0x91AF,  
      0x91B0,  0x91B1,  0x91B2,  0x91B3,  0x91B4,  0x91B5,  0x91B6,  0x91B7,  // 0x91Bx
      0x91B8,  0x91B9,  0x91BA,  0x91BB,  0x91BC,  0x91BD,  0x91BE,  0x91BF,  
      0x91C0,  0x91C1,  0x91C2,  0x91C3,  0x91C4,  0x91C5,  0x91C6,  0x91C7,  // 0x91Cx
      0x91C8,  0x91C9,  0x91CA,  0x91CB,  0x91CC,  0x91CD,  0x91CE,  0x91CF,  
      0x91D0,  0x91D1,  0x91D2,  0x91D3,  0x91D4,  0x91D5,  0x91D6,  0x91D7,  // 0x91Dx
      0x91D8,  0x91D9,  0x91DA,  0x91DB,  0x91DC,  0x91DD,  0x91DE,  0x91DF,  
      0x91E0,  0x91E1,  0x91E2,  0x91E3,  0x91E4,  0x91E5,  0x91E6,  0x91E7,  // 0x91Ex
      0x91E8,  0x91E9,  0x91EA,  0x91EB,  0x91EC,  0x91ED,  0x91EE,  0x91EF,  
      0x91F0,  0x91F1,  0x91F2,  0x91F3,  0x91F4,  0x91F5,  0x91F6,  0x91F7,  // 0x91Fx
      0x91F8,  0x91F9,  0x91FA,  0x91FB,  0x91FC,  0,       0,       0,       
} ;
#endif


#ifdef NH2CW_H
#define  Zq2cwTable_92  Nh2cwTable_92
#else
static const unsigned short Zq2cwTable_92 [] = {
      0x9240,  0x9241,  0x9242,  0x9243,  0x9244,  0x9245,  0x9246,  0x9247,  // 0x924x
      0x9248,  0x9249,  0x924A,  0x924B,  0x924C,  0x924D,  0x924E,  0x924F,  
      0x9250,  0x9251,  0x9252,  0x9253,  0x9254,  0x9255,  0x9256,  0x9257,  // 0x925x
      0x9258,  0x9259,  0x925A,  0x925B,  0x925C,  0x925D,  0x925E,  0x925F,  
      0x9260,  0x9261,  0x9262,  0x9263,  0x9264,  0x9265,  0x9266,  0x9267,  // 0x926x
      0x9268,  0x9269,  0x926A,  0x926B,  0x926C,  0x926D,  0x926E,  0x926F,  
      0x9270,  0x9271,  0x9272,  0x9273,  0x9274,  0x9275,  0x9276,  0x9277,  // 0x927x
      0x9278,  0x9279,  0x927A,  0x927B,  0x927C,  0x927D,  0x927E,  0,       
      0x9280,  0x9281,  0x9282,  0x9283,  0x9284,  0x9285,  0x9286,  0x9287,  // 0x928x
      0x9288,  0x9289,  0x928A,  0x928B,  0x928C,  0x928D,  0x928E,  0x928F,  
      0x9290,  0x9291,  0x9292,  0x9293,  0x9294,  0x9295,  0x9296,  0x9297,  // 0x929x
      0x9298,  0x9299,  0x929A,  0x929B,  0x929C,  0x929D,  0x929E,  0x929F,  
      0x92A0,  0x92A1,  0x92A2,  0x92A3,  0x92A4,  0x92A5,  0x92A6,  0x92A7,  // 0x92Ax
      0x92A8,  0x92A9,  0x92AA,  0x92AB,  0x92AC,  0x92AD,  0x92AE,  0x92AF,  
      0x92B0,  0x92B1,  0x92B2,  0x92B3,  0x92B4,  0x92B5,  0x92B6,  0x92B7,  // 0x92Bx
      0x92B8,  0x92B9,  0x92BA,  0x92BB,  0x92BC,  0x92BD,  0x92BE,  0x92BF,  
      0x92C0,  0x92C1,  0x92C2,  0x92C3,  0x92C4,  0x92C5,  0x92C6,  0x92C7,  // 0x92Cx
      0x92C8,  0x92C9,  0x92CA,  0x92CB,  0x92CC,  0x92CD,  0x92CE,  0x92CF,  
      0x92D0,  0x92D1,  0x92D2,  0x92D3,  0x92D4,  0x92D5,  0x92D6,  0x92D7,  // 0x92Dx
      0x92D8,  0x92D9,  0x92DA,  0x92DB,  0x92DC,  0x92DD,  0x92DE,  0x92DF,  
      0x92E0,  0x92E1,  0x92E2,  0x92E3,  0x92E4,  0x92E5,  0x92E6,  0x92E7,  // 0x92Ex
      0x92E8,  0x92E9,  0x92EA,  0x92EB,  0x92EC,  0x92ED,  0x92EE,  0x92EF,  
      0x92F0,  0x92F1,  0x92F2,  0x92F3,  0x92F4,  0x92F5,  0x92F6,  0x92F7,  // 0x92Fx
      0x92F8,  0x92F9,  0x92FA,  0x92FB,  0x92FC,  0,       0,       0,       
} ;
#endif


#ifdef NH2CW_H
#define  Zq2cwTable_93  Nh2cwTable_93
#else
static const unsigned short Zq2cwTable_93 [] = {
      0x9340,  0x9341,  0x9342,  0x9343,  0x9344,  0x9345,  0x9346,  0x9347,  // 0x934x
      0x9348,  0x9349,  0x934A,  0x934B,  0x934C,  0x934D,  0x934E,  0x934F,  
      0x9350,  0x9351,  0x9352,  0x9353,  0x9354,  0x9355,  0x9356,  0x9357,  // 0x935x
      0x9358,  0x9359,  0x935A,  0x935B,  0x935C,  0x935D,  0x935E,  0x935F,  
      0x9360,  0x9361,  0x9362,  0x9363,  0x9364,  0x9365,  0x9366,  0x9367,  // 0x936x
      0x9368,  0x9369,  0x936A,  0x936B,  0x936C,  0x936D,  0x936E,  0x936F,  
      0x9370,  0x9371,  0x9372,  0x9373,  0x9374,  0x9375,  0x9376,  0x9377,  // 0x937x
      0x9378,  0x9379,  0x937A,  0x937B,  0x937C,  0x937D,  0x937E,  0,       
      0x9380,  0x9381,  0x9382,  0x9383,  0x9384,  0x9385,  0x9386,  0x9387,  // 0x938x
      0x9388,  0x9389,  0x938A,  0x938B,  0x938C,  0x938D,  0x938E,  0x938F,  
      0x9390,  0x9391,  0x9392,  0x9393,  0x9394,  0x9395,  0x9396,  0x9397,  // 0x939x
      0x9398,  0x9399,  0x939A,  0x939B,  0x939C,  0x939D,  0x939E,  0x939F,  
      0x93A0,  0x93A1,  0x93A2,  0x93A3,  0x93A4,  0x93A5,  0x93A6,  0x93A7,  // 0x93Ax
      0x93A8,  0x93A9,  0x93AA,  0x93AB,  0x93AC,  0x93AD,  0x93AE,  0x93AF,  
      0x93B0,  0x93B1,  0x93B2,  0x93B3,  0x93B4,  0x93B5,  0x93B6,  0x93B7,  // 0x93Bx
      0x93B8,  0x93B9,  0x93BA,  0x93BB,  0x93BC,  0x93BD,  0x93BE,  0x93BF,  
      0x93C0,  0x93C1,  0x93C2,  0x93C3,  0x93C4,  0x93C5,  0x93C6,  0x93C7,  // 0x93Cx
      0x93C8,  0x93C9,  0x93CA,  0x93CB,  0x93CC,  0x93CD,  0x93CE,  0x93CF,  
      0x93D0,  0x93D1,  0x93D2,  0x93D3,  0x93D4,  0x93D5,  0x93D6,  0x93D7,  // 0x93Dx
      0x93D8,  0x93D9,  0x93DA,  0x93DB,  0x93DC,  0x93DD,  0x93DE,  0x93DF,  
      0x93E0,  0x93E1,  0x93E2,  0x93E3,  0x93E4,  0x93E5,  0x93E6,  0x93E7,  // 0x93Ex
      0x93E8,  0x93E9,  0x93EA,  0x93EB,  0x93EC,  0x93ED,  0x93EE,  0x93EF,  
      0x93F0,  0x93F1,  0x93F2,  0x93F3,  0x93F4,  0x93F5,  0x93F6,  0x93F7,  // 0x93Fx
      0x93F8,  0x93F9,  0x93FA,  0x93FB,  0x93FC,  0,       0,       0,       
} ;
#endif


#ifdef NH2CW_H
#define  Zq2cwTable_94  Nh2cwTable_94
#else
static const unsigned short Zq2cwTable_94 [] = {
      0x9440,  0x9441,  0x9442,  0x9443,  0x9444,  0x9445,  0x9446,  0x9447,  // 0x944x
      0x9448,  0x9449,  0x944A,  0x944B,  0x944C,  0x944D,  0x944E,  0x944F,  
      0x9450,  0x9451,  0x9452,  0x9453,  0x9454,  0x9455,  0x9456,  0x9457,  // 0x945x
      0x9458,  0x9459,  0x945A,  0x945B,  0x945C,  0x945D,  0x945E,  0x945F,  
      0x9460,  0x9461,  0x9462,  0x9463,  0x9464,  0x9465,  0x9466,  0x9467,  // 0x946x
      0x9468,  0x9469,  0x946A,  0x946B,  0x946C,  0x946D,  0x946E,  0x946F,  
      0x9470,  0x9471,  0x9472,  0x9473,  0x9474,  0x9475,  0x9476,  0x9477,  // 0x947x
      0x9478,  0x9479,  0x947A,  0x947B,  0x947C,  0x947D,  0x947E,  0,       
      0x9480,  0x9481,  0x9482,  0x9483,  0x9484,  0x9485,  0x9486,  0x9487,  // 0x948x
      0x9488,  0x9489,  0x948A,  0x948B,  0x948C,  0x948D,  0x948E,  0x948F,  
      0x9490,  0x9491,  0x9492,  0x9493,  0x9494,  0x9495,  0x9496,  0x9497,  // 0x949x
      0x9498,  0x9499,  0x949A,  0x949B,  0x949C,  0x949D,  0x949E,  0x949F,  
      0x94A0,  0x94A1,  0x94A2,  0x94A3,  0x94A4,  0x94A5,  0x94A6,  0x94A7,  // 0x94Ax
      0x94A8,  0x94A9,  0x94AA,  0x94AB,  0x94AC,  0x94AD,  0x94AE,  0x94AF,  
      0x94B0,  0x94B1,  0x94B2,  0x94B3,  0x94B4,  0x94B5,  0x94B6,  0x94B7,  // 0x94Bx
      0x94B8,  0x94B9,  0x94BA,  0x94BB,  0x94BC,  0x94BD,  0x94BE,  0x94BF,  
      0x94C0,  0x94C1,  0x94C2,  0x94C3,  0x94C4,  0x94C5,  0x94C6,  0x94C7,  // 0x94Cx
      0x94C8,  0x94C9,  0x94CA,  0x94CB,  0x94CC,  0x94CD,  0x94CE,  0x94CF,  
      0x94D0,  0x94D1,  0x94D2,  0x94D3,  0x94D4,  0x94D5,  0x94D6,  0x94D7,  // 0x94Dx
      0x94D8,  0x94D9,  0x94DA,  0x94DB,  0x94DC,  0x94DD,  0x94DE,  0x94DF,  
      0x94E0,  0x94E1,  0x94E2,  0x94E3,  0x94E4,  0x94E5,  0x94E6,  0x94E7,  // 0x94Ex
      0x94E8,  0x94E9,  0x94EA,  0x94EB,  0x94EC,  0x94ED,  0x94EE,  0x94EF,  
      0x94F0,  0x94F1,  0x94F2,  0x94F3,  0x94F4,  0x94F5,  0x94F6,  0x94F7,  // 0x94Fx
      0x94F8,  0x94F9,  0x94FA,  0x94FB,  0x94FC,  0,       0,       0,       
} ;
#endif


#ifdef NH2CW_H
#define  Zq2cwTable_95  Nh2cwTable_95
#else
static const unsigned short Zq2cwTable_95 [] = {
      0x9540,  0x9541,  0x9542,  0x9543,  0x9544,  0x9545,  0x9546,  0x9547,  // 0x954x
      0x9548,  0x9549,  0x954A,  0x954B,  0x954C,  0x954D,  0x954E,  0x954F,  
      0x9550,  0x9551,  0x9552,  0x9553,  0x9554,  0x9555,  0x9556,  0x9557,  // 0x955x
      0x9558,  0x9559,  0x955A,  0x955B,  0x955C,  0x955D,  0x955E,  0x955F,  
      0x9560,  0x9561,  0x9562,  0x9563,  0x9564,  0x9565,  0x9566,  0x9567,  // 0x956x
      0x9568,  0x9569,  0x956A,  0x956B,  0x956C,  0x956D,  0x956E,  0x956F,  
      0x9570,  0x9571,  0x9572,  0x9573,  0x9574,  0x9575,  0x9576,  0x9577,  // 0x957x
      0x9578,  0x9579,  0x957A,  0x957B,  0x957C,  0x957D,  0x957E,  0,       
      0x9580,  0x9581,  0x9582,  0x9583,  0x9584,  0x9585,  0x9586,  0x9587,  // 0x958x
      0x9588,  0x9589,  0x958A,  0x958B,  0x958C,  0x958D,  0x958E,  0x958F,  
      0x9590,  0x9591,  0x9592,  0x9593,  0x9594,  0x9595,  0x9596,  0x9597,  // 0x959x
      0x9598,  0x9599,  0x959A,  0x959B,  0x959C,  0x959D,  0x959E,  0x959F,  
      0x95A0,  0x95A1,  0x95A2,  0x95A3,  0x95A4,  0x95A5,  0x95A6,  0x95A7,  // 0x95Ax
      0x95A8,  0x95A9,  0x95AA,  0x95AB,  0x95AC,  0x95AD,  0x95AE,  0x95AF,  
      0x95B0,  0x95B1,  0x95B2,  0x95B3,  0x95B4,  0x95B5,  0x95B6,  0x95B7,  // 0x95Bx
      0x95B8,  0x95B9,  0x95BA,  0x95BB,  0x95BC,  0x95BD,  0x95BE,  0x95BF,  
      0x95C0,  0x95C1,  0x95C2,  0x95C3,  0x95C4,  0x95C5,  0x95C6,  0x95C7,  // 0x95Cx
      0x95C8,  0x95C9,  0x95CA,  0x95CB,  0x95CC,  0x95CD,  0x95CE,  0x95CF,  
      0x95D0,  0x95D1,  0x95D2,  0x95D3,  0x95D4,  0x95D5,  0x95D6,  0x95D7,  // 0x95Dx
      0x95D8,  0x95D9,  0x95DA,  0x95DB,  0x95DC,  0x95DD,  0x95DE,  0x95DF,  
      0x95E0,  0x95E1,  0x95E2,  0x95E3,  0x95E4,  0x95E5,  0x95E6,  0x95E7,  // 0x95Ex
      0x95E8,  0x95E9,  0x95EA,  0x95EB,  0x95EC,  0x95ED,  0x95EE,  0x95EF,