kolibrios/programs/develop/cmm/tokr.cpp

#define _TOKR_

#include "tok.h"

char useasm=FALSE;
char asmparam=FALSE;
#include "asmnemon.h"

void asmtwo1(int basecode); // used for ADD ADC SUB SBB CMP AND OR XOR.
void asmregmem(int out1,int out2); // used for LEA LDS LES LFS LGS LSS.
void Scanbit(int basecode);
void CheckBit(int code);
void asmone1(int basecode); 			// used for INC and DEC.
void asmone2(int basecode); 			// used for NEG NOT MUL IMUL DIV IDIV.
void asmshortjump(int shortcode,int nearcode);
void lar_lsl(int code);
unsigned char tabldeckr(int code);
void protectinstr(int code,int code2);
void doasmmov();		 // do MOV
void asmextend(int basecode); 	// procedure MOVSX and MOVZX
void movd();
void movq();
void packMMX(int code,int code1,int code2);
void asmshift(int basecode);			// used for ROL ROR RCL RCR SHL SAL SHR SAR.
void Shxd(int code);
void FpuType1(unsigned int addrm);
void FpuType2(unsigned int addrm,unsigned int addrm2);
void FpuType3(unsigned int opcode,unsigned int addrm);
void FpuType4(unsigned int opcode,unsigned int addrm);
void FpuType5(unsigned int opcode,unsigned int addrm);
void FpuType6(unsigned int opcode,unsigned int addrm);
void FpuType7(unsigned int addrm);
void FpuType8(unsigned int opcode,unsigned int addrm);
void addlocaljump(int callkind);
unsigned long SaveNumber(int type,int tok4,char *name);
void cmov(int num);
void mmxiii(int type);
void prefetch(int code, int type);
void pextrw();
void pinsrw();
void pshufw();
void xmminstr(int type,int sec,int op1=tk_xmmreg,int op2=tk_xmmreg);
void xmm3instr(int type,int sec);
void xmm2xmm(int code,int code2=0,int type=tk_xmmreg);
void movxmm(int code,int code2,int addc=1);
void movxmm2(int code,int code2=0);
void movxmm3(int code,int code2=0,int type=tk_xmmreg);
void movxmm4(int code,int code2);
void shiftxmm(int rm);	//rxmm,i8
void DDDW(int faradd);
void AADM(int code);

extern void shortjumperror();
extern void invalidfarjumpitem();
extern void invalidfarcallitem();
extern void bytedxexpected();
extern void axalexpected();
extern void clornumberexpected();
extern void reg32regexpected(int type);
extern void begexpected(int type);
extern void regexpected(int type);
extern void invalidoperand(int type);
extern void mmxregexpected(int type=0);
extern void mmxregordwordexpected(int type);
extern void mmxormem(int type);
extern void reg32orword(int type);
extern void xmmregorvarexpected(int type);
extern void xmmregexpected(int type);
extern void fpustakexpected(int type);
extern void fpuvarexpected(int type);

void doasm(int nexta)
{
unsigned char possiblecpu=0,next=1;
int htok;
ITOK hstok;
char *hbuf;
SINFO hstr;
unsigned int i=0;
int razr=r16;
unsigned long hnumber;
int faradd=0;
	if(nexta==FALSE){
		useasm=TRUE;
		nexttok();
		useasm=FALSE;
	}
	if(tok==tk_idasm){
		htok=itok.rm;
		goto sw_asm;
	}
	if(tok==tk_ID||tok==tk_id||tok==tk_undefproc){
		if(tok2==tk_colon){	//<2F><>⪠
			if(tok==tk_undefproc)doanyundefproc();
			else doid((char)(tok==tk_ID?1:0),tk_void);
			return;
		}
		strupr((char *)string);
		htok=FastSearch((unsigned char *)asmMnem,ofsmnem,0,(char *)string);
sw_asm:
		asmparam=TRUE;
		switch(htok){
			case a_add: //ADD
			case a_or:	//OR
			case a_adc: //ADC
			case a_sbb:	//SBB
			case a_and:	//AND
			case a_sub:	//SUB
			case a_xor:	//XOR
			case a_cmp:	//CMP
				asmtwo1(htok*8);
				next=0;
				break;
			case a_not:	//NOT
			case a_neg:	//NEG
			case a_mul:	//MUL
			case a_div:	//DIV
			case a_idiv:	//IDIV
				asmone2((htok-a_not)*8+16);
				break;
			case a_rol:	//ROL
			case a_ror:	//ROR
			case a_rcl:	//RCL
			case a_rcr:	//RCR
			case a_shl:	//SHL
			case a_shr:	//SHR
			case a_sar:	//SAR
				asmshift((htok-a_rol)*8);
				next=0;
				break;
			case a_btc:	//BTC
			case a_btr: //BTR
			case a_bts: //BTS
			case a_bt:	//BT
				CheckBit((htok-a_bt)*8);
				next=0;
				break;
			case a_dec:	//DEC
			case a_inc:	//INC
				asmone1((htok-a_inc)*8);
				break;
			case a_shrd:	//SHRD
			case a_shld:	//SHLD
				Shxd((htok-a_shld)*8+0xa4);
				next=0;
				break;
			case a_aaa:
				ClearReg(AX);
				op(0x37);	//AAA
				break;
			case a_aad:
				ClearReg(AX);
				AADM(0xD5);	//AAD
				break;
			case a_aam:
				ClearReg(AX);
				AADM(0xD4);	//AAM
				break;
			case a_aas:
				ClearReg(AX);
				op(0x3F);	//AAS
				break;
			case a_adrsiz:
				op(0x67);
				possiblecpu=3;
				break;
			case a_arpl:	//ARPL
				nexttok();
				htok=tok;
				hstok=itok;
				hbuf=bufrm;
				bufrm=NULL;
				hstr=strinf;
				strinf.bufstr=NULL;
				nextexpecting2(tk_camma);
				if(tok!=tk_reg)regexpected(2);
				switch(htok){
					case tk_intvar:
					case tk_wordvar:
#ifdef OPTVARCONST
					ClearVarByNum(&hstok);
#endif
						CheckAllMassiv(hbuf,2,&hstr,&hstok);
						KillVar(hstok.name);
						outseg(&hstok,2);
						op(0x63);
						op(hstok.rm+(unsigned int)itok.number*8);
						outaddress(&hstok);
						break;
					case tk_reg:
						ClearReg(hstok.number);
 						op(0x63);
						op(192+(unsigned int)itok.number*8+hstok.number);
						break;
					default: wordvalexpected();
				}
				possiblecpu=2;
				break;
			case a_bound:	//BOUND
				asmregmem(0x62,0);
				possiblecpu=2;
				break;
			case a_lea:
				asmregmem(0x8D,0);	//LEA
				break;
			case a_lds:	//LDS
			case a_les:	//LES
				asmregmem(htok-a_les+0xC4,0);
				break;
			case a_lss:	//LSS
				asmregmem(0xF,0xB2);
				possiblecpu=3;
				break;
			case a_lgs:	//LGS
			case a_lfs:	//LFS
				asmregmem(0xF,htok-a_lfs+0xB4);
				possiblecpu=3;
				break;
			case a_bswap:	//BSWAP
				nexttok();
				ClearReg(itok.number);
				if(tok==tk_reg32||tok==tk_reg){
					op66(tok==tk_reg?r16:r32);
					op(0x0F);
					op(0xC8+(unsigned int)itok.number);
				}
				else preerror("Expecting 32 bit Register for BSWAP");
				possiblecpu=4;
				break;
			case a_bsf:	//BSF
			case a_bsr:	//BSR
				Scanbit(htok-a_bsf+0xbc);
				break;
			case a_call:	//CALL
				nexttok();
				htok=0;
				if(tok==tk_ID||tok==tk_id){
					if(stricmp("FAR",(char *)string)==0){
						nexttok();
						faradd=8;
						htok=1;
					}
					else if(stricmp("NEAR",(char *)string)==0){
						nexttok();
						htok=1;
					}
				}
				else if(tok==tk_far){
					nexttok();
					faradd=8;
					htok=1;
				}
//				printf("call %d\n",tok);
				switch(tok){
					case tk_proc:
						if(faradd==0){
							if(itok.segm==DYNAMIC){
								itok.segm=DYNAMIC_USED;
								updatetree();
							}
							int flag=itok.flag;
							if(itok.segm<NOT_DYNAMIC){	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>᪠<EFBFBD> <20><><EFBFBD>楤<EFBFBD><E6A5A4><EFBFBD>
								addacall(itok.number,(unsigned char)(am32!=FALSE?CALL_32:CALL_NEAR));
								callloc0();
							}
							else callloc(itok.number);
						}
						else invalidfarcallitem();
						break;
					case tk_number:
						asmparam=FALSE;
						hnumber=doconstdwordmath();
						if(faradd==0)callloc(hnumber);
						else{
							op(0x9A);
							expecting2(tk_colon);
							unsigned long tempi=doconstdwordmath();
							if(am32==FALSE)outword((unsigned int)tempi);
							else outdword(tempi);
							outword(hnumber);
						}
						next=0;
						break;	 /* CALL num */
					case tk_postnumber:
						if(faradd==0){
							itok.number=itok.number-outptr-3;
							op(0xE8);
							(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
							if(am32==FALSE)outword(itok.number);
							else outdword(itok.number-2);
/*							op(0xE8);
							(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
							if(am32==FALSE)outword((unsigned int)itok.number);
							else outdword(itok.number);*/
						}
						else invalidfarcallitem();
						break;
					case tk_reg32:
						op66(r32);
						goto callreg;
					case tk_reg:
						op66(r16);
callreg:
						if(faradd==0){
							op(0xFF);
							op(0xD0+(unsigned int)itok.number);
						} 	 /* CALL reg */
						else invalidfarcallitem();
						break;
					case tk_ID:
					case tk_id:
						if(faradd==0){
							tobedefined(am32==FALSE?CALL_NEAR:CALL_32,tk_void);
							callloc0();
						} 		 /* CALL NEAR */
						else invalidfarcallitem();
						break;
					case tk_declare:
						tok=tk_undefproc;
						updatetree();
					case tk_locallabel:
					case tk_undefproc:
						if(faradd==0){
							addacall((unsigned int)itok.number,
(unsigned char)((itok.flag&f_extern)!=0?CALL_EXT:(am32==FALSE?CALL_NEAR:CALL_32)));
							callloc0();
						} 			/* CALL NEAR */
						else invalidfarcallitem();
						break;
					case tk_dwordvar:
					case tk_longvar:
						i=2;
						if(am32==FALSE&&htok==0)faradd=8;
					case tk_intvar:
					case tk_wordvar:
						i+=2;
						CheckAllMassiv(bufrm,i,&strinf);
						outseg(&itok,2);
						op(0xFF); op(0x10+itok.rm+faradd);
						outaddress(&itok);
						break;
					default:
						preerror("Invalid item for CALL");
						break;
				}
#ifdef OPTVARCONST
				FreeGlobalConst();
#endif
				clearregstat();
				break;
			case a_cbw:
				ClearReg(AX);
				if(am32)op(0x66);
				op(0x98);	//CBW
				break;
			case a_cdq:
				ClearReg(DX);
				op66(r32);
				op(0x99);
				possiblecpu=3;	//CDQ
				break;
			case a_clc:
				op(0xF8);	//CLC
				break;
			case a_cld:
				op(0xFC);	//CLD
				break;
			case a_cli:
				op(0xFA);	//CLI
				break;
			case a_clts:	//CLTS
				outword(0x060F);
				possiblecpu=2;
				break;
			case a_cmc:
				op(0xF5);	//CMC
				break;
			case a_cmpsb:
				ClearReg(SI);
				ClearReg(DI);
				op(0xA6);
				break;
			case a_cmpsw:
				ClearReg(SI);
				ClearReg(DI);
				op66(r16);
				op(0xA7);
				break;
			case a_cmpsd:
				if(ScanTok3()==tk_camma&&tok2==tk_xmmreg){
					xmm3instr(0xC2,0xF2);
					possiblecpu=9;
					next=0;
				}
				else{
					ClearReg(SI);
					ClearReg(DI);
					op66(r32);
					op(0xA7);
					possiblecpu=3;
				}
				break;
			case a_cmpxchg:	//CMPXCHG
				nexttok();
				htok=tok;
				hstok=itok;
				hbuf=bufrm;
				bufrm=NULL;
				hstr=strinf;
				strinf.bufstr=NULL;
				nextexpecting2(tk_camma);
				i=r16;
				ClearReg(AX);
				switch(htok){
					case tk_reg32:
						i=r32;
					case tk_reg:
						ClearReg(hstok.number);
						switch(tok){
							case tk_reg32:
								if(i==r16)goto erreg;
							case tk_reg:
	 							op66(i);
								outword(0xB10F);
								op(128+64+(unsigned int)itok.number*8+hstok.number);
								break;
							case tk_longvar:
							case tk_dwordvar:
								if(i==r16)goto erreg;
							case tk_intvar:
							case tk_wordvar:
#ifdef OPTVARCONST
								ClearVarByNum(&itok);
#endif
								CheckAllMassiv(bufrm,i,&strinf);
	 							op66(i);
								outseg(&itok,3);
								outword(0xB10F);
								op(itok.rm+hstok.number*8);
								outaddress(&itok);
								break;
							default:
erreg:
								if(i==r16)wordvalexpected();
								else dwordvalexpected();
								break;
						}
						break;
					case tk_beg:
						ClearReg(hstok.number);
						switch(tok){
							case tk_beg:
								outword(0xB00F);
								op(128+64+(unsigned int)itok.number*8+hstok.number);
								break;
							case tk_charvar:
							case tk_bytevar:
								CheckAllMassiv(bufrm,1,&strinf);
								outseg(&itok,3);
								outword(0xB00F);
								op(itok.rm+hstok.number*8);
								outaddress(&itok);
								break;
							default: bytevalexpected(2);
								break;
						}
						break;
					case tk_charvar:
					case tk_bytevar:
#ifdef OPTVARCONST
						ClearVarByNum(&hstok);
#endif
						if(tok!=tk_beg)begexpected(2);
						CheckAllMassiv(hbuf,1,&hstr,&hstok);
						KillVar(hstok.name);
						outseg(&hstok,3);
						outword(0xB00F);
						op(hstok.rm+(unsigned int)itok.number*8);
						outaddress(&hstok);
						break;
					case tk_longvar:
					case tk_dwordvar:
						if(tok!=tk_reg32)reg32expected(2);
						i=r32;
						goto noint;
					case tk_intvar:
					case tk_wordvar:
						if(tok!=tk_reg)regexpected(2);
noint:
#ifdef OPTVARCONST
						ClearVarByNum(&hstok);
#endif
						CheckAllMassiv(hbuf,i,&hstr,&hstok);
						KillVar(hstok.name);
						op66(i);
						outseg(&hstok,3);
						outword(0xB10F);
						op(hstok.rm+(unsigned int)itok.number*8);
						outaddress(&hstok);
						break;
					default:
						varexpected(1);
						break;
				}
				possiblecpu=4;
				break;
			case a_cmpxchg8b:	//CMPXCHG8B
				nexttok();
				if(tok!=tk_qwordvar)qwordvalexpected();
#ifdef OPTVARCONST
				ClearVarByNum(&itok);
#endif
				CheckAllMassiv(bufrm,8,&strinf);
				KillVar(itok.name);
				outseg(&itok,3);
				outword(0xc70f);
				op(itok.rm+8);
				outaddress(&itok);
				possiblecpu=5;
				break;
			case a_cwd:
				ClearReg(DX);
				op66(r16);
				op(0x99);	//CWD
				break;
			case a_cwde:
				ClearReg(AX);
				if(!am32)op(0x66);
				op(0x98);
				possiblecpu=3;
				break;
			case a_cpuid:
				ClearReg(AX);
				ClearReg(BX);
				ClearReg(CX);
				ClearReg(DX);
				outword(0xa20f);	//CPUID
				possiblecpu=5;
				break;
			case a_daa:
				ClearReg(AX);
				op(0x27);	//DAA
				break;
			case a_das:
				ClearReg(AX);
				op(0x2F);	//DAS
				break;
			case a_db:	//DB
				dbgact++;
				asmparam=FALSE;
				do{
					i=1;
					nexttok();
					CheckIP();
					if(tok==tk_number){
						hnumber=doconstdwordmath();
						if(tok==tk_id&&strcmp((char *)string,"dup")==0){
							i=hnumber;
							nexttok();
							CheckMinusNum();
							if(tok==tk_number)hnumber=doconstdwordmath();
							else numexpected();
						}
						for(;i!=0;i--)op(hnumber);
					}
					else if(tok==tk_string){
						for(i=0;i<(unsigned int)itok.number;i++)opd(string[i]);
						switch(itok.flag&3){
							case zero_term:
								if(itok.flag&s_unicod)opd(0);
								opd(0);
								break;
							case dos_term:
								if(itok.flag&s_unicod)opd(0);
								opd('$');
								break;
						}
						nexttok();
					}
					else{
						numexpected();
						nexttok();
					}
				}while(tok==tk_camma);
				dbgact--;
				next=0;
				break;
			case a_dd:	//DD
				faradd++;
			case a_dw:	//DW
				DDDW(faradd);
				next=0;
				break;
			case a_enter:	//ENTER
				ClearReg(BP);
				op(0xC8);
				nexttok();
				if(tok==tk_number)outword((unsigned int)doconstlongmath());
				else{
					numexpected(1);
					nexttok();
				}
				expecting2(tk_camma);
				if(tok==tk_number)op((int)doconstlongmath());
				else{
					numexpected(2);
					nexttok();
				}
				next=0;
				possiblecpu=2;
				break;
			case a_emms:	//EMMS
				outword(0x770f);
				possiblecpu=6;
				break;
			case a_imul:	//IMUL
				nexttok();
				if(tok2!=tk_camma){
				ClearReg(AX);
					switch(tok){
						case tk_reg32:
							possiblecpu=3;
							razr=r32;
						case tk_reg:
							ClearReg(DX);
							op66(razr);
						  op(246+1);
							op(128+64+40+(unsigned int)itok.number);
							break;
						case tk_beg:
							op(246);
							op(128+64+40+(unsigned int)itok.number);
							break;
						case tk_charvar:
						case tk_bytevar:
							CheckAllMassiv(bufrm,1,&strinf);
							outseg(&itok,2);
							op(246);
							op(itok.rm+40);
							outaddress(&itok);
							break;
						case tk_longvar:
						case tk_dwordvar:
							CheckAllMassiv(bufrm,4,&strinf);
							possiblecpu=3;
							razr=r32;
						case tk_intvar:
						case tk_wordvar:
							CheckAllMassiv(bufrm,2,&strinf);
							ClearReg(DX);
							op66(razr);
							outseg(&itok,2);
							op(247);
							op(itok.rm+40);
							outaddress(&itok);
							break;
						default: varexpected(1);	break;
					}
				}
				else{
					htok=tok;
					hnumber=itok.number;
					ClearReg(hnumber);
					nextexpecting2(tk_camma);
					possiblecpu=2;
					if(tok2!=tk_camma){
						switch(tok){
							case tk_number:
								switch(htok){
									case tk_reg32:
										possiblecpu=3;
										razr=r32;
									case tk_reg:
										op66(razr);
										if(short_ok(itok.number,TRUE))i=2;	//<2F><><EFBFBD><EFBFBD>⪠<EFBFBD> <20><>ଠ
										op(0x69+i);
										op(0xc0+(unsigned int)hnumber+(unsigned int)hnumber*8);
										if(i==2)op(itok.number);
										else{
											if(htok==tk_reg)outword(itok.number);
											else outdword(itok.number);
										}
										break;
									default: reg32regexpected(1);
								}
								break;
							case tk_reg32:
								razr=r32;
							case tk_reg:
								op66(razr);
								possiblecpu=3;
								if(htok!=tok)reg32regexpected(1);
								outword(0xaf0f);
								op(0xc0+(unsigned int)itok.number+(unsigned int)hnumber*8);
								break;
							case tk_longvar:
								tok++;
							case tk_dwordvar:
								if(htok!=tk_reg32)reg32expected(1);
								CheckAllMassiv(bufrm,4,&strinf);
								razr=r32;
								goto imul1;
							case tk_intvar:
								tok++;
							case tk_wordvar:
imul1:
								possiblecpu=3;
								if(htok!=tk_reg&&(tok==tk_intvar||tok==tk_wordvar))regexpected(1);
								CheckAllMassiv(bufrm,2,&strinf);
								op66(razr);
								outseg(&itok,3);
								outword(0xaf0f);
								op(itok.rm+hnumber*8);
								outaddress(&itok);
								break;
							default: varexpected(2);
						}
					}
					else{
						int htok2=tok;
						hstok=itok;
						hbuf=bufrm;
						hstr=strinf;
						strinf.bufstr=NULL;
						bufrm=NULL;
						nextexpecting2(tk_camma);
						if(tok!=tk_number)numexpected(3);
						switch(htok2){
							case tk_reg32:
								possiblecpu=3;
								razr=r32;
							case tk_reg:
								op66(razr);
								if(htok!=htok2)reg32regexpected(2);
								if(short_ok(itok.number,TRUE))i=2;	//<2F><><EFBFBD><EFBFBD>⪠<EFBFBD> <20><>ଠ
								op(0x69+i);
								op(0xc0+(unsigned int)hstok.number+(unsigned int)hnumber*8);
								if(i==2)op(itok.number);
								else{
									if(htok==tk_reg)outword(itok.number);
									else outdword(itok.number);
								}
								break;
							case tk_longvar:
								tok++;
							case tk_dwordvar:
								possiblecpu=3;
								if(htok!=tk_reg32)reg32expected(2);
								CheckAllMassiv(hbuf,4,&hstr,&hstok);
								razr=r32;
								goto imul2;
							case tk_intvar:
								tok++;
							case tk_wordvar:
imul2:
								if(htok!=tk_reg&&(htok2==tk_intvar||htok2==tk_wordvar))regexpected(1);
								CheckAllMassiv(hbuf,2,&hstr,&hstok);
								op66(razr);
								if(short_ok(itok.number,TRUE))i=2;	//<2F><><EFBFBD><EFBFBD>⪠<EFBFBD> <20><>ଠ
								outseg(&hstok,2);
								op(0x69+i);
								op(hstok.rm+hnumber*8);
								outaddress(&hstok);
								if(i==2)op(itok.number);
								else{
									if(htok==tk_reg)outword(itok.number);
									else outdword(itok.number);
								}
								break;
							default: varexpected(2);
						}
					}
				}
				break;
			case a_in:	//IN
				ClearReg(AX);
				nexttok();
				if((tok==tk_reg||tok==tk_reg32)&&(unsigned int)itok.number==AX){
					op66(tok==tk_reg?r16:r32);
					if(tok==tk_reg32)possiblecpu=3;
					nexttok();
					expecting(tk_camma);
					if(tok==tk_number){
						op(0xE5);
						asmparam=FALSE;
						if((hnumber=doconstdwordmath())>255)bytedxexpected();
						op(hnumber);
						next = 0;
					}
					else if(tok==tk_reg&&(unsigned int)itok.number==DX)op(0xED);
					else bytedxexpected();
				}
				else if(tok==tk_beg&&(unsigned int)itok.number==AL){
					nexttok();
					expecting(tk_camma);
					if(tok==tk_number){
						op(0xE4);
						asmparam=FALSE;
						if((hnumber=doconstdwordmath())>255)bytedxexpected();
						op(hnumber);
						next=0;
					}
					else if(tok==tk_reg&&(unsigned int)itok.number==DX)op(0xEC);
					else bytedxexpected();
				}
				else axalexpected();
				break;
			case a_insb:	//INSB
				ClearReg(AX);
				ClearReg(DI);
				op(0x6C);
				possiblecpu=2;
				break;
			case a_insw:	//INSW
				op66(r16);
				possiblecpu=2;
				goto insd;
				break;
			case a_insd:	//INSD
				op66(r32);
				possiblecpu=3;
insd:
				op(0x6D);
				ClearReg(AX);
				ClearReg(DI);
				break;
			case a_int:	//INT
				clearregstat();
				nexttok();
				if(tok==tk_number){
					asmparam=FALSE;
					htok=doconstlongmath();
					if(htok==3)op(0xCC);
					else{
						op(0xCD);
						op(htok);
					}
					next=0;
				}
				else numexpected();
				break;
			case a_into:
				op(0xCE);	//INTO
				break;
			case a_invd:	//INVD
				outword(0x080F);
				possiblecpu=4;
				break;
			case a_invlpg:	//INVLPG
				nexttok();
				switch(tok){
					case tk_longvar:
					case tk_dwordvar:
						CheckAllMassiv(bufrm,4,&strinf);
						goto invlgp;
					case tk_intvar:
					case tk_wordvar:
						CheckAllMassiv(bufrm,2,&strinf);
invlgp:
						outseg(&itok,3);
						outword(0x010F);
						op(itok.rm+0x38);
						outaddress(&itok);
						break;

					case tk_undefofs:
						strcpy(hstok.name,itok.name);
						tok=tk_number;
					case tk_number:
						hnumber=doconstdwordmath();
						outword(0x010f);
						op((am32==FALSE?rm_d16:rm_d32)+0x38);
		 				if(postnumflag&f_reloc)AddReloc();
					 	if(htok==tk_undefofs)AddUndefOff(2,hstok.name);
						if(am32)outdword(hnumber);
						else outword(hnumber);
						next=0;
						break;
					case tk_postnumber:
						outword(0x010F);
						op((am32==FALSE?rm_d16:rm_d32)+0x38);
						(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
						if(am32==FALSE)outword(itok.number);	//<2F>뫮 0
						outdword(itok.number);
						break;

					default:
						varexpected(0); break;
				}
				possiblecpu=4;
				break;
			case a_iret:
#ifdef OPTVARCONST
				ClearLVIC();
#endif
				RestoreStack();
				clearregstat();
				op66(r16);
				op(0xCF);	//IRET
				break;
			case a_iretd:
#ifdef OPTVARCONST
				ClearLVIC();
#endif
				RestoreStack();
				clearregstat();
				op66(r32);
				op(0xCF);	//IRETD
				break;
			case a_jo:
			case a_jno:
			case a_jc:
			case a_jnc:
			case a_jz:
			case a_jnz:
			case a_jna:
			case a_ja:
			case a_js:
			case a_jns:
			case a_jp:
			case a_jnp:
			case a_jl:
			case a_jnl:
			case a_jng:
			case a_jg:
				RestoreStack();
				asmshortjump((htok-a_jo)+0x70,(htok-a_jo)+0x80);
				next=0;
				break;
			case a_jecxz:	//JECXZ
				RestoreStack();
				op67(r32);
				asmshortjump(0xE3,0);
				next=0;
				break;
			case a_jcxz:	//JCXZ
				RestoreStack();
				op67(r16);
				asmshortjump(0xE3,0);
				next=0;
				break;
			case a_jmp:	//JMP
				RestoreStack();
				nexttok();
				faradd=0;
				lastcommand=tk_goto;
				if(stricmp("FAR",itok.name)==0){
					nexttok();
					faradd=8;
				}
				else if(stricmp("NEAR",itok.name)==0)nexttok();
				else if(stricmp("SHORT",itok.name)==0){	 // case insensitive
					nexttok();
					next=(unsigned char)GOTO();
					break;
				}
				next=gotol(faradd);
				break;
			case a_lahf:
				ClearReg(AX);
				op(0x9F);	//LAHF
				break;
			case a_lar:	//LAR
			case a_lsl:	//LSL
				lar_lsl(htok-a_lar+2);
				break;
			case a_leave:	//LEAVE
				RestoreStack();
				op(0xC9);
				ClearReg(BP);
				possiblecpu = 2;
				break;
			case a_lmsw:
				protectinstr(1,0x30);	//LMSW
				break;
			case a_loadall:	// LOADALL 80286 only
				outword(0x050F);
				possiblecpu=2;
				break;
			case a_lodsb:
				ClearReg(SI);
				ClearReg(AX);
				op(0xAC);	//LODSB
				break;
			case a_lodsw:
				op66(r16);
				ClearReg(SI);
				ClearReg(AX);
				op(0xAD);	//LODSW
				break;
			case a_lodsd:
				op66(r32);
				ClearReg(SI);
				ClearReg(AX);
				op(0xAD);
				possiblecpu =3;	//LODSD
				break;
			case a_lock:
				op(0xF0);	//LOCK
				break;
			case a_loop:
				ConstToReg(0,CX,(am32+1)*2);
				op67(r16);
				asmshortjump(0xE2,0);
				next=0;
				break;
			case a_loopd:
				ConstToReg(0,CX,r32);
				possiblecpu=3;
				op67(r32);
				asmshortjump(0xE2,0);
				next=0;
				break;
			case a_loopz:	//LOOPE LOOPZ
				ClearReg(CX);
				asmshortjump(0xE1,0);
				next=0;
				break;
			case a_loopnz:	//LOOPNZ LOOPNE
				ClearReg(CX);
				asmshortjump(0xE0,0);
				next=0;
				break;
			case a_ltr:
				protectinstr(0,0x18);	//LTR
				break;
			case a_str:
				protectinstr(0,0x08);	//STR
				break;
			case a_lgdt:
				next=tabldeckr(0x10);
				break;
			case a_lidt:	//LIDT
				next=tabldeckr(0x18);
				break;
			case a_lldt:
				protectinstr(0,0x10);	//LLDT
				break;
			case a_mov:
				doasmmov();
				next=0;
				break;
			case a_movsb:
				movsb();	//MOVSB
				break;
			case a_movsd:
				if(ScanTok3()==tk_camma&&(tok2==tk_xmmreg||(tok2>=tk_charvar&&tok2<tk_qwordvar))){
					movxmm(0x10,0xf2);
					possiblecpu=9;
				}
				else movsd();	//MOVSD
				break;
			case a_movsw:
				movsw();	//MOVSW
				break;
			case a_movzx:
			case a_movsx:
				asmextend((htok-a_movzx)*8+0xB6);
				break;
			case a_movd:
				movd();	//MOVD
				break;
			case a_movq:
				movq();	//MOVQ
				break;
			case a_nop:
				op(0x90);	//NOP
				break;
			case a_opsiz:	//OPSIZ OPSIZE
				op(0x66);
				possiblecpu=3;
				break;
			case a_out:	//OUT
				nexttok();
				if(tok==tk_number){
					if((hnumber=doconstdwordmath())>255)bytedxexpected();
					expecting2(tk_camma);
					if((tok==tk_reg||tok==tk_reg32)&&(unsigned int)itok.number==AX){
						op66(tok==tk_reg?r16:r32);
						if(tok==tk_reg32)possiblecpu=3;
						op(0xE7);	op(hnumber);
					}
					else if(tok==tk_beg&&(unsigned int)itok.number==AL){
						op(0xE6);	op(hnumber);
					}
					else axalexpected();
				}
				else if(tok==tk_reg&&(unsigned int)itok.number==DX){
					nextexpecting2(tk_camma);
					if((tok==tk_reg||tok==tk_reg32)&&(unsigned int)itok.number==AX){
						op66(tok==tk_reg?r16:r32);
						if(tok==tk_reg32)possiblecpu=3;
						op(0xEF);
					}
					else if(tok==tk_beg&&(unsigned int)itok.number==AL)op(0xEE);
					else axalexpected();
				}
				else bytedxexpected();
				break;
			case a_outsb:	//OUTSB
				ClearReg(SI);
				op(0x6E);
				possiblecpu=2;
				break;
			case a_outsw:	//OUTSW
				ClearReg(SI);
				op66(r16);
				op(0x6F);
				possiblecpu=2;
				break;
			case a_outsd:	//OUTSD
				ClearReg(SI);
				op66(r32);
				op(0x6F);
				possiblecpu=3;
				break;
			case a_pop:	//POP
				RestoreStack();
				do{
					possiblecpu=0;
					asmparam=TRUE;
					nexttok();
					razr=r16;
					switch(tok){
						case tk_reg32:
							possiblecpu=3;
							razr=r32;
						case tk_reg:
							ClearReg(itok.number);
							op66(razr);
						  op(0x58+(unsigned int)itok.number); break;
						case tk_dwordvar:
							tok--;
						case tk_longvar:
							CheckAllMassiv(bufrm,4,&strinf);
							possiblecpu=3;
							razr=r32;
							goto pop;
						case tk_wordvar:
							tok--;
						case tk_intvar:
							CheckAllMassiv(bufrm,2,&strinf);
pop:
#ifdef OPTVARCONST
							ClearVarByNum(&itok);
#endif
							KillVar(itok.name);
							op66(razr);
							outseg(&itok,2);
							op(0x8F);	op(itok.rm);
							outaddress(&itok);
							break;
						case tk_seg:
							if(itok.number!=CS){
								PopSeg((unsigned int)itok.number);
								break;
							}
						default:
							preerror("Invalid operand for POP");
							break;
					}
					if(cpu<possiblecpu)cpu=possiblecpu;
					asmparam=FALSE;
					addESP-=razr==r16?2:4;
					nexttok();
				}while(tok==tk_camma);
				next=0;
				break;
			case a_popa:	//POPA
				razr=r16;
				possiblecpu=2;
				goto POPAD;
			case a_popad:	//POPAD
				razr=r32;
				possiblecpu=3;
POPAD:
				op66(razr);
				addESP-=razr==r16?16:32;
				RestoreStack();
				clearregstat();
				op(0x61);
				break;
			case a_popf:
				razr=r16;
				goto POPFD;
			case a_popfd:	//POPFD
				razr=r32;
				possiblecpu = 3;
POPFD:
				op66(razr);
				addESP-=razr==r16?2:4;
				RestoreStack();
				op(0x9D);
				break;
			case a_push:	//PUSH
				RestoreStack();
				do{
					asmparam=TRUE;
					nexttok();
					if((razr=Push())==FALSE)preerror("Invalid operand for PUSH");
					asmparam=FALSE;
					addESP+=razr==r16?2:4;
				}while(tok==tk_camma);
				next=0;
				break;
			case a_pusha:	//PUSHA
				razr=r16;
				possiblecpu=2;
				goto PUSHAD;
			case a_pushad:	//PUSHAD
				razr=r32;
				possiblecpu=3;
PUSHAD:
				op66(razr);
				addESP+=razr==r16?16:32;
				RestoreStack();
				op(0x60);
				break;
			case a_pushf:
				razr=r16;
				goto PUSHFD;
			case a_pushfd:	//PUSHFD
				razr=r32;
				possiblecpu=3;
PUSHFD:
				op66(razr);
				RestoreStack();
				op(0x9C);
				addESP+=razr==r16?2:4;
				break;
			case a_pcmpeqd:
			case a_pcmpeqw:
			case a_pcmpeqb:
			case a_packssdw:  //+xmm
			case a_punpckhdq:
			case a_punpckhwd:
			case a_punpckhbw:
			case a_packuswb:    //+xmm
			case a_pcmpgtd:
			case a_pcmpgtw:
			case a_pcmpgtb:
			case a_packsswb:	//+xmm
			case a_punpckldq:
			case a_punpcklwd:
			case a_punpcklbw:
				mmxiii(htok-a_punpcklbw+0x60);
				break;
			case a_pmullw:
				mmxiii(0xD5);	//PMULLW
				break;
			case a_pmuludq:
				mmxiii(0xF4);	//PMULUDQ
				break;
			case a_psubusb:
				mmxiii(0xD8);	//PSUBUSB
				break;
			case a_psubusw:
				mmxiii(0xD9);//PSUBUSW
				break;
			case a_pand:    //+xmm
				mmxiii(0xDB);	//PAND
				break;
			case a_paddusb:	//+xmm
				mmxiii(0xDC);	//PADDUSB
				break;
			case a_paddusw: //+xmm
				mmxiii(0xDD);//PADDUSW
				break;
			case a_pandn:   //+xmm
				mmxiii(0xDF);//PANDN
				break;
			case a_pause:
				outword(0x90F3);
				possiblecpu=9;
				break;
			case a_pmulhw:
				mmxiii(0xE5);	//PMULHW
				break;
			case a_psubsb:
				mmxiii(0xE8);	//PSUBSB
				break;
			case a_psubsw:
				mmxiii(0xE9);//PSUBSW
				break;
			case a_por:
				mmxiii(0xEB);	//POR
				break;
			case a_paddsb:	//+xmm
				mmxiii(0xEC);	//PADDSB
				break;
			case a_paddsw:  //+xmm
				mmxiii(0xED);//PADDSW
				break;
			case a_pxor:
				mmxiii(0xEF);	//PXOR
				break;
			case a_pmaddwd:
				mmxiii(0xF5);	//PMADDWD
				break;
			case a_psubb:
				mmxiii(0xF8);	//PSUBB
				break;
			case a_psubw:
				mmxiii(0xF9);//PSUBW
				break;
			case a_psubd:
				mmxiii(0xFA);//PSUBD
				break;
			case a_psubq:
				mmxiii(0xFB);//PSUBQ
				possiblecpu=9;
				break;
			case a_paddb:   //+xmm
				mmxiii(0xFC);	//PADDB
				break;
			case a_paddw:   //+xmm
				mmxiii(0xFD);//PADDW
				break;
			case a_paddd:   //+xmm
				mmxiii(0xFE);//PADDD
				break;
			case a_paddq:   //+xmm
				mmxiii(0xD4);//PADDQ
				possiblecpu=9;
				break;

			case a_psrlw:
				packMMX(0xD1,0x71,0xd0);	//PSRLW
				next=0;
				break;
			case a_psrld:
				packMMX(0xD2,0x72,0xd0);//PSRLD
				next=0;
				break;
			case a_psrlq:
				packMMX(0xD3,0x73,0xd0);//PSRLQ
				next=0;
				break;
			case a_psraw:
				packMMX(0xE1,0x71,0xe0);	//PSRAW
				next=0;
				break;
			case a_psrad:
				packMMX(0xE2,0x72,0xe0);//PSRAD
				next=0;
				break;
			case a_psllw:
				packMMX(0xF1,0x71,0xf0);	//PSLLW
				next=0;
				break;
			case a_pslld:
				packMMX(0xF2,0x72,0xf0);//PSLLD
				next=0;
				break;
			case a_psllq:
				packMMX(0xF3,0x73,0xf0);//PSLLQ
				next=0;
				break;
			case a_pslldq:
				shiftxmm(7);
				next=0;
				possiblecpu=9;
				break;
			case a_psrldq:
				shiftxmm(3);
				next=0;
				possiblecpu=9;
				break;
			case a_rdmsr:
				ClearReg(AX);
				ClearReg(DX);
				outword(0X320F);
				possiblecpu=5;
				break;
			case a_rdtsc:
				outword(0X310F);
				possiblecpu=5;
				break;
			case a_rep:
	      op(0xF3);//REP REPE REPZ
				ClearReg(CX);
				break;
			case a_repnz:
	      op(0xF2);	//REPNE REPNZ
				ClearReg(CX);
				break;
			case a_ret:	//RET
#ifdef OPTVARCONST
				ClearLVIC();
#endif
				RestoreStack();
				clearregstat();
				next=0;
				if(tok2==tk_number){
//					usedirectiv=TRUE;
					nexttok();
					op(0xC2);
				 	asmparam=FALSE;
					outword((unsigned int)doconstlongmath());
//					usedirectiv=FALSE;
				}
				else{
					op(0xC3);
					nexttok();
				}
				break;
			case a_retf:
#ifdef OPTVARCONST
				ClearLVIC();
#endif
				RestoreStack();
				clearregstat();
				next=0;
				if(tok2==tk_number){
					nexttok();
					op(0xCA);
				 	asmparam=FALSE;
					outword((unsigned int)doconstlongmath());
				}
				else{
					op(0xCB);
					nexttok();
				}//RETF
				break;
			case a_rsm:	//RSM
				outword(0Xaa0F);
				possiblecpu=5;
				break;
			case a_sahf:
				op(0x9E);	//SAHF
				break;
			case a_scasb:
				op(0xAE);	//SCASB
				ClearReg(DI);
				break;
			case a_scasw:
				op66(r16);
				op(0xAF);  //SCASW
				ClearReg(DI);
				break;
			case a_scasd:	//SCASD
				op66(r32);
				op(0xAF);
				possiblecpu=3;
				ClearReg(DI);
				break;
			case a_smsw:
				protectinstr(1,0x20);	//SMSW
				break;
			case a_stc:
				op(0xF9);	//STC
				break;
			case a_std:
				op(0xFD);	//STD
				break;
			case a_sti:
				op(0xFB);	//STI
				break;
			case a_stosb:
				stosb();	//STOSB
				break;
			case a_stosw:
				stosw();	//STOSW
				break;
			case a_stosd:
				stosd();	//STOSD
				break;
			case a_seto:
			case a_setno:
			case a_setc:
			case a_setnc:
			case a_setz:
			case a_setnz:
			case a_setna:
			case a_seta:
			case a_sets:
			case a_setns:
			case a_setp:
			case a_setnp:
			case a_setl:
			case a_setnl:
			case a_setng:
			case a_setg:
				i=htok-a_seto;
				nexttok();
				switch(tok){
					case tk_beg:
						ClearReg(itok.number%4);
						op(0xf);
						op(0x90+i);
						op(0xc0+(unsigned int)itok.number);
						break;
					case tk_charvar:
					case tk_bytevar:
						CheckAllMassiv(bufrm,1,&strinf);
						KillVar(itok.name);
						outseg(&itok,3);
						op(0xf);
						op(0x90+i);
						op(itok.rm);
						outaddress(&itok);
						break;
					default: bytevalexpected(0);
				}
				possiblecpu=3;
				break;
			case a_sgdt:
				next=tabldeckr(0);
				break;
			case a_sidt:
				next=tabldeckr(0x8);
				break;
			case a_sldt:
				protectinstr(0,0);	//SLDT
				break;
			case a_fwait:	//FWAIT
			case a_wait:
				fwait();//WAIT
				break;
			case a_wbinvd:	//WBINVD
				outword(0x090F);
				possiblecpu=4;
				break;
			case a_wrmsr:	//WRMSR
				outword(0x300F);
				possiblecpu=5;
				break;
			case a_xadd:	//XADD
				nexttok();
				hstok=itok;
				htok=tok;
				hbuf=bufrm;
				bufrm=NULL;
				hstr=strinf;
				strinf.bufstr=NULL;
				nextexpecting2(tk_camma);
				switch(htok){
					case tk_reg32:
						razr=r32;
					case tk_reg:
						switch(tok){
							case tk_reg32:
								if(razr==r16)goto erxreg;
							case tk_reg:
								RegToReg(itok.number,hstok.number,razr);
								ClearReg(hstok.number);
								op66(razr);
								outword(0xC10F);
								op(128+64+(unsigned int)itok.number*8+hstok.number);
								break;
							case tk_longvar:
							case tk_dwordvar:
								if(razr==r16)goto erxreg;
							case tk_intvar:
							case tk_wordvar:
								KillVar(hstok.name);
								/*if(bufrm==0&&strinf.bufstr==NULL)*/AddRegVar(hstok.number,razr,&itok);
								CheckAllMassiv(bufrm,razr,&strinf);
								op66(razr);
								outseg(&itok,3);
								outword(0xC10F);
								op(itok.rm+hstok.number*8);
								outaddress(&itok);
								break;
							default:
erxreg:
								wordvalexpected(); break;
						}
						break;
					case tk_beg:
						switch(tok){
							case tk_beg:
								RegToReg(itok.number,hstok.number,r8);
								ClearReg(hstok.number%4);
								outword(0xC00F);
								op(128+64+(unsigned int)itok.number*8+hstok.number);
								break;
							case tk_charvar:
							case tk_bytevar:
								KillVar(hstok.name);
								/*if(bufrm==0&&strinf.bufstr==NULL)*/AddRegVar(hstok.number,r8,&itok);
								CheckAllMassiv(bufrm,1,&strinf);
								outseg(&itok,3);
								outword(0xC00F);
								op(itok.rm+hstok.number*8);
								outaddress(&itok);
								break;
							default: bytevalexpected(2); break;
						}
						break;
					case tk_charvar:
					case tk_bytevar:
						if(tok!=tk_beg)begexpected(2);
						CheckAllMassiv(hbuf,1,&hstr,&hstok);
						ClearReg(itok.number);
						KillVar(hstok.name);
						outseg(&hstok,3);
						outword(0xC00F);
						op(hstok.rm+(unsigned int)itok.number*8);
						outaddress(&hstok);
						break;
					case tk_longvar:
					case tk_dwordvar:
						if(tok!=tk_reg32)reg32expected(2);
						razr=r32;
						goto nointxadd;
					case tk_intvar:
					case tk_wordvar:
						if(tok!=tk_reg)regexpected(1);
nointxadd:
						CheckAllMassiv(hbuf,razr,&hstr,&hstok);
						ClearReg(itok.number);
						KillVar(hstok.name);
						op66(razr);
						outseg(&hstok,3);
						outword(0xC10F);
						op(hstok.rm+(unsigned int)itok.number*8);
						outaddress(&hstok);
						break;
					default: varexpected(1); break;
				}
				possiblecpu=4;
				break;
			case a_xchg:	//XCHG
				nexttok();
				htok=tok;
				hstok=itok;
				hbuf=bufrm;
				bufrm=NULL;
				hstr=strinf;
				strinf.bufstr=NULL;
				nextexpecting2(tk_camma);
				switch(htok){
					case tk_reg32:
						razr=r32;
						possiblecpu=3;
					case tk_reg:
						switch(tok){
							case tk_reg32:
								if(razr==r16)goto erregx;
							case tk_reg:
								op66(razr);
								RegSwapReg(hstok.number,itok.number,razr);
								if(hstok.number==AX)op(0x90+(unsigned int)itok.number);
								else if((unsigned int)itok.number==AX)op(0x90+hstok.number);
								else{
									op(0x87);
									op(128+64+(unsigned int)itok.number*8+hstok.number);
								}
								break;
							case tk_longvar:
							case tk_dwordvar:
								if(razr==r16)goto erregx;
							case tk_intvar:
							case tk_wordvar:
								CheckAllMassiv(bufrm,razr,&strinf);
								KillVar(itok.name);
								IDZToReg(itok.name,hstok.number,razr);
								op66(razr);
								outseg(&itok,2);
								op(0x87);
								op(itok.rm+hstok.number*8);
								outaddress(&itok);
								break;
							default:
erregx:
								wordvalexpected(); break;
						}
						break;
					case tk_beg:
						switch(tok){
							case tk_beg:
								RegSwapReg(hstok.number,itok.number,r8);
								op(0x86);
								op(128+64+(unsigned int)itok.number*8+hstok.number);
								break;
							case tk_charvar:
							case tk_bytevar:
								CheckAllMassiv(bufrm,1,&strinf);
								KillVar(itok.name);
								IDZToReg(itok.name,hstok.number,r8);
								outseg(&itok,2);
								op(0x86);
								op(itok.rm+hstok.number*8);
								outaddress(&itok);
								break;
							default: bytevalexpected(2); break;
						}
						break;
					case tk_charvar:
					case tk_bytevar:
						if(tok!=tk_beg)begexpected(2);
						CheckAllMassiv(hbuf,1,&hstr,&hstok);
						KillVar(hstok.name);
						IDZToReg(hstok.name,itok.number,r8);
						outseg(&hstok,2);
						op(0x86);
						op(hstok.rm+(unsigned int)itok.number*8);
						outaddress(&hstok);
						break;
					case tk_longvar:
					case tk_dwordvar:
						razr=r32;
						possiblecpu=3;
						if(tok!=tk_reg32)reg32expected(2);
						goto nointx;
					case tk_intvar:
					case tk_wordvar:
						if(tok!=tk_reg)regexpected(2);
nointx:
		 				CheckAllMassiv(hbuf,razr,&hstr,&hstok);
						KillVar(hstok.name);
						IDZToReg(hstok.name,itok.number,razr);
						op66(razr);
						outseg(&hstok,2);
						op(0x87);
						op(hstok.rm+(unsigned int)itok.number*8);
						outaddress(&hstok);
						break;
					default: varexpected(1); break;
				}
				break;
			case a_xlat:
				ClearReg(AX);
				op(0xD7);	//XLAT
				break;
			case a_hlt:
	      op(0xF4);	//HLT
				break;
			case a_verr:
				protectinstr(0,0x20);	//VERR
				break;
			case a_verw:
				protectinstr(0,0x28);	//VERW
				break;
			case a_test:	//TEST
				if(iTest()==FALSE)invalidoperand(0);
				next=0;
				break;
			case a_fcom:	//FCOM
				FpuType1(0x10);
				break;
			case a_fcomp:	//FCOMP
				FpuType1(0x18);
				break;
			case a_fadd:	//FADD
				FpuType2(0,0);
				break;
			case a_fdiv:	//FDIV
				FpuType2(0x38,0x30);
				break;
			case a_fdivr:	//FDIVR
				FpuType2(0x30,0x38);
				break;
			case a_fmul:	//FMUL
				FpuType2(0x8,0x8);
				break;
			case a_fsub:	//FSUB
				FpuType2(0x28,0x20);
				break;
			case a_fsubr:	//FSUBR
				FpuType2(0x20,0x28);
				break;
			case a_faddp:	//FADDP
				FpuType3(0xDE,0);
				break;
			case a_fdivp:	//FDIVP
				FpuType3(0xDE,0x38);
				break;
			case a_fdivrp:	//FDIVRP
				FpuType3(0xDE,0x30);
				break;
			case a_ffree:	//FFREE
				FpuType3(0xDD,0);
				break;
			case a_fmulp:	//FMULP
				FpuType3(0xDE,8);
				break;
			case a_fsubp:	//FSUBP
				FpuType3(0xDE,0x28);
				break;
			case a_fsubrp:	//FSUBRP
				FpuType3(0xDE,0x20);
				break;
			case a_fucom:	//FUCOM
				FpuType3(0xDD,0x20);
				break;
			case a_fucomp:	//FUCOMP
				FpuType3(0xDD,0x28);
				break;
			case a_fxch:	//FXCH
				FpuType3(0xD9,8);
				break;

			case a_fiadd:	//FIADD
				FpuType4(0,0);
				break;
			case a_ficom:	//FICOM
				FpuType4(0,0x10);
				break;
			case a_ficomp:	//FICOMP
				FpuType4(0,0x18);
				break;
			case a_fidiv:	//FIDIV
				FpuType4(0,0x30);
				break;
			case a_fidivr:	//FIDIVR
				FpuType4(0,0x38);
				break;
			case a_fild:	//FILD
				FpuType4(1,0);
				break;
			case a_fimul:	//FIMUL
				FpuType4(0,8);
				break;
			case a_fist:	//FIST
				FpuType4(1,0x10);
				break;
			case a_fistp:	//FISTP
				FpuType4(1,0x18);
				break;
			case a_fisub:	//FISUB
				FpuType4(0,0x20);
				break;
			case a_fisubr:	//FISUBR
				FpuType4(0,0x28);
				break;

			case a_fld:	//FLD
				FpuType5(0xD9,0);
				break;
			case a_fst:	//FST
				FpuType5(0xDD,0x10);
				break;
			case a_fstp:	//FSTP
				FpuType5(0xDD,0x18);
				break;

			case a_fbld:	//FBLD
				FpuType6(0xDF,0X20);
				break;
			case a_fbstp:	//FBSTP
				FpuType6(0xDF,0X30);
				break;
			case a_fildq:	//FILDQ
				FpuType6(0xDF,0x28);
				break;
			case a_fldenv:	//FLDENV <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				FpuType6(0xD9,0x20);
				break;
			case a_frstor:	//FRSTOR <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				FpuType6(0xDD,0x20);
				break;
			case a_fsave:	//FSAVE <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				fwait();
			case a_fnsave:	//FNSAVE <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				FpuType6(0xDD,0x30);
				break;
			case a_fstenv:	//FSTENV <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				fwait();
			case a_fnstenv:	//FNSTENV <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				FpuType6(0xD9,0x30);
				break;

			case a_fldcw:	//FLDCW
				FpuType7(0x28);
				break;
			case a_fstcw:	//FSTCW
				fwait();
			case a_fnstcw:	//FNSTCW
				FpuType7(0x38);
				break;

			case a_f2xm1:
				outword(0xf0d9);	//F2XM1
				possiblecpu=2;
				break;
			case a_fabs:
				outword(0xE1D9);	//FABS
				break;
			case a_fchs:
				outword(0xE0D9);	//FCHS
				break;
			case a_fclex:	//FCLEX
				fwait();
//				outword(0xE2DB);
//				break;
			case a_fnclex:
				outword(0xE2DB);	//FNCLEX
				break;
			case a_fcompp:
				outword(0xD9DE);	//FCOMPP
				break;
			case a_fcos:	//FCOS
				outword(0xFFD9);
				possiblecpu=3;
				break;
			case a_fdecstr:
				outword(0xF6D9);	//FDECSTP
				break;
			case a_fdisi:
				fwait();
			case a_fndisi:
				outword(0xE1DB);	//FDISI
				break;
			case a_feni:
				fwait();
			case a_fneni:
				outword(0xE0DB);	//FENI
				break;
			case a_fincstr:
				outword(0xF7D9);	//FINCSTP
				break;
			case a_finit:     	//FINIT
				fwait();
			case a_fninit:
				outword(0xE3DB);	//FNINIT
				break;
			case a_fldlg2:
				outword(0xECD9);	//FLDLG2
				break;
			case a_fldln2:
				outword(0xEDD9);	//FLDLN2
				break;
			case a_fldl2e:
				outword(0xEAD9);	//FLDL2E
				break;
			case a_fldl2t:
				outword(0xE9D9);	//FLDL2T
				break;
			case a_fldpi:
				outword(0xEBD9);	//FLDPI
				break;
			case a_fldz:
				outword(0xEED9);	//FLDZ
				break;
			case a_fld1:
				outword(0xE8D9);	//FLD1
				break;
			case a_fnop:
				outword(0xD0D9);	//FNOP
				break;
			case a_fpatan:
				outword(0xF3D9);	//FPATAN
				break;
			case a_fprem:
				outword(0xF8D9);	//FPREM
				break;
			case a_fprem1:
				outword(0xF5D9);	//FPREM1
				possiblecpu=3;
				break;
			case a_fptan:
				outword(0xF2D9);	//FPTAN
				break;
			case a_frndint:
				outword(0xFCD9);	//FRNDINT
				break;
			case a_fsetpm:
				fwait();
			case a_fnsetpm:
				outword(0xE4DB);	//FSETPM
				possiblecpu=2;
				break;
			case a_fscale:
				outword(0XFDD9);	//FSCALE
				break;
			case a_fsin:	//FSIN
				outword(0xFED9);
				possiblecpu=3;
				break;
			case a_fsincos:	//FSINCOS
				outword(0xFBD9);
				possiblecpu=3;
				break;
			case a_fsqrt:
				outword(0xFAD9);	//FSQRT
				break;
			case a_fstsw:	//FSTSW
				fwait();
			case a_fnstsw:	//FNSTSW
				nexttok();
				switch(tok){
					case tk_wordvar:
					case tk_intvar:
						CheckAllMassiv(bufrm,2,&strinf);
						KillVar(itok.name);
						outseg(&itok,2);
						op(0xDD);
						op(itok.rm+0x38);
						outaddress(&itok);
						break;
					case tk_reg:
						if(itok.number==0)outword(0xe0df);
						else preerror("Use only AX");
						ClearReg(AX);
						break;
					default: wordvalexpected();
				}
				break;
			case a_ftst:
				outword(0xE4D9);	//FTST
				break;
			case a_fucompp:	//FUCOMPP
				outword(0xE9DA);
				possiblecpu=3;
				break;
			case a_fxam:
				outword(0xE5D9);	//FXAM
				break;
			case a_fxtract:
				outword(0xF4D9);	//FXTRACT
				break;
			case a_fyl2x:
				outword(0xF1D9);	//FYL2X
				break;
			case a_fyl2xp1:
				outword(0xF9D9);	//FYL2XP1
				break;
			case a_ud2:
				outword(0x0B0F);	//UD2
				possiblecpu=7;
				break;
			case a_sysenter:
				outword(0x340F);	//SYSENTER
				possiblecpu=7;
				break;
			case a_sysexit:
				outword(0x350F);	//SYSEXIT
				possiblecpu=7;
				break;
			case a_rdpmc:
				outword(0x330F);	//RDPMC
				possiblecpu=7;
				break;
			case a_fcmovnu:
				i+=8;
			case a_fcmovnbe:
				i+=8;
			case a_fcmovne:
				i+=8;
			case a_fcmovnb:
				FpuType8(0xDB,i);
				break;
			case a_fcmovu:
				i+=8;
			case a_fcmovbe:
				i+=8;
			case a_fcmove:
				i+=8;
			case a_fcmovb:
				FpuType8(0xDA,i);
				break;
			case a_fcomi:	//FCOMI
				i+=8;
			case a_fucomi:
				FpuType8(0xDB,i+0x28);
				break;
			case a_fcomip:
				i+=8;
			case a_fucomip:
				FpuType8(0xDF,i+0x28);
				break;
			case a_cmovo:
			case a_cmovno:
			case a_cmovc:
			case a_cmovnc:
			case a_cmovz:
			case a_cmovnz:
			case a_cmovna:
			case a_cmova:
			case a_cmovs:
			case a_cmovns:
			case a_cmovp:
			case a_cmovnp:
			case a_cmovl:
			case a_cmovnl:
			case a_cmovng:
			case a_cmovg:
				cmov(htok-a_cmovo);
				possiblecpu=7;
				break;
			case a_lfence:	//LFENCE
				outword(0xAE0F);
				op(0xE8);
				possiblecpu=9;
				break;
			case a_mfence:	//MFENCE
				outword(0xAE0F);
				op(0xF0);
				possiblecpu=9;
				break;
			case a_sfence:	//SFENCE
				outword(0xAE0F);
				op(0xF8);
				possiblecpu=8;
				break;
			case a_maskmovq:	//MASKMOVQ
				nexttok();
				hnumber=itok.number;
				if(tok!=tk_mmxreg)mmxregexpected(1);
				nextexpecting2(tk_camma);
				if(tok!=tk_mmxreg)mmxregexpected(2);
				outword(0xF70F);
				op(0xC0+hnumber+itok.number*8);
				possiblecpu=8;
				break;
			case a_movntq:	//MOVNTQ
				movxmm3(0xE7,0,tk_mmxreg);
				possiblecpu=8;
				break;
			case a_pavgb:
				mmxiii(0xE0);
				break;
			case a_pavgw:
				mmxiii(0xE3);
				break;
			case a_pmaxub:
				mmxiii(0xDE);
				break;
			case a_pmaxsw:
				mmxiii(0xEE);
				break;
			case a_pminub:
				mmxiii(0xDA);
				break;
			case a_pminsw:
				mmxiii(0xEA);
				break;
			case a_pmulhuw:
				mmxiii(0xE4);
				break;
			case a_psadbw:
				mmxiii(0xF6);
				break;
			case a_prefetcht0:
				prefetch(0x18,1);
				possiblecpu=8;
				break;
			case a_prefetcht1:
				prefetch(0x18,2);
				possiblecpu=8;
				break;
			case a_prefetcht2:
				prefetch(0x18,3);
				possiblecpu=8;
				break;
			case a_prefetchnta:
				prefetch(0x18,0);
				possiblecpu=8;
				break;
			case a_pextrw:
				pextrw();
				next=0;
				break;
			case a_pinsrw:
				pinsrw();
				next=0;
				break;
			case a_pmovmskb:
				nexttok();
				if(tok!=tk_reg32)reg32expected(1);
				htok=itok.number;
				ClearReg(htok);
				nextexpecting2(tk_camma);
				if(tok==tk_xmmreg){
					op(0x66);
					possiblecpu=9;
				}
				else{
					possiblecpu=8;
					if(tok!=tk_mmxreg)mmxregexpected(2);
				}
				outword(0xD70F);
				op(rm_mod11+htok*8+itok.number);
				break;
			case a_pshufw:
				pshufw();
				next=0;
				possiblecpu=8;
				break;
			case a_pshufd:
				xmm3instr(0x70,0x66);
				possiblecpu=9;
				next=0;
				break;
			case a_pshufhw:
				xmm3instr(0x70,0xf3);
				possiblecpu=9;
				next=0;
				break;
			case a_pshuflw:
				xmm3instr(0x70,0xf2);
				possiblecpu=9;
				next=0;
				break;
			case a_addpd:
				xmminstr(0x58,0x66);
				possiblecpu=9;
				break;
			case a_addps:
				xmminstr(0x58,0);
				possiblecpu=8;
				break;
			case a_addsd:
				xmminstr(0x58,0xF2);
				possiblecpu=9;
				break;
			case a_addss:
				xmminstr(0x58,0xF3);
				possiblecpu=8;
				break;
			case a_addsubpd:
				xmminstr(0xD0,0x66);
				possiblecpu=9;
				break;
			case a_addsubps:
				xmminstr(0xD0,0xF2);
				possiblecpu=9;
				break;
			case a_andnpd:
				xmminstr(0x55,0x66);
				possiblecpu=9;
				break;
			case a_andnps:
				xmminstr(0x55,0);
				possiblecpu=8;
				break;
			case a_andpd:
				xmminstr(0x54,0x66);
				possiblecpu=9;
				break;
			case a_andps:
				xmminstr(0x54,0);
				possiblecpu=8;
				break;
			case a_comisd:
				xmminstr(0x2F,0x66);
				possiblecpu=9;
				break;
			case a_comiss:
				xmminstr(0x2F,0);
				possiblecpu=8;
				break;
			case a_divps:
				xmminstr(0x5E,0);
				possiblecpu=8;
				break;
			case a_divsd:
				xmminstr(0x5E,0xf2);
				possiblecpu=9;
				break;
			case a_divss:
				xmminstr(0x5E,0xF3);
				possiblecpu=8;
				break;
			case a_haddpd:
				xmminstr(0x7C,0x66);
				possiblecpu=9;
				break;
			case a_haddps:
				xmminstr(0x7C,0xF2);
				possiblecpu=9;
				break;
			case a_hsubpd:
				xmminstr(0x7D,0x66);
				possiblecpu=9;
				break;
			case a_hsubps:
				xmminstr(0x7D,0xF2);
				possiblecpu=9;
				break;
			case a_maskmovdqu:
				xmm2xmm(0xf7,0x66);
				possiblecpu=9;
				break;
			case a_maxpd:
				xmminstr(0x5f,0x66);
				possiblecpu=9;
				break;
			case a_maxps:
				xmminstr(0x5F,0);
				possiblecpu=8;
				break;
			case a_maxsd:
				xmminstr(0x5f,0xf2);
				possiblecpu=9;
				break;
			case a_maxss:
				xmminstr(0x5F,0xF3);
				possiblecpu=8;
				break;
			case a_minpd:
				xmminstr(0x5d,0x66);
				possiblecpu=9;
				break;
			case a_minps:
				xmminstr(0x5D,0);
				possiblecpu=8;
				break;
			case a_minsd:
				xmminstr(0x5d,0xf2);
				possiblecpu=9;
				break;
			case a_minss:
				xmminstr(0x5D,0xF3);
				possiblecpu=8;
				break;
			case a_mulpd:
				xmminstr(0x59,0x66);
				possiblecpu=9;
				break;
			case a_mulps:
				xmminstr(0x59,0);
				possiblecpu=8;
				break;
			case a_mulsd:
				xmminstr(0x59,0xF2);
				possiblecpu=9;
				break;
			case a_mulss:
				xmminstr(0x59,0xF3);
				possiblecpu=8;
				break;
			case a_orpd:
				xmminstr(0x56,0x66);
				possiblecpu=9;
				break;
			case a_orps:
				xmminstr(0x56,0);
				possiblecpu=8;
				break;
			case a_rcpps:
				xmminstr(0x53,0);
				possiblecpu=8;
				break;
			case a_rcpss:
				xmminstr(0x53,0xF3);
				possiblecpu=8;
				break;
			case a_rsqrtps:
				xmminstr(0x52,0);
				possiblecpu=8;
				break;
			case a_rsqrtss:
				xmminstr(0x52,0xF3);
				possiblecpu=8;
				break;
			case a_sqrtpd:
				xmminstr(0x51,0x66);
				possiblecpu=9;
				break;
			case a_sqrtps:
				xmminstr(0x51,0);
				possiblecpu=8;
				break;
			case a_sqrtsd:
				xmminstr(0x51,0xf2);
				possiblecpu=9;
				break;
			case a_sqrtss:
				xmminstr(0x51,0xF3);
				possiblecpu=8;
				break;
			case a_subpd:
				xmminstr(0x5C,0x66);
				possiblecpu=9;
				break;
			case a_subps:
				xmminstr(0x5C,0);
				possiblecpu=8;
				break;
			case a_subsd:
				xmminstr(0x5C,0xF2);
				possiblecpu=9;
				break;
			case a_subss:
				xmminstr(0x5C,0xF3);
				possiblecpu=8;
				break;
			case a_ucomisd:
				xmminstr(0x2E,0x66);
				possiblecpu=9;
				break;
			case a_ucomiss:
				xmminstr(0x2E,0);
				possiblecpu=8;
				break;
			case a_unpckhpd:
				xmminstr(0x15,0x66);
				possiblecpu=9;
				break;
			case a_unpckhps:
				xmminstr(0x15,0);
				possiblecpu=8;
				break;
			case a_unpcklpd:
				xmminstr(0x14,0x66);
				possiblecpu=9;
				break;
			case a_unpcklps:
				xmminstr(0x14,0);
				possiblecpu=8;
				break;
			case a_xorpd:
				xmminstr(0x57,0x66);
				possiblecpu=9;
				break;
			case a_xorps:
				xmminstr(0x57,0);
				possiblecpu=8;
				break;
			case a_cmppd:
				xmm3instr(0xC2,0x66);
				possiblecpu=9;
				next=0;
				break;
			case a_cmpeqpd:
			case a_cmpltpd:
			case a_cmplepd:
			case a_cmpunordpd:
			case a_cmpneqpd:
			case a_cmpnltpd:
			case a_cmpnlepd:
			case a_cmpordpd:
				xmminstr(0xC2,0x66);
				possiblecpu=9;
				op(htok-a_cmpeqpd);
				break;
			case a_cmpps:
				xmm3instr(0xC2,0);
				possiblecpu=8;
				next=0;
				break;
			case a_cmpeqps:
			case a_cmpltps:
			case a_cmpleps:
			case a_cmpunordps:
			case a_cmpneqps:
			case a_cmpnltps:
			case a_cmpnleps:
			case a_cmpordps:
				xmminstr(0xC2,0);
				possiblecpu=9;
				op(htok-a_cmpeqps);
				break;
			case a_cmpss:
				xmm3instr(0xC2,0xF3);
				possiblecpu=8;
				next=0;
				break;
			case a_cmpeqss:
			case a_cmpltss:
			case a_cmpless:
			case a_cmpunordss:
			case a_cmpneqss:
			case a_cmpnltss:
			case a_cmpnless:
			case a_cmpordss:
				xmminstr(0xC2,0xF3);
				possiblecpu=9;
				op(htok-a_cmpeqss);
				break;
			case a_cmpeqsd:
			case a_cmpltsd:
			case a_cmplesd:
			case a_cmpunordsd:
			case a_cmpneqsd:
			case a_cmpnltsd:
			case a_cmpnlesd:
			case a_cmpordsd:
				xmminstr(0xC2,0xF2);
				op(htok-a_cmpeqsd);
				possiblecpu=9;
				break;
			case a_shufpd:
				xmm3instr(0xC6,0x66);
				possiblecpu=9;
				next=0;
				break;
			case a_shufps:
				xmm3instr(0xC6,0);
				possiblecpu=8;
				next=0;
				break;
			case a_cvtdq2pd:
				xmminstr(0xE6,0xF3);
				possiblecpu=9;
				break;
			case a_cvtdq2ps:
				xmminstr(0x5B,0);
				possiblecpu=9;
				break;
			case a_cvtpd2dq:
				xmminstr(0xE6,0xF2);
				possiblecpu=9;
				break;
			case a_cvtpd2pi:
				xmminstr(0x2d,0x66,tk_mmxreg,tk_xmmreg);
				possiblecpu=9;
				break;
			case a_cvtpd2ps:
				xmminstr(0x5a,0x66);
				possiblecpu=9;
				break;
			case a_cvtpi2pd:
				xmminstr(0x2a,0x66,tk_xmmreg,tk_mmxreg);
				possiblecpu=9;
				break;
			case a_cvtpi2ps:
				xmminstr(0x2a,0,tk_xmmreg,tk_mmxreg);
				possiblecpu=8;
				break;
			case a_cvtps2dq:
				xmminstr(0x5b,0x66);
				possiblecpu=9;
				break;
			case a_cvtps2pd:
				xmminstr(0x5a,0);
				possiblecpu=9;
				break;
			case a_cvtsi2ss:
				xmminstr(0x2a,0xf3,tk_xmmreg,tk_reg32);
				possiblecpu=8;
				break;
			case a_cvtps2pi:
				xmminstr(0x2d,0,tk_mmxreg,tk_xmmreg);
				possiblecpu=9;
				break;
			case a_cvtsd2si:
				xmminstr(0x2d,0xf2,tk_reg32,tk_xmmreg);
				possiblecpu=9;
				break;
			case a_cvtsd2ss:
				xmminstr(0x5a,0xf2);
				possiblecpu=9;
				break;
			case a_cvtsi2sd:
				xmminstr(0x2a,0xf2,tk_xmmreg,tk_reg32);
				possiblecpu=9;
				break;
			case a_cvtss2sd:
				xmminstr(0x5a,0xf3);
				possiblecpu=9;
				break;
			case a_cvtss2si:
				xmminstr(0x2d,0xf3,tk_reg32,tk_xmmreg);
				possiblecpu=8;
				break;
			case a_cvttpd2pi:
				xmminstr(0x2c,0x66,tk_mmxreg,tk_xmmreg);
				possiblecpu=9;
				break;
			case a_cvttpd2dq:
				xmminstr(0xE6,0x66);
				possiblecpu=9;
				break;
			case a_cvttps2dq:
				xmminstr(0x5B,0xF3);
				possiblecpu=9;
				break;
			case a_cvttps2pi:
				xmminstr(0x2c,0,tk_mmxreg,tk_xmmreg);
				possiblecpu=8;
				break;
			case a_cvttsd2si:
				xmminstr(0x2C,0xF2,tk_reg32,tk_xmmreg);
				possiblecpu=9;
				break;
			case a_cvttss2si:
				xmminstr(0x2C,0xF3,tk_reg32,tk_xmmreg);
				possiblecpu=8;
				break;
			case a_divpd:
				xmminstr(0x5E,0x66);
				possiblecpu=9;
				break;
			case a_punpckhqdq:
				xmminstr(0x6D,0x66);
				possiblecpu=9;
				break;
			case a_punpcklqdq:
				xmminstr(0x6C,0x66);
				possiblecpu=9;
				break;
			case a_fxrstor:
				prefetch(0xAE,1);
				possiblecpu=8;
				break;
			case a_fxsave:
				prefetch(0xAE,0);
				possiblecpu=8;
				break;
			case a_ldmxcsr:
				prefetch(0xAE,2);
				possiblecpu=8;
				break;
			case a_stmxcsr:
				prefetch(0xAE,3);
				possiblecpu=8;
				break;
			case a_clflush:
				prefetch(0xAE,7);
				possiblecpu=9;
				break;
			case a_monitor:
				outword(0x010F);
				op(0xc8);
				possiblecpu=9;
				break;
			case a_mwait:
				outword(0x010F);
				op(0xc9);
				possiblecpu=9;
				break;
			case a_lddqu:
				movxmm4(0xF0,0xF2);
				possiblecpu=9;
				break;
			case a_movhlps:
				xmm2xmm(0x12);
				possiblecpu=8;
				break;
			case a_movlhps:
				xmm2xmm(0x16);
				possiblecpu=8;
				break;
			case a_movmskps:
				xmm2xmm(0x50,0,tk_reg32);
				possiblecpu=8;
				break;
			case a_movntdq:
				movxmm3(0xE7,0x66);
				possiblecpu=9;
				break;
			case a_movntpd:
				movxmm3(0x2B,0x66);
				possiblecpu=9;
				break;
			case a_movntps:
				movxmm3(0x2b,0);
				possiblecpu=8;
				break;
			case a_movapd:
				movxmm(0x28,0x66);
				possiblecpu=9;
				break;
			case a_movaps:
				movxmm(0x28,0);
				possiblecpu=8;
				break;
			case a_movdqa:
				movxmm(0x6f,0x66,0x10);
				possiblecpu=9;
				break;
			case a_movddup:
				xmminstr(0x12,0xF2);
				possiblecpu=9;
				break;
			case a_movshdup:
				xmminstr(0x16,0xF3);
				possiblecpu=9;
				break;
			case a_movsldup:
				xmminstr(0x12,0xF3);
				possiblecpu=9;
				break;
			case a_movdqu:
				movxmm(0x6f,0xf3,0x10);
				possiblecpu=9;
				break;
			case a_movdq2q:
				xmm2xmm(0xd6,0xf2,tk_mmxreg);
				possiblecpu=9;
				break;
			case a_movhpd:
				movxmm2(0x16,0x66);
				possiblecpu=9;
				break;
			case a_movlpd:
				movxmm2(0x12,0x66);
				possiblecpu=9;
				break;
			case a_movmskpd:
				xmm2xmm(0x50,0x66,tk_reg32);
				possiblecpu=9;
				break;
			case a_movnti:	//MOVNTI
				movxmm3(0xC3,0,tk_reg32);
				possiblecpu=9;
				break;
			case a_movq2dq:	//MOVQ2DQ
				nexttok();
				hnumber=itok.number;
				if(tok!=tk_xmmreg)xmmregexpected(1);
				nextexpecting2(tk_camma);
				if(tok!=tk_mmxreg)mmxregexpected(2);
				op(0xF3);
				outword(0xD60F);
				op(0xC0+hnumber+itok.number*8);
				possiblecpu=9;
				break;
			case a_movupd:
				movxmm(0x10,0x66);
				possiblecpu=9;
				break;
			case a_movups:
				movxmm(0x10,0);
				possiblecpu=8;
				break;
			case a_movss:
				movxmm(0x10,0xF3);
				possiblecpu=8;
				break;
			case a_movhps:
				movxmm2(0x16);
				possiblecpu=8;
				break;
			case a_movlps:
				movxmm2(0x12);
				possiblecpu=8;
				break;

			case -1: codeexpected(); break;
			default:
				preerror("sorry, this instruction is not supported");
				break;
		}
		asmparam=FALSE;
		if(cpu<possiblecpu)cpu=possiblecpu;
		if(next)nexttok();
	}
	else if(tok==tk_seg){
		switch((unsigned int)itok.number){
			case ES: op(0x26); break;
			case SS: op(0x36); break;
			case CS: op(0x2E); break;
			case DS: op(0x3E); break;
			case FS: op(0x64);
				if(cpu<3)cpu=3;
				break;
			case GS: op(0x65);
				if(cpu<3)cpu=3;
				break;
			default: beep(); break;
		}
		nextexpecting2(tk_colon);
	}
	else if(tok==tk_locallabel)define_locallabel();
	else if(tok==tk_at&&ScanTok3()==tk_colon){
		nexttok();
		LLabel();
	}
	else codeexpected();
	if(tok==tk_semicolon)nexttok();
}

void cmov(int num)
{
int type=r32;
int reg;
	nexttok();
	if(tok==tk_reg)type=r16;
	else if(tok!=tk_reg32)reg32regexpected(1);
	reg=itok.number;
	ClearReg(reg);
	nextexpecting2(tk_camma);
	op66(type);
	switch(tok){
		case tk_reg:
			if(type==r32)reg32expected(2);
			goto regs;
		case tk_reg32:
			if(type==r16)regexpected(2);
regs:
			op(0x0F);
			op(0x40+num);
			op(0xC0+reg*8+itok.number);
			break;
		case tk_wordvar:
		case tk_intvar:
			if(type==r32)dwordvalexpected();
			CheckAllMassiv(bufrm,2,&strinf);
			goto dwords;
		case tk_dwordvar:
		case tk_longvar:
			if(type==r16)wordvalexpected();
			CheckAllMassiv(bufrm,4,&strinf);
dwords:
			outseg(&itok,3);
			op(0x0F);
			op(0x40+num);
			op(itok.rm+reg*8);
			outaddress(&itok);
			break;
		default:
			varexpected(2);
			break;
	}
}

#ifdef OPTVARCONST
int GetOperand(int code)
{
	switch(code){
		case a_inc:	//INC
		case a_add: return tk_plus;
		case a_or: return tk_or;
		case a_and:	return tk_and;
		case a_dec:	//DEC
		case a_sub:	return tk_minus;
		case a_xor:	return tk_xor;
		case a_not:	return tk_not;
		case a_neg:	return tk_numsign;
		case a_shl:	return tk_ll;
		case a_shr:	return tk_rr;
	}
	return tokens;
}
#endif

void  asmtwo1(int basecode) // used for ADD ADC SUB SBB CMP AND OR XOR.
{
unsigned long holdnumber2;
int htok,typet=r16;
long longholdnumber;
char *hbuf;
ITOK hstok;
unsigned char next=1;
SINFO hstr;
#ifdef OPTVARCONST
int initconst=FALSE;
int operand=GetOperand(basecode/8);
#endif
	nexttok();
	hstok=itok;
	htok=tok;
	hbuf=bufrm;
	bufrm=NULL;
	hstr=strinf;
	strinf.bufstr=NULL;
	nextexpecting2(tk_camma);
int i=tok;
	switch(htok){
		case tk_reg:
			if((basecode/8)!=a_cmp)ClearReg(hstok.number);
		  switch(tok){
				case tk_undefofs:
					strcpy(hstok.name,itok.name);
					tok=tk_number;
					goto wnum;
				case tk_minus:
					if(tok2!=tk_number){
						wordvalexpected();
						break;
					}
				case tk_number:
wnum:
					asmparam=FALSE;
					holdnumber2=doconstlongmath();
					next=0;
					op66(r16);
					if(hstok.number==AX){
						op(4+1+basecode);
						if((postnumflag&f_reloc)!=0)AddReloc();
						if(i==tk_undefofs)AddUndefOff(2,hstok.name);
						outword(holdnumber2);
					}
					else{
						if((postnumflag&f_reloc)==0&&short_ok(holdnumber2)){
							op(128+2+1);
							op(128+64+hstok.number+basecode);
							op(holdnumber2);
						}
						else{
							op(128+1);
							op(128+64+hstok.number+basecode);
							if((postnumflag&f_reloc)!=0)AddReloc();
							if(i==tk_undefofs)AddUndefOff(2,hstok.name);
							outword(holdnumber2);
						}
					}
					break;
				case tk_postnumber:
					op66(r16);
					if(hstok.number==AX)op(4+1+basecode);
					else{
						op(128+1);
						op(128+64+hstok.number+basecode);
					}
					(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
					outword((unsigned int)itok.number);
					break;
				case tk_reg:
					op66(r16);
					op(2+1+basecode);
					op(128+64+(unsigned int)itok.number+hstok.number*8);
					break;
				case tk_wordvar:
				case tk_intvar:
					CheckAllMassiv(bufrm,2,&strinf);
					op66(r16);
					outseg(&itok,2);
					op(2+1+basecode);
					op(itok.rm+hstok.number*8);
					outaddress(&itok);
					break;
				default: wordvalexpected(); break;
			}
			break;
		case tk_reg32:
			if((basecode/8)!=a_cmp)ClearReg(hstok.number);
			switch(tok){
				case tk_undefofs:
					strcpy(hstok.name,itok.name);
					tok=tk_number;
					goto dnum;
				case tk_minus:
					i=tk_number;
					if(tok2!=tk_number){
						dwordvalexpected();
						break;
					}
				case tk_number:
dnum:
					op66(r32);
					asmparam=FALSE;
					longholdnumber=doconstdwordmath();
					next=0;
					if(i==tk_number&&(postnumflag&f_reloc)==0&&short_ok(longholdnumber,TRUE)){
						op(128+2+1);
						op(128+64+hstok.number+basecode);
						op((int)longholdnumber);
					}
					else{
						if(hstok.number==EAX)op(4+1+basecode);
						else{
							op(128+1);
							op(128+64+hstok.number+basecode);
						}
						if((postnumflag&f_reloc)!=0)AddReloc();
						if(i==tk_undefofs)AddUndefOff(2,hstok.name);
						outdword(longholdnumber);
					}
					break;
				case tk_postnumber:
					op66(r32);
					if(hstok.number==EAX)op(4+1+basecode);
					else{
						op(128+1);
						op(128+64+hstok.number+basecode);
					}
					(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
					outdword(itok.number);
					break;
				case tk_reg32:
					op66(r32);
					op(2+1+basecode);
					op(128+64+(unsigned int)itok.number+hstok.number*8);
					break;
				case tk_dwordvar:
				case tk_longvar:
					CheckAllMassiv(bufrm,4,&strinf);
					op66(r32);
					outseg(&itok,2);
					op(2+1+basecode);
					op(itok.rm+hstok.number*8);
					outaddress(&itok);
					break;
				default: dwordvalexpected(); break;
			}
			if(cpu<3)cpu=3;
			break;
		case tk_beg:
			if((basecode/8)!=a_cmp)ClearReg(hstok.number>3?hstok.number-4:hstok.number);
			switch(tok){
				case tk_minus:
					if(tok2!=tk_number){
						bytevalexpected(2);
						break;
					}
				case tk_number:
					asmparam=FALSE;
					holdnumber2=doconstlongmath();
					next=0;
					if(hstok.number==AL)op(4+basecode);
					else{
						op(128);
						op(128+64+hstok.number+basecode);
					}
					op(holdnumber2);
					break;
				case tk_beg:
					op(2+basecode);
					op(128+64+(unsigned int)itok.number+hstok.number*8);
					break;
				case tk_bytevar:
				case tk_charvar:
					CheckAllMassiv(bufrm,1,&strinf);
					outseg(&itok,2);
					op(2+basecode);
					op(itok.rm+hstok.number*8);
					outaddress(&itok);
					break;
				default: bytevalexpected(2); break;
			}
			break;
		case tk_dwordvar:
		case tk_longvar:
			typet=r32;
			if(cpu<3)cpu=3;
		case tk_intvar:
		case tk_wordvar:
			if((basecode/8)!=a_cmp)KillVar(hstok.name);
			CheckAllMassiv(hbuf,typet,&hstr,&hstok);
			op66(typet);
			outseg(&hstok,2);
			switch(tok){
				case tk_undefofs:
					strcpy(hstok.name,itok.name);
					tok=tk_number;
					goto vnum;
				case tk_minus:
					if(tok2!=tk_number)goto erval;
				case tk_number:
vnum:
					asmparam=FALSE;
					holdnumber2=doconstlongmath();
#ifdef OPTVARCONST
					if(i==tk_number&&(postnumflag&f_reloc)==0){
						initconst=UpdVarConst(&hstok,holdnumber2,tk_dword,operand);
					}
#endif
					next=0;
					if(i!=tk_undefofs&&(postnumflag&f_reloc)==0&&short_ok(holdnumber2,typet/2-1)){
						op(128+2+1);
						op(hstok.rm+basecode);
						outaddress(&hstok);
						op(holdnumber2);
					}
					else{
						op(128+1);
						op(hstok.rm+basecode);
						outaddress(&hstok);
						if((postnumflag&f_reloc)!=0)AddReloc();
						if(i==tk_undefofs)AddUndefOff(2,hstok.name);
						if(typet==r16)outword(holdnumber2);
						else outdword(holdnumber2);
					}
					break;
				case tk_postnumber:
					if(typet==r32)goto erval;
					op(128+1);
					op(hstok.rm+basecode);
					outaddress(&hstok);
					(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
					if(typet==r16)outword(itok.number);
					else outdword(itok.number);
					break;
				case tk_reg32:
					if(typet==r16)goto erval;
				case tk_reg:
					op(1+basecode);
					op(hstok.rm+(unsigned int)itok.number*8);
					outaddress(&hstok);
					break;
				default:
erval:
					if(typet==r16)wordvalexpected();
					else dwordvalexpected();
					break;
			}
#ifdef OPTVARCONST
			if(initconst==FALSE)ClearVarByNum(&hstok);
#endif

			break;
		case tk_bytevar:
		case tk_charvar:
			if((basecode/8)!=a_cmp)KillVar(hstok.name);
			CheckAllMassiv(hbuf,1,&hstr,&hstok);
			switch(tok){
				case tk_minus:
					if(tok2!=tk_number){
						bytevalexpected(2);
						break;
					}
				case tk_number:
					asmparam=FALSE;
					holdnumber2=doconstlongmath();
#ifdef OPTVARCONST
					if((postnumflag&f_reloc)==0){
						initconst=UpdVarConst(&hstok,holdnumber2,tk_byte,operand);
					}
#endif
					next=0;
					outseg(&hstok,2);
					op(128);
					op(hstok.rm+basecode);
					outaddress(&hstok);
					op(holdnumber2);
					break;
				case tk_beg:
					outseg(&hstok,2);
					op(basecode);
					op(hstok.rm+(unsigned int)itok.number*8);
					outaddress(&hstok);
					break;
				default: bytevalexpected(2); break;
			}
#ifdef OPTVARCONST
			if(initconst==FALSE)ClearVarByNum(&hstok);
#endif
			break;
		default: varexpected(1);	break;
	}
	if(next)nexttok();
}

int GOTO()
{
unsigned char next=1;
	CheckIP();
#ifdef OPTVARCONST
	ClearLVIC();
#endif
	clearregstat();
	switch(tok){
		case tk_proc:
		case tk_interruptproc:
			if(itok.segm!=NOT_DYNAMIC){
				idrec *ptr=itok.rec;
				itok.segm=ptr->recsegm=DYNAMIC_USED;
				itok.rm=tok=tk_undefofs;	//ᬥ饭<E1ACA5><E9A5AD> <20><><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>⭮<EFBFBD> <20><>⪨
				goto undefproc;
			}
			jumploc(itok.number);	//<2F><> <20><><EFBFBD>楤<EFBFBD><E6A5A4><EFBFBD> <20><><EFBFBD> ࠭<><E0A0AD><EFBFBD>
			break;
		case tk_number:
			asmparam=FALSE;
			jumploc(doconstlongmath());//<2F><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
			next=0;
			break;
		case tk_ID:
			addlocaljump(CALL_SHORT); //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
			outword(0x00EB); 	// JMP SHORT
			break;
		case tk_id:
			tobedefined(CALL_SHORT,tk_void);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFA2AB><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
			outword(0x00EB);	// JMP SHORT
			break;
		case tk_declare:
			tok=tk_undefproc;
			updatetree();
		case tk_locallabel:
		case tk_undefproc:		//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFA2AB><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
undefproc:
			addacall((unsigned int)itok.number,(unsigned char)((itok.flag&f_extern)!=0?CALL_EXT:CALL_SHORT));
			outword(0x00EB);	// JMP SHORT
			break;
		default: shortjumperror(); break;
	}
	return next;
}

unsigned char gotol(int faradd)
{
unsigned char next=1;
unsigned long hnumber;
unsigned int i=0;
	CheckIP();
#ifdef OPTVARCONST
	ClearLVIC();
#endif
	clearregstat();
	switch(tok){
		case tk_declare:
			if(tok2!=tk_openbracket){
				tok=tk_undefproc;
				updatetree();
			}
		case tk_locallabel:
		case tk_undefproc:
			if(tok2==tk_openbracket){
				asmparam=FALSE;
				if(doanyundefproc(TRUE)==tokens)next=0;
				break;
			}
			if(faradd==0){
				addacall((unsigned int)itok.number,(unsigned char)((itok.flag&f_extern)!=0?CALL_EXT:(am32==FALSE?JMP_NEAR:JMP_32)));
				jumploc0();
			} 			/* JMP num */
			else invalidfarjumpitem();
			break;
		case tk_proc:
			if(tok2==tk_openbracket){
				doanyproc(TRUE);
				break;
			}
			if(itok.segm!=NOT_DYNAMIC){
				idrec *ptr=itok.rec;
				itok.segm=ptr->recsegm=DYNAMIC_USED;
				itok.rm=tok=tk_undefofs;	//ᬥ饭<E1ACA5><E9A5AD> <20><><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>⭮<EFBFBD> <20><>⪨
		 		if(faradd==0){
					addacall((unsigned int)itok.number,(unsigned char)((itok.flag&f_extern)!=0?CALL_EXT:(am32==FALSE?JMP_NEAR:JMP_32)));
					jumploc0();
					break;
				} 			/* JMP num */
			}
		case tk_interruptproc:
			if(faradd==0)jumploc(itok.number);
			else invalidfarjumpitem();
			break;
		case tk_apiproc:
			asmparam=FALSE;
			if(tok2==tk_openbracket){
				if(doanyundefproc(TRUE)==tokens)next=0;
			}
			else{
				if(FastCallApi==TRUE){
					outword(0x25ff);
					AddApiToPost(itok.number);
				}
				else{
					addacall(itok.number,(unsigned char)CALL_32);
					jumploc0();
				}
			}
			break;
		case tk_minus:
			if(tok2!=tk_number)goto err;
		case tk_number:
			asmparam=FALSE;
			hnumber=doconstdwordmath();
			if(faradd==0)jumploc(hnumber);
			else{
				op(0xEA);
				expecting2(tk_colon);
				int htok=tok;
				char name[IDLENGTH];
				if(tok==tk_undefofs){
					tok=tk_number;
					strcpy(name,itok.name);
				}
				unsigned long tempi=doconstdwordmath();
				if(postnumflag&f_reloc)AddReloc();
				if(htok==tk_undefofs)AddUndefOff(2,name);
				if(am32==FALSE)outword((unsigned int)tempi);
				else outdword(tempi);
				outword((unsigned int)hnumber);
			}
			next=0;
			break;	 /* JMP num */
		case tk_postnumber:
			if(faradd==0){
				op(0xE9);
				(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
				if(am32==FALSE)outword((unsigned int)itok.number);
				else outdword(itok.number);
			}
			else invalidfarjumpitem();
			break;
		case tk_reg32:
			op66(r32);
			goto jmpreg;
		case tk_reg:
			op66(r16);
jmpreg:
			if(faradd==0){
				op(0xFF);
				op(0xE0+(unsigned int)itok.number);
			} 	 /* JMP reg */
			else invalidfarjumpitem();
			break;
		case tk_ID:
			if(faradd==0){
				addlocaljump(am32==FALSE?JMP_NEAR:JMP_32);
				jumploc0();
			} 		 /* JMP num */
			else invalidfarjumpitem();
			break;
		case tk_id:
			if(faradd==0){
				tobedefined(am32==FALSE?JMP_NEAR:JMP_32,tk_void);
				jumploc0();
			} 		 /* JMP num */
			else invalidfarjumpitem();
			break;
		case tk_dwordvar:
		case tk_longvar:
			i=2;
		case tk_intvar:
		case tk_wordvar:
			i+=2;
			CheckAllMassiv(bufrm,i,&strinf);
			outseg(&itok,2);
			op(0xFF);  op(0x20+itok.rm+(faradd==0?(i==4&&am32==0?8:0):8));
			outaddress(&itok);
			break;
		default:
err:
			preerror("Invalid item for JMP");
			break;
	}
	return next;
}

void  asmregmem(int out1,int out2) // used for LEA LDS LES LFS LGS LSS.
{
int holdreg;
	nexttok();
	op66(tok==tk_reg?r16:r32);
	if(tok!=tk_reg32&&tok!=tk_reg)reg32regexpected(1);
	holdreg=(unsigned int)itok.number;
	ClearReg(itok.number);
	nextexpecting2(tk_camma);
	switch(tok){
		case tk_intvar:
		case tk_wordvar:
		case tk_charvar:
		case tk_bytevar:
		case tk_longvar:
		case tk_dwordvar:
			break;
		default: varexpected(2);
	}
	CheckAllMassiv(bufrm,2,&strinf);
	if(out2==0)outseg(&itok,2);
	else outseg(&itok,3);
	op(out1);
	if(out2!=0)op(out2);
	op(itok.rm+holdreg*8);
	outaddress(&itok);
}

void Scanbit(int basecode)
{
unsigned long hnumber;
int htok,typet=r16;
	nexttok();
	hnumber=itok.number;
	ClearReg(itok.number);
	htok=tok;
	nextexpecting2(tk_camma);
	switch(htok){
		case tk_reg32:
			typet=r32;
			if(tok==tk_reg||tok==tk_wordvar||tok==tk_intvar)goto erval;
		case tk_reg:
		  switch(tok){
				case tk_reg32:
					if(typet==r16)goto erval;
				case tk_reg:
					op66(typet);
					op(0xf);
					op(basecode);
					op(0xc0+(unsigned int)itok.number+hnumber*8);
					break;
				case tk_dwordvar:
				case tk_longvar:
					if(typet==r16)goto erval;
				case tk_wordvar:
				case tk_intvar:
					CheckAllMassiv(bufrm,typet,&strinf);
					op66(typet);
					outseg(&itok,3);
					op(0xf);
					op(basecode);
					op(itok.rm+hnumber*8);
					outaddress(&itok);
					break;
				default:
erval:
					if(typet==r16)wordvalexpected();
					else dwordvalexpected();
					break;
			}
			break;
		default: reg32regexpected(1);
	}
	if(cpu<3)cpu=3;
}

void CheckBit(int code)
{
unsigned long holdnumber2;
int htok;
ITOK hstok;
unsigned char next=1;
char *hbuf;
SINFO hstr;
	nexttok();
	hstok=itok;
	htok=tok;
	hbuf=bufrm;
	bufrm=NULL;
	hstr=strinf;
	strinf.bufstr=NULL;
	nextexpecting2(tk_camma);
	switch(htok){
		case tk_reg32:
		case tk_reg:
			op66(htok==tk_reg?r16:r32);
			if(code)ClearReg(hstok.number);
		  switch(tok){
				case tk_number:
					asmparam=FALSE;
					holdnumber2=doconstlongmath();
					next=0;
					outword(0xba0f);
					op(0xe0+code+hstok.number);
					op(holdnumber2);
					break;
				case tk_reg32:
					if(tok!=htok){
						dwordvalexpected();
						break;
					}
				case tk_reg:
					if(tok!=htok)wordvalexpected();
					op(0xf);
					op(0xa3+code);
					op(0xc0+hstok.number+(unsigned int)itok.number*8);
					break;
				default: wordvalexpected(); break;
			}
			break;
		case tk_intvar:
		case tk_wordvar:
			CheckAllMassiv(hbuf,2,&hstr,&hstok);
			if(code)KillVar(hstok.name);
			op66(r16);
			switch(tok){
				case tk_number:
varc:
					asmparam=FALSE;
					holdnumber2=doconstlongmath();
					next=0;
					outseg(&hstok,3);
					outword(0xba0f);
					op(hstok.rm+code+0x20);
					outaddress(&hstok);
					op(holdnumber2);
					break;
				case tk_reg:
varreg:
					outseg(&hstok,3);
					op(0xf);
					op(0xa3+code);
					op(hstok.rm+(unsigned int)itok.number*8);
					outaddress(&hstok);
					break;
				default: wordvalexpected(); break;
			}
#ifdef OPTVARCONST
			if(code)ClearVarByNum(&hstok);
#endif
			break;
		case tk_dwordvar:
		case tk_longvar:
			CheckAllMassiv(hbuf,4,&hstr,&hstok);
			if(code)KillVar(hstok.name);
			op66(r32);
			if(tok==tk_number)goto varc;
			if(tok==tk_reg32)goto varreg;
			dwordvalexpected();
			break;
		default: varexpected(1);
	}
	if(cpu<3)cpu=3;
	if(next)nexttok();
}

void asmone1(int basecode)			 // used for INC and DEC.
{
int razr=r16;
#ifdef OPTVARCONST
int operand=GetOperand(basecode/8+a_inc);
#endif
	nexttok();
	switch(tok){
		case tk_reg32:
			if(cpu<3)cpu=3;
			razr=r32;
		case tk_reg:
			ClearReg(itok.number);
			op66(razr);
		  op(64+basecode+(unsigned int)itok.number);
			break;
		case tk_beg:
			ClearReg(itok.number);
			op(254); op(128+64+basecode+(unsigned int)itok.number);
			break;
		case tk_charvar:
		case tk_bytevar:
#ifdef OPTVARCONST
			UpdVarConst(&itok,1,tk_byte,operand);
#endif
			CheckAllMassiv(bufrm,1,&strinf);
			KillVar(itok.name);
			outseg(&itok,2);
			op(254);
			op(itok.rm+basecode);
			outaddress(&itok);
			break;
		case tk_longvar:
		case tk_dwordvar:
			CheckAllMassiv(bufrm,4,&strinf);
			if(cpu<3)cpu=3;
			razr=r32;
			goto dec;
		case tk_intvar:
		case tk_wordvar:
			CheckAllMassiv(bufrm,2,&strinf);
dec:
#ifdef OPTVARCONST
			UpdVarConst(&itok,1,tk_dword,operand);
#endif
			KillVar(itok.name);
			op66(razr);
			outseg(&itok,2);
			op(255);
			op(itok.rm+basecode);
			outaddress(&itok);
			break;
		default: varexpected(0);	break;
	}
}

void asmone2(int basecode)			 // used for NEG NOT MUL IMUL DIV IDIV.
{
int razr=r16;
#ifdef OPTVARCONST
int operand=GetOperand((basecode-16)/8+a_not);
#endif
	nexttok();
	switch(tok){
		case tk_reg32:
			if(cpu<3)cpu=3;
			razr=r32;
		case tk_reg:
			ClearReg(itok.number);
			op66(razr);
		  op(246+1); op(128+64+basecode+(unsigned int)itok.number); break;
		case tk_beg:
			ClearReg(itok.number);
			op(246); op(128+64+basecode+(unsigned int)itok.number); break;
			razr=r8;
		case tk_charvar:
		case tk_bytevar:
#ifdef OPTVARCONST
			UpdVarConst(&itok,0,tk_dword,operand);
#endif
			CheckAllMassiv(bufrm,1,&strinf);
			KillVar(itok.name);
			outseg(&itok,2);
			op(246);
			op(itok.rm+basecode);
			outaddress(&itok);
			razr=r8;
			break;
		case tk_longvar:
		case tk_dwordvar:
			CheckAllMassiv(bufrm,4,&strinf);
			if(cpu<3)cpu=3;
			razr=r32;
			goto neg;
		case tk_intvar:
		case tk_wordvar:
			CheckAllMassiv(bufrm,2,&strinf);
neg:
#ifdef OPTVARCONST
			UpdVarConst(&itok,0,tk_dword,operand);
#endif
			KillVar(itok.name);
			op66(razr);
			outseg(&itok,2);
			op(247);
			op(itok.rm+basecode);
			outaddress(&itok);
			break;
		default: varexpected(0);	break;
	}
	if(basecode!=16&&basecode!=24){
		ClearReg(AX);
		if(razr!=r8)ClearReg(DX);
	}
}

void  asmshortjump(int shortcode,int nearcode)
{
unsigned char next=1,shortjump=1;
unsigned int address;
#ifdef OPTVARCONST
	ClearLVIC();
#endif
	nexttok();
	if(stricmp("FAR",itok.name)==0){ 	 // case insensitive
		preerror("FAR jump not available for this instruction");
		nexttok();
	}
	else if(stricmp("NEAR",itok.name)==0){  // case insensitive
		shortjump=0;
		nexttok();
	}
	else if(stricmp("SHORT",itok.name)==0)nexttok();  // case insensitive
	if(shortjump){
		CheckIP();
		switch(tok){
			case tk_proc:
				*(unsigned int *)&itok.number-=outptr+2;
				if(short_ok(itok.number)){
					op(shortcode);
					op((unsigned int)itok.number);
				}
				else shortjumptoolarge();
				break;
			case tk_number:
				asmparam=FALSE;
				address=doconstdwordmath()-(outptr+2);
				if(short_ok(address)){
					op(shortcode);
					op(address);
				}
				else shortjumptoolarge();
				next=0;
				break;
			case tk_ID:
				addlocaljump(CALL_SHORT);
				op(shortcode); op(0x00);	 /* JXX SHORT */
				break;
			case tk_id:
				tobedefined(CALL_SHORT,tk_void);
				op(shortcode); op(0x00);	 /* JXX SHORT */
				break;
			case tk_declare:
				tok=tk_undefproc;
				updatetree();
			case tk_locallabel:
			case tk_undefproc:
				addacall((unsigned int)itok.number,(unsigned char)((itok.flag&f_extern)!=0?CALL_EXT:CALL_SHORT));
				op(shortcode); op(0x00);		/* JXX SHORT */
				break;
			default: shortjumperror(); break;
		}
	}
	else if(nearcode!=0){
unsigned long numlong;
		asmparam=FALSE;
		switch(tok){
			case tk_proc:
				op(0xF); op(nearcode);
				numlong=itok.number-outptr-2;
				if(am32==FALSE)outword((unsigned int)numlong);
				else outdword(numlong-2);
				break;
			case tk_number:
				op(0xF); op(nearcode);
				numlong=doconstdwordmath()-outptr-2;
				if(am32==FALSE)outword((unsigned int)numlong);
				else outdword(numlong-2);
				next=0;
				break;
			case tk_undefofs:	// ???? 32 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ०<><E0A5A6>
				op(0xF); op(nearcode);
				AddUndefOff(2,itok.name);
				outword(-(int)(outptr-2));
				if(am32!=FALSE)outword(0x0000);
				break;
			case tk_postnumber:
				op(0xF); op(nearcode);
				(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
				numlong=itok.number-outptr-2;
				if(am32==FALSE)outword((unsigned int)numlong);
				else outdword(numlong-2);
				break;
			case tk_ID:
				op(0xF);	 // must go before tobedefined()
				addlocaljump(am32==FALSE?CALL_NEAR:CALL_32);
				op(nearcode); outword(0x0000);			/* JXX NEAR */
				if(am32!=FALSE)outword(0x0000);
				break;
			case tk_id:
				op(0xF);	 // must go before tobedefined()
				tobedefined(am32==FALSE?CALL_NEAR:CALL_32,tk_void);
				op(nearcode); outword(0x0000);			/* JXX NEAR */
				if(am32!=FALSE)outword(0x0000);
				break;
			case tk_declare:
				tok=tk_undefproc;
				updatetree();
			case tk_locallabel:
			case tk_undefproc:
				op(0xF);	 // must go before addacall()
				addacall((unsigned int)itok.number,(unsigned char)((itok.flag&f_extern)!=0?CALL_EXT:(am32==FALSE?CALL_NEAR:CALL_32)));
				op(nearcode); outword(0x0000);  /* JXX NEAR */
				if(am32!=FALSE)outword(0x0000);
				break;
			default: preerror("Invalid operand for NEAR jump"); break;
		}
		if(cpu<3)cpu=3;
	}
	else preerror("NEAR jump not available for this instruction");
	if(next)nexttok();
}

void lar_lsl(int code)
{
unsigned char possiblecpu=0;
int razr=r16;
	nexttok();
	if(tok!=tk_reg&&tok!=tk_reg32)reg32regexpected(1);
	int htok=tok;
	int hnumber=(unsigned int)itok.number;
	ClearReg(itok.number);
	nextexpecting2(tk_camma);
	switch(tok){
		case tk_reg32:
			if(htok==tk_reg)reg32expected(1);
			possiblecpu=3;
			razr=r32;
			goto lar;
		case tk_reg:
			if(htok==tk_reg32)regexpected(1);
			possiblecpu=2;
lar:
			op66(razr);
			op(0x0f);
			op(code);
			op(0xc0+(unsigned int)itok.number+hnumber*8);
			break;
		case tk_longvar:
		case tk_dwordvar:
			if(htok==tk_reg)reg32expected(1);
			CheckAllMassiv(bufrm,4,&strinf);
			possiblecpu=3;
			razr=r32;
			goto lar1;
		case tk_intvar:
		case tk_wordvar:
			if(htok==tk_reg32)regexpected(1);
			possiblecpu=2;
			CheckAllMassiv(bufrm,2,&strinf);
lar1:
			op66(razr);
			outseg(&itok,3);
			op(0x0f);
			op(code);
			op(itok.rm+hnumber*8);
			outaddress(&itok);
			break;
		default: invalidoperand(2); break;
	}
	if(possiblecpu>cpu)cpu=possiblecpu;
}

unsigned char tabldeckr(int code)
{
unsigned int i=0;
int htok;
unsigned char next=1;
char name[IDLENGTH];
	nexttok();
	htok=tok;
	KillVar(itok.name);
	switch(tok){
		case tk_longvar:
		case tk_dwordvar:
			i=2;
		case tk_intvar:
		case tk_wordvar:
			i++;
		case tk_charvar:
		case tk_bytevar:
			i++;
			CheckAllMassiv(bufrm,i,&strinf);
			outseg(&itok,3);
			outword(0x010f);
			op(itok.rm+code);
			outaddress(&itok);
			break;
		case tk_undefofs:
			strcpy(name,itok.name);
			tok=tk_number;
		case tk_number:
			i=doconstdwordmath();
			outword(0x010f);
			op((am32==FALSE?rm_d16:rm_d32)+code);
		 	if(postnumflag&f_reloc)AddReloc();
		 	if(htok==tk_undefofs)AddUndefOff(2,name);
			if(am32)outdword(i);
			else outword(i);
			next=0;
			break;
		default: varexpected(0);
	}
	if(cpu<2)cpu=2;
	return next;
}

void  protectinstr(int code,int code2)
{
int i=0;
	nexttok();
	switch(tok){
		case tk_longvar:
		case tk_dwordvar:
			i=2;
		case tk_intvar:
		case tk_wordvar:
			i++;
		case tk_charvar:
		case tk_bytevar:
			i++;
#ifdef OPTVARCONST
			ClearVarByNum(&itok);
#endif
			CheckAllMassiv(bufrm,i,&strinf);
			KillVar(itok.name);
			outseg(&itok,3);
			op(0x0f);
			op(code);
			op(itok.rm+code2);
			outaddress(&itok);
			break;
		case tk_reg32:
		case tk_reg:
			ClearReg(itok.number);
			op(0x0f);
			op(code);
			op(0xc0+code2+(unsigned int)itok.number);
			break;
		default: wordvalexpected();
	}
	if(cpu<2)cpu=2;
}

void doasmmov() 		// do MOV
{
unsigned char next=1,possiblecpu=0;
int htok,typet;
ITOK hstok;
char *hbuf;
SINFO hstr;
#ifdef OPTVARCONST
int initconst=FALSE;
#endif
	nexttok();
	hstok=itok;
	htok=tok;
	hbuf=bufrm;
	bufrm=NULL;
	hstr=strinf;
	strinf.bufstr=NULL;
	nextexpecting2(tk_camma);
	typet=r16;
int i=tok;
	switch(htok){
		case tk_reg32:
			possiblecpu=3;
			typet=r32;
		case tk_reg:
			switch(tok){
				case tk_debugreg:
					ClearReg(hstok.number);
					if(typet==r16)goto erreg;
					outword(0x210F);
					op(128+64+(unsigned int)itok.number*8+hstok.number);
					possiblecpu=4;
					if((unsigned int)itok.number<=DR3||(unsigned int)itok.number==DR6
					   ||(unsigned int)itok.number==DR7)possiblecpu=3;
					break;
				case tk_controlreg:
					ClearReg(hstok.number);
					if(typet==r16)goto erreg;
					outword(0x200F);
					op(128+64+(unsigned int)itok.number*8+hstok.number);
					possiblecpu=4;
					if((unsigned int)itok.number<=CR3)possiblecpu=3;
					break;
				case tk_testreg:
					ClearReg(hstok.number);
					if(typet==r16)goto erreg;
					outword(0x240F);
					op(128+64+(unsigned int)itok.number*8+hstok.number);
					possiblecpu=4;
					if((unsigned int)itok.number==TR6||(unsigned int)itok.number==TR7)possiblecpu=3;
					break;
				case tk_reg32:
					if(typet==r16)goto erreg;
				case tk_reg:
					RegToReg(hstok.number,itok.number,typet);
					op66(typet);
					op(0x89);
					op(128+64+(unsigned int)itok.number*8+hstok.number);
					break;
				case tk_undefofs:
					strcpy(hstok.name,itok.name);
					tok=tk_number;
					goto wnum;
				case tk_minus:
					if(tok2!=tk_number){
						wordvalexpected();
						break;
					}
				case tk_number:
wnum:
					op66(typet);
					op(0xB8+hstok.number);
					ClearReg(hstok.number);
					asmparam=FALSE;
					SaveNumber(typet,i,hstok.name);
					next=0;
					break;
				case tk_postnumber:
					ClearReg(hstok.number);
					op66(typet);
					op(0xB8+hstok.number);
					(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
					if(typet==r32)outdword(itok.number);
					else outword((unsigned int)itok.number);
					break;
				case tk_dwordvar:
				case tk_longvar:
					if(typet==r16)goto erreg;
				case tk_wordvar:
				case tk_intvar:
					CheckAllMassiv(bufrm,typet,&strinf);
					IDZToReg(itok.name,hstok.number,typet);
					op66(typet);
					if(hstok.number==0&&((itok.rm==rm_d16&&itok.sib==CODE16)||(itok.rm==rm_d32&&(itok.sib==CODE32||itok.sib==0)))){
						outseg(&itok,1);
						op(0xA1);
					}
					else{
						outseg(&itok,2);
						op(0x8B);
						op(itok.rm+hstok.number*8);
					}
					outaddress(&itok);
					break;
				case tk_seg:
					if(typet==r32)goto erreg;
					IDZToReg(itok.name,hstok.number,typet);
					op66(r16);
					op(0x8C);
					op(128+64+(unsigned int)itok.number*8+hstok.number);
					if((unsigned int)itok.number==FS||(unsigned int)itok.number==GS)possiblecpu=3;
					break;
				default:
erreg:
					invalidoperand(2); break;
			}
			break;
		case tk_beg:
			ClearReg(hstok.number%4);
			switch(tok){
				case tk_beg:
						op(0x88);
						op(128+64+(unsigned int)itok.number*8+hstok.number);
					break;
				case tk_number:
					op(0xB0+hstok.number);
					asmparam=FALSE;
					op((int)doconstlongmath());
					next=0;
					break;
				case tk_bytevar:
				case tk_charvar:
					CheckAllMassiv(bufrm,1,&strinf);
					if(hstok.number==0&&((itok.rm==rm_d16&&itok.sib==CODE16)||(itok.rm==rm_d32&&(itok.sib==CODE32||itok.sib==0)))){
						outseg(&itok,1);
						op(0xA0);
					}
					else{
						outseg(&itok,2);
						op(0x8A);
						op(itok.rm+hstok.number*8);
					}
					outaddress(&itok);
					break;
				default: invalidoperand(2); break;
			}
			break;
		case tk_seg:
			if(hstok.number==CS){
				invalidoperand(1); break;
			}
			switch(tok){
				case tk_reg:
					op66(r16);
				  op(0x8E);
					op(128+64+hstok.number*8+(unsigned int)itok.number);
					if(hstok.number==FS||hstok.number==GS)possiblecpu=3;
					break;
				case tk_wordvar:
				case tk_intvar:
					CheckAllMassiv(bufrm,2,&strinf);
					op66(r16);
					outseg(&itok,2);
					op(0x8E);
					op(itok.rm+hstok.number*8);
					outaddress(&itok);
					if(hstok.number==FS||hstok.number==GS)possiblecpu=3;
					break;
				default: invalidoperand(2); break;
			}
			break;
		case tk_dwordvar:
		case tk_longvar:
			possiblecpu=3;
			typet=r32;
		case tk_wordvar:
		case tk_intvar:
			KillVar(itok.name);
			CheckAllMassiv(hbuf,typet,&hstr,&hstok);
			op66(typet);
			switch(tok){
				case tk_reg32:
					if(typet==r16)goto ervar;
				case tk_reg:
			/*if((tok==tk_reg||tok==tk_reg32)&&hbuf==NULL&&hstr.bufstr==NULL)*/
					AddRegVar(itok.number,typet,&hstok);
					if(itok.number==0&&((hstok.rm==rm_d16&&hstok.sib==CODE16)||(hstok.rm==rm_d32&&(hstok.sib==CODE32||hstok.sib==0)))){
						outseg(&hstok,1);
						op(0xA3);
						outaddress(&hstok);
					}
					else{
						outseg(&hstok,2);
						op(0x89);
						op(hstok.rm+(unsigned int)itok.number*8);
						outaddress(&hstok);
					}
					break;
				case tk_undefofs:
					strcpy(hstok.name,itok.name);
					tok=tk_number;
					goto vnum;
				case tk_minus:
					if(tok2!=tk_number){
						wordvalexpected();
						break;
					}
				case tk_number:
vnum:
					outseg(&hstok,2);
					op(0xC7);
					op(hstok.rm);
					outaddress(&hstok);
					asmparam=FALSE;
#ifdef OPTVARCONST
					unsigned long t;
					t=SaveNumber(typet,i,hstok.name);
					if(typet==r16)t&=0xffff;
					else t&=0xffffffff;
					if((i==tk_number||i==tk_minus)&&(postnumflag&f_reloc)){
						Const2Var(&hstok,t,tk_dword);
						initconst=TRUE;
					}
#else
					SaveNumber(typet,i,hstok.name);
#endif
					next=0;
					break;
				case tk_postnumber:
					outseg(&hstok,2);
					op(0xC7);
					op(hstok.rm);
					outaddress(&hstok);
					(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
					if(typet==r16)outword((unsigned int)itok.number);
					else outdword(itok.number);
					break;
				case tk_seg:
					outseg(&hstok,2);
					if(typet==r32)goto ervar;
					op(0x8C);
					op(hstok.rm+(unsigned int)itok.number*8);
					outaddress(&hstok);
					if(hstok.number==FS||hstok.number==GS)possiblecpu=3;
					break;
				default:
ervar:
					invalidoperand(2); break;
			}
#ifdef OPTVARCONST
			if(initconst==FALSE)ClearVarByNum(&hstok);
#endif
			break;
		case tk_charvar:
		case tk_bytevar:
			KillVar(itok.name);
			CheckAllMassiv(hbuf,1,&hstr,&hstok);
			switch(tok){
				case tk_beg:
			/*if(tok==tk_beg&&hbuf==NULL&&hstr.bufstr==NULL)*/
					AddRegVar(itok.number,r8,&hstok);
					if(itok.number==0&&((hstok.rm==rm_d16&&hstok.sib==CODE16)||(hstok.rm==rm_d32&&(hstok.sib==CODE32||hstok.sib==0)))){
						outseg(&hstok,1);
						op(0xA2);
						outaddress(&hstok);
					}
					else{
						outseg(&hstok,2);
						op(0x88);
						op(hstok.rm+(unsigned int)itok.number*8);
						outaddress(&hstok);
					}
					break;
				case tk_number:
					outseg(&hstok,2);
					op(0xC6);
					op(hstok.rm);
					outaddress(&hstok);
					asmparam=FALSE;
#ifdef OPTVARCONST
					long t;
					t=doconstlongmath()&0xff;
					op(t);
					if((postnumflag&f_reloc)){
						initconst=TRUE;
						Const2Var(&hstok,t,tk_byte);
					}
#else
					op((int)doconstlongmath());
#endif
					next=0;
					break;
				default: invalidoperand(2); break;
			}
#ifdef OPTVARCONST
			if(initconst==FALSE)ClearVarByNum(&hstok);
#endif
			break;
		case tk_debugreg:
			if(tok==tk_reg32){
				outword(0x230F);
				op(128+64+hstok.number*8+(unsigned int)itok.number);
				possiblecpu=4;
				if(hstok.number<=DR3||hstok.number==DR6||hstok.number==DR7)possiblecpu=3;
			}
			else invalidoperand(2);
			break;
		case tk_controlreg:
			if(tok==tk_reg32){
				outword(0x220F);
				op(128+64+hstok.number*8+(unsigned int)itok.number);
				possiblecpu=4;
				if(hstok.number<=CR3)possiblecpu=3;
			}
			else invalidoperand(2);
			break;
		case tk_testreg:
			if(tok==tk_reg32){
				outword(0x260F);
				op(128+64+hstok.number*8+(unsigned int)itok.number);
				possiblecpu=4;
				if(hstok.number==TR6||hstok.number==TR7)possiblecpu=3;
			}
			else invalidoperand(2);
			break;
		default: invalidoperand(1); break;
	}
	asmparam=FALSE;
	if(possiblecpu>cpu)cpu=possiblecpu;
	if(next)nexttok();
}

void asmextend(int basecode)	 // procedure MOVSX and MOVZX
{
int regnum;
int razr=r16;
	nexttok();
	if(tok==tk_reg32)razr=r32;
	if(tok!=tk_reg32&&tok!=tk_reg)reg32regexpected(1);
	regnum=(unsigned int)itok.number*8;
	ClearReg(itok.number);
	nextexpecting2(tk_camma);
	switch(tok){
		case tk_reg:
			op66(razr);
			op(0xF); op(basecode|1);
			op(128+64+regnum+(unsigned int)itok.number);
			break;
		case tk_beg:
			op66(razr);
			op(0xF); op(basecode);
			op(128+64+regnum+(unsigned int)itok.number);
			break;
		case tk_wordvar:
		case tk_intvar:
			CheckAllMassiv(bufrm,2,&strinf);
			op66(razr);
			outseg(&itok,3);
			op(0xF); op(basecode|1);
			op(itok.rm+regnum);
			outaddress(&itok);
			break;
		case tk_bytevar:
		case tk_charvar:
			CheckAllMassiv(bufrm,1,&strinf);
			op66(razr);
			outseg(&itok,3);
			op(0xF); op(basecode);
			op(itok.rm+regnum);
			outaddress(&itok);
			break;
		default: varexpected(2); break;
	}
	if(cpu<3)cpu=3;
}

void movd()
{
ITOK hstok;
int htok;
char *hbuf;
SINFO hstr;
int i=0;
	nexttok();
	hstok=itok;
	htok=tok;
	hbuf=bufrm;
	bufrm=NULL;
	hstr=strinf;
	strinf.bufstr=NULL;
	nextexpecting2(tk_camma);
	if(tok==tk_xmmreg)i++;
	switch(htok){
		case tk_reg32:
			ClearReg(hstok.number);
			if(tok==tk_mmxreg||i){	//MOVD EAX,MM0
				if(i)op(0x66);
				outword(0x7E0F);
				op(0xc0+hstok.number+(unsigned int)itok.number*8);
			}
			else mmxregexpected(2);
			break;
		case tk_dwordvar:
		case tk_longvar:
			if(tok==tk_mmxreg||i){	//MOVD mem,MM0
#ifdef OPTVARCONST
				ClearVarByNum(&hstok);
#endif
				CheckAllMassiv(hbuf,4,&hstr,&hstok);
				KillVar(hstok.name);
				outseg(&hstok,i==0?3:4);
				if(i)op(0x66);
				outword(0x7E0F);
				op(hstok.rm+(unsigned int)itok.number*8);
				outaddress(&hstok);
			}
			else mmxregexpected(2);
			break;
		case tk_xmmreg:
			i++;
		case tk_mmxreg:
			switch(tok){
				case tk_reg32:	//MOVD MM0,EAX
					if(i)op(0x66);
					outword(0x6E0F);
					op(0xc0+hstok.number*8+(unsigned int)itok.number);
					break;
				case tk_dwordvar:	//MOVD MMO,mem
				case tk_longvar:
					CheckAllMassiv(bufrm,4,&strinf);
					outseg(&itok,i==0?3:4);
					if(i)op(0x66);
					outword(0x6E0F);
					op(itok.rm+hstok.number*8);
					outaddress(&itok);
					break;
				default: dwordvalexpected();
			}
			break;
		default: mmxregordwordexpected(1);
	}
	if(cpu<6)cpu=6;
	if(i&&cpu<9)cpu=9;
}

void movq()
{
int htok;
ITOK hstok;
char *hbuf;
SINFO hstr;
int i=1,xmm=0;
	nexttok();
	hstok=itok;
	htok=tok;
	hbuf=bufrm;
	bufrm=NULL;
	hstr=strinf;
	strinf.bufstr=NULL;
	nextexpecting2(tk_camma);
	if(tok==tk_xmmreg)xmm++;
	switch(htok){
		case tk_qwordvar:
		case tk_doublevar:
			i+=4;
		case tk_longvar:
		case tk_dwordvar:
		case tk_floatvar:
			i+=2;
		case tk_wordvar:
		case tk_intvar:
			i++;
		case tk_charvar:
		case tk_bytevar:
			if(tok==tk_mmxreg||xmm){	//MOVQ mem,MM0
#ifdef OPTVARCONST
				ClearVarByNum(&hstok);
#endif
				KillVar(hstok.name);
				CheckAllMassiv(hbuf,i,&hstr,&hstok);
				outseg(&hstok,xmm==0?3:4);
				if(xmm){
					op(0x66);
					outword(0xD60f);
				}
				else outword(0x7F0F);
				op(hstok.rm+(unsigned int)itok.number*8);
				outaddress(&hstok);
			}
			else mmxregexpected(2);
			break;
		case tk_mmxreg:
			switch(tok){
				case tk_mmxreg:	//MOVQ MM0,MM1
					outword(0x6F0F);
					op(0xc0+hstok.number*8+(unsigned int)itok.number);
					break;
				case tk_qwordvar:
				case tk_doublevar:
					i+=4;
				case tk_longvar:
				case tk_dwordvar:
				case tk_floatvar:
					i+=2;
				case tk_wordvar:
				case tk_intvar:
					i++;
				case tk_charvar:
				case tk_bytevar:
					CheckAllMassiv(bufrm,i,&strinf);
					outseg(&itok,3);
					outword(0x6F0F);
					op(itok.rm+hstok.number*8);
					outaddress(&itok);
					break;
				default: mmxregordwordexpected(2);
			}
			break;
		case tk_xmmreg:
			switch(tok){
				case tk_xmmreg:
					op(0xF3);
					outword(0x7e0F);
					op(0xc0+hstok.number*8+(unsigned int)itok.number);
					break;
				case tk_qwordvar:
				case tk_doublevar:
					i+=4;
				case tk_longvar:
				case tk_dwordvar:
				case tk_floatvar:
					i+=2;
				case tk_wordvar:
				case tk_intvar:
					i++;
				case tk_charvar:
				case tk_bytevar:
					CheckAllMassiv(bufrm,i,&strinf);
					outseg(&itok,4);
					op(0xF3);
					outword(0x7E0F);
					op(itok.rm+hstok.number*8);
					outaddress(&itok);
					xmm++;
					break;
				default: xmmregorvarexpected(2);
			}
			break;
		default: mmxregordwordexpected(1);
	}
	if(cpu<6)cpu=6;
	if(xmm&&cpu<9)cpu=9;
}

void packMMX(int code,int code1,int code2)
{
unsigned int hnumber;
int htok,next=TRUE;
int i=1;
int xmm=FALSE;
	nexttok();
	hnumber=(unsigned int)itok.number;
	htok=tok;
	nextexpecting2(tk_camma);
	if(htok==tk_xmmreg)xmm=TRUE;
	else if(htok!=tk_mmxreg)mmxregexpected(1);
	switch(tok){
		case tk_mmxreg:
			if(xmm)xmmregexpected(2);
			op(0x0f);
			op(code);
			op(0xc0+hnumber*8+(unsigned int)itok.number);
			break;
		case tk_xmmreg:
			if(!xmm)mmxregexpected(2);
			else op(0x66);
			op(0x0f);
			op(code);
			op(0xc0+hnumber*8+(unsigned int)itok.number);
			break;
		case tk_number:
			if(xmm)op(0x66);
			op(0x0f);
			op(code1);
			op(code2+hnumber);
		 	asmparam=FALSE;
			op((unsigned int)doconstlongmath());
			next=FALSE;
			break;
		case tk_qwordvar:
			i+=4;
		case tk_longvar:
		case tk_dwordvar:
		case tk_floatvar:
			i+=2;
		case tk_wordvar:
		case tk_intvar:
			i++;
		case tk_charvar:
		case tk_bytevar:
			CheckAllMassiv(bufrm,i,&strinf);
			outseg(&itok,xmm==FALSE?3:4);
			if(xmm)op(0x66);
			op(0x0f);
			op(code);
			op(itok.rm+hnumber*8);
			outaddress(&itok);
			break;
		default:
			mmxregordwordexpected(2);
			break;
	}
	if(cpu<6)cpu=6;
	if(xmm&&cpu<9)cpu=9;
	if(next==TRUE)nexttok();
}

void asmshift(int basecode) 		 // used for ROL ROR RCL RCR SHL SAL SHR SAR.
{
int htok,precode;
unsigned char holdbyte;
int usenumsh=TRUE;
ITOK hstok;
char *hbuf;
char next=1;
SINFO hstr;
int razr=r16;
#ifdef OPTVARCONST
int operand=GetOperand(basecode/8+a_rol);
#endif
	nexttok();
	htok=tok;
	hstok=itok;
	hbuf=bufrm;
	bufrm=NULL;
	hstr=strinf;
	strinf.bufstr=NULL;
	nextexpecting2(tk_camma);
	if(tok==tk_beg&&(unsigned int)itok.number==CL){
		precode=0xD2;
		usenumsh=FALSE;
	}
	else if(tok==tk_number){
		asmparam=FALSE;
		holdbyte=(unsigned char)doconstlongmath();
		if(holdbyte==1){
			precode=0xD0;
			usenumsh=FALSE;
		}
		else /*if(holdbyte!=0)*/{
			precode=0xC0;
			if(cpu<2)cpu=2;
		}
		next=0;
	}
	else clornumberexpected();
//	if(precode!=0){
		switch(htok){
			case tk_reg32:
				if(cpu<3)cpu=3;
				razr=r32;
			case tk_reg:
				ClearReg(hstok.number);
				op66(razr);
			  op(precode+1); op(128+64+basecode+hstok.number);
				break;
			case tk_beg:
				ClearReg(hstok.number);
				op(precode); op(128+64+basecode+hstok.number);
				break;
			case tk_charvar:
			case tk_bytevar:
#ifdef OPTVARCONST
				if(precode==0xD0||precode==0xc0)UpdVarConst(&hstok,holdbyte,tk_byte,operand);
				else ClearVarByNum(&hstok);
#endif
				CheckAllMassiv(hbuf,1,&hstr,&hstok);
				KillVar(hstok.name);
				outseg(&hstok,2);
				op(precode);
				op(hstok.rm+basecode);
				outaddress(&hstok);
				break;
			case tk_dwordvar:
			case tk_longvar:
				CheckAllMassiv(hbuf,4,&hstr,&hstok);
				if(cpu<3)cpu=3;
				razr=r32;
				goto rol;
			case tk_wordvar:
			case tk_intvar:
				CheckAllMassiv(hbuf,2,&hstr,&hstok);
rol:
#ifdef OPTVARCONST
				if(precode==0xD0||precode==0xc0)UpdVarConst(&hstok,holdbyte,tk_byte,operand);
				else ClearVarByNum(&hstok);
#endif
				KillVar(hstok.name);
				op66(razr);
				outseg(&hstok,2);
				op(precode+1);
				op(hstok.rm+basecode);
				outaddress(&hstok);
				break;
			default: varexpected(1); break;
		}
		if(usenumsh)op(holdbyte);
	if(next)nexttok();
}

void CheckCl(int code)
{
	op(0xf);
	if(tok==tk_beg){
		if(itok.number==CL)code++;
		else clornumberexpected();
	}
	else if(tok!=tk_number)clornumberexpected();
	op(code);
}

void Shxd(int code)
{
unsigned int h2number;
int htok,h2tok;
ITOK hstok;
char *hbuf;
unsigned char next=1;
SINFO hstr;
	nexttok();
	hstok=itok;
	htok=tok;
	hbuf=bufrm;
	bufrm=NULL;
	hstr=strinf;
	strinf.bufstr=NULL;
	nextexpecting2(tk_camma);
	h2number=(unsigned int)itok.number;
	ClearReg(itok.number);
	h2tok=tok;
	nextexpecting2(tk_camma);
	switch(htok){
		case tk_reg:
			if(h2tok==tk_reg){
				op66(r16);
regreg:
				ClearReg(hstok.number);
				CheckCl(code);
				op(0xc0+hstok.number+(unsigned int)h2number*8);
				if(tok==tk_number){
					asmparam=FALSE;
					op(doconstlongmath());
					next=0;
				}
			}
			else regexpected(2);
			break;
		case tk_reg32:
			if(h2tok==tk_reg32){
				op66(r32);
				goto regreg;
			}
			else reg32expected(2);
			break;
		case tk_intvar:
		case tk_wordvar:
			if(h2tok==tk_reg){
				CheckAllMassiv(hbuf,2,&hstr,&hstok);
				op66(r16);
varreg:
#ifdef OPTVARCONST
			ClearVarByNum(&hstok);
#endif

			KillVar(hstok.name);
				outseg(&hstok,3);
				CheckCl(code);
				op(hstok.rm+h2number*8);
				outaddress(&hstok);
				if(tok==tk_number){
					asmparam=FALSE;
					op(doconstlongmath());
					next=0;
				}
			}
			else regexpected(2);
			break;
		case tk_dwordvar:
		case tk_longvar:
			if(h2tok==tk_reg32){
				CheckAllMassiv(hbuf,4,&hstr,&hstok);
				op66(r32);
				goto varreg;
			}
			else reg32expected(2);
			break;
		default: valueexpected();
	}
	if(cpu<3)cpu=3;
	if(next)nexttok();
}

void FpuType1(unsigned int addrm)
{
int opcode=0xd8;
int oscan=scanlexmode;
	scanlexmode=ASMLEX;
	nexttok();
	retoldscanmode(oscan);
	if(tok==tk_endline||tok==tk_semicolon){
		op(0xD8);
		op(0xC1+addrm);
		return;
	}
	if(tok==tk_double){
		opcode=0xdc;
		nexttok();
	}
	switch(tok){
		case tk_fpust:
			op(0xD8);
			op(0xC0+(unsigned int)itok.number+addrm);
			break;
		case tk_longvar:
		case tk_dwordvar:
		case tk_floatvar:
			CheckAllMassiv(bufrm,4,&strinf);
			outseg(&itok,2);
			op(opcode);
			op(itok.rm+addrm);
			outaddress(&itok);
			break;
		case tk_doublevar:
			CheckAllMassiv(bufrm,8,&strinf);
			outseg(&itok,2);
			op(0xDC);
			op(itok.rm+addrm);
			outaddress(&itok);
			break;
		default: fpuvarexpected(0);
	}
}

void FpuType2(unsigned int addrm,unsigned int addrm2)
{
long hnum;
int opcode=0xd8;
int oscan=scanlexmode;
	scanlexmode=ASMLEX;
	nexttok();
	retoldscanmode(oscan);
	if(tok==tk_endline||tok==tk_semicolon){
		op(0xDE);
		op(0xC1+addrm);
		return;
	}
	if(tok==tk_double){
		opcode=0xdc;
		nexttok();
	}
	switch(tok){
		case tk_fpust:
			hnum=itok.number;
			nextexpecting2(tk_camma);
			if(hnum==0){
				if(tok==tk_fpust){
					op(0xD8);
					op(0xC0+addrm2+(unsigned int)itok.number);
				}
				else fpustakexpected(2);
			}
			else{
				if(tok==tk_fpust){
					if(itok.number!=0)fpu0expected();
					op(0xDC);
					op(0xC0+(unsigned int)hnum+addrm);
				}
				else fpustakexpected(2);
			}
			break;
		case tk_longvar:
		case tk_dwordvar:
		case tk_floatvar:
			CheckAllMassiv(bufrm,4,&strinf);
			outseg(&itok,2);
			op(opcode);
			op(addrm2+itok.rm);
			outaddress(&itok);
			break;
		case tk_doublevar:
			CheckAllMassiv(bufrm,8,&strinf);
			outseg(&itok,2);
			op(0xDC);
			op(addrm2+itok.rm);
			outaddress(&itok);
			break;
		default: fpuvarexpected(1);
	}
}

void FpuType3(unsigned int opcode,unsigned int addrm)
{
int oscan=scanlexmode;

	scanlexmode=ASMLEX;
	nexttok();
//	scanlexmode=oscan;
	retoldscanmode(oscan);
	if((tok==tk_endline||tok==tk_semicolon)&&opcode!=0xDD){
		op(opcode);
		op(0xC1+addrm);
	}
	else if(tok==tk_fpust){
		op(opcode);
		op(0xC0+(unsigned int)itok.number+addrm);
	}
	else fpustakexpected(1);
	if(opcode==0xDE&&tok2==tk_camma){
		nexttok();
		nexttok();
		if(tok!=tk_fpust||itok.number!=0)fpu0expected();

	}
}

void FpuType4(unsigned int opcode,unsigned int addrm)
{
	nexttok();
	if(opcode==1&&(addrm==0x18||addrm==0)&&tok==tk_qwordvar){
		if(addrm==0)addrm=0x28;
		else addrm=0x38;
		CheckAllMassiv(bufrm,8,&strinf);
		KillVar(itok.name);
		outseg(&itok,2);
		op(0xDF);
		op(itok.rm+addrm);
		outaddress(&itok);
		return;
	}
	switch(tok){
		case tk_wordvar:
		case tk_intvar:
			CheckAllMassiv(bufrm,2,&strinf);
			KillVar(itok.name);
			outseg(&itok,2);
			op(0xDE + opcode);
			op(itok.rm+addrm);
			outaddress(&itok);
			break;
		case tk_longvar:
		case tk_dwordvar:
		case tk_floatvar:
			CheckAllMassiv(bufrm,4,&strinf);
			KillVar(itok.name);
			outseg(&itok,2);
			op(0xDA+opcode);
			op(itok.rm+addrm);
			outaddress(&itok);
			break;
		default: fpuvarexpected(0);
	}
}

void  FpuType5(unsigned int opcode,unsigned int addrm)
{
int opc=0xd9;
int i=4;
	nexttok();
	if(tok==tk_qword||tok==tk_double){
		nexttok();
		tok=tk_qwordvar;
	}
	else if((strcmp(itok.name,"tbyte")==0||strcmp(itok.name,"ldouble")==0)&&addrm!=0x10){
		opc=0xdb;
		i=10;
		if(addrm==0)addrm=40;
		else addrm=56;
		nexttok();
		if(tok>=tk_charvar&&tok<=tk_wordvar)tok=tk_dwordvar;
	}
	switch(tok){
		case tk_fpust:
			op(opcode);
			op(0xC0+(unsigned int)itok.number+addrm);
			break;
		case tk_qwordvar:
		case tk_doublevar:
			opc=0xdd;
			i=8;
		case tk_longvar:
		case tk_dwordvar:
		case tk_floatvar:
			CheckAllMassiv(bufrm,i,&strinf);
			if(opcode!=0xD9)KillVar(itok.name);
			outseg(&itok,2);
			op(opc);
			op(itok.rm+addrm);
			outaddress(&itok);
			break;
		default: fpuvarexpected(0);
	}
}

void FpuType6(unsigned int opcode,unsigned int addrm)
{
int i=0;
	nexttok();
	if(opcode==0xDF){
		if(tok==tk_qword){
			nexttok();
			tok=tk_qwordvar;
		}
		if(strcmp(itok.name,"tbyte")==0){
			i=2;
			nexttok();
			tok=tk_qwordvar;
		}
	}
	switch(tok){
		case tk_qwordvar:
		if(opcode!=0xDF)wordvalexpected();
			i=+4;
		case tk_longvar:
		case tk_dwordvar:
		case tk_floatvar:
			i+=2;
		case tk_wordvar:
		case tk_intvar:
			i+=2;
			CheckAllMassiv(bufrm,i,&strinf);
			KillVar(itok.name);
			outseg(&itok,2);
			op(opcode);
			op(itok.rm+addrm);
			outaddress(&itok);
			break;
		default: wordvalexpected();
	}
}

void FpuType7(unsigned int addrm)
{
	nexttok();
	switch(tok){
		case tk_wordvar:
		case tk_intvar:
			CheckAllMassiv(bufrm,2,&strinf);
			if(addrm!=0x28)KillVar(itok.name);
			outseg(&itok,2);
			op(0xD9);
			op(itok.rm+addrm);
			outaddress(&itok);
			break;
		default: wordvalexpected();
	}
}

void FpuType8(unsigned int opcode,unsigned int addrm)
{
	nexttok();
	if(tok==tk_fpust&&itok.number==0&&tok2==tk_camma){
		nexttok();
		nexttok();
	}
	if(tok==tk_fpust){
		op(opcode);
		op(0xC0+(unsigned int)itok.number+addrm);
		if(cpu<7)cpu=7;
	}
	else fpustakexpected(1);
}

/* ***************** start of some quick codes ****************** */

int  short_ok(long thenumber,int reg32)
{
	if(reg32==TRUE){
		if(thenumber<=SHORTMAX&&thenumber>=SHORTMIN)return(1);
	}
	else{
		if((short)thenumber<=SHORTMAX&&(short)thenumber>=SHORTMIN)return(1);
	}
	return(0);
}

void cbw()
{
	if(optimizespeed&&(chip==5||chip==6)){
		outdword(0xFCC0C488);	//mov ah,al	sar AH,7
		op(7);
	}
	else{
		op66(r16);
		op(0x98);
	}
	ClearReg(AX);
}

void stosb()
{
	op(0xAA);
	ClearReg(DI);
}

void stosw()
{
	op66(r16);
	op(0xAB);
	ClearReg(DI);
}

void stosd()
{
	op66(r32);
	op(0xAB);
	if(cpu<3)cpu=3;
	ClearReg(DI);
}

void movsb()
{
	op(0xA4);
	ClearReg(DI);
	ClearReg(SI);
}

void movsw()
{
	op66(r16);
	op(0xA5);
	ClearReg(DI);
	ClearReg(SI);
}

void movsd()
{
	op66(r32);
	op(0xA5);
	if(cpu<3)cpu=3;
	ClearReg(DI);
	ClearReg(SI);
}

void pushds()  /* produce PUSH DS */
{
	RestoreStack();
	op(0x1E);
}

void pushss()
{
	RestoreStack();
	op(0x16);			/* PUSH SS */
}

void popes()	 /* produce POP ES */
{
	RestoreStack();
	op(0x07);
}

void ret()		/* produce RET */
{
	RestoreStack();
	op(0xC3);
}

void retf() 	/* produce RETF */
{
	RestoreStack();
	op(0xCB);
}

void jumploc(long loc)		 /* produce JUMP # */
{

	loc=loc-outptr-3;
	if(loc>-130&&loc<127){
		loc++;
		op(0xEB);
		op(loc);
		if(loc==0)notunreach=TRUE;
	}
	else{
		if(am32==FALSE){
			op(0xE9);
			outword(loc);
		}
		else{
			if(!optimizespeed&&(loc>126&&loc<65533)){
				outword(0xE966);
				outword(loc-1);
			}
			else{
				op(0xE9);
				outdword(loc-2);
			}
		}
	}
}

void callloc(long loc)	 /* produce CALL # */
{
	loc=loc-outptr-3;
	op(0xE8);
	if(am32==FALSE)	outword(loc);
	else outdword(loc-2);
}

void xorAHAH()	 /* produce XOR AH,AH */
{
	outword(0xE430);
	ConstToReg(0,AH,r8);
}

void xorAXAX()	 /* produce XOR AX,AX */
{
	op66(r16);
	outword(0xC031);
	ConstToReg(0,AX,r16);
}

void xorEAXEAX()	 /* produce XOR EAX,EAX */
{
	op66(r32);
	outword(0xC031);
	if(cpu<3)cpu=3;
	ConstToReg(0,AX,r32);
}

void ZeroReg(int reg, int razr)
{
	op66(razr);
	op(0x31);
	op(0xc0+9*reg);	//xor reg,reg
	ConstToReg(0,reg,razr);
}

void fwait()
{
	op(0x9B);
}

void cwdq(int razr)
{
	op66(razr);
	if(optimizespeed&&(chip==5||chip==6)){
		outword(0xC289);	//mov dx,ax
		op66(razr);
		outword(0xFAC1);	//sar dx,15
		op(razr==r16?15:31);
	}
	else op(0x99);
	ClearReg(DX);
}

void  nextexpecting2(int want)
{
	nexttok();
	expecting2(want);
}

void expecting2(int want)
{
	if(want!=tok)SwTok(want);
	nexttok();
}

void CheckIP()
{
	if(tok==tk_dollar){
		tok=tk_number;
		itok.number=outptr;
	}
}

void jumploc0()
{
	op(0xE9);
	outword(0); 	/* the large jump */
	if(am32!=FALSE)outword(0);
}

void callloc0()
{
	op(0xE8);
	outword(0);
	if(am32!=FALSE)outword(0);
}

void Leave()
{
	if((optimizespeed&&chip>3&&chip<7)||chip==0){
		outword(0xEC89);	// MOV SP,BP
		op(0x5D);
	}
	else op(0xC9);
}

void  tobedefined(int callkind,int expectedreturn)
{
//	strcpy(itok.name,(char *)string);
	string[0]=0;
	itok.flag=(unsigned char)(tok==tk_ID?tp_fastcall:(comfile==file_w32?tp_stdcall:tp_pascal));
	tok=tk_undefproc;
	itok.number=secondcallnum;
	itok.segm=NOT_DYNAMIC;
	itok.rm=expectedreturn;
	itok.post=0;
	addtotree(itok.name);
	addacall(secondcallnum++,(unsigned char)callkind);
}

void  addlocaljump(int callkind)
{
	addlocalvar((char *)string,tk_locallabel,secondcallnum,TRUE);
	addacall(secondcallnum++,(char)callkind);
}

unsigned long SaveNumber(int type,int tok4,char *name)
{
	unsigned long t=doconstdwordmath();
	if(tok4==tk_undefofs)AddUndefOff(0,name);
	else if((postnumflag&f_reloc)!=0)AddReloc();
	if(type==r16)outword((unsigned int)t);
	else outdword(t);
	return t;
}

void Swap2tok(int *tok4, ITOK *itok4, char **buf4, SINFO *strinf4, int *tok6,
	 ITOK *itok6, char **buf6, SINFO *strinf6)
{
int htok;
ITOK hstok;
char *hbuf;
SINFO hstr;
	htok=*tok4;
	*tok4=*tok6;
	*tok6=htok;
	hstok=*itok4;
	*itok4=*itok6;
	*itok6=hstok;
	hbuf=*buf4;
	*buf4=*buf6;
	*buf6=hbuf;
	hstr=*strinf4;
	*strinf4=*strinf6;
	*strinf6=hstr;
}

int iTest(int mode)
{
int htok,i;
ITOK hstok;
char *hbuf;
SINFO hstr;
unsigned char possiblecpu=0,next=1;
unsigned long num;
 	asmparam=TRUE;
	nexttok();
	htok=tok;
	hstok=itok;
	hbuf=bufrm;
	bufrm=NULL;
	hstr=strinf;
	strinf.bufstr=NULL;
	if(tok==tk_number)hstok.number=doconstlongmath();
	else nexttok();
	expecting2(tk_camma);
	i=r16;
//	printf("tok=%d itok.number=%u bufrm=%s htok=%d hstok.number=%u nbuf=%s\n",
//	 tok,itok.number,bufrm,htok,hstok.number,hbuf);
	if(htok==tk_number||htok==tk_postnumber)Swap2tok(&tok,&itok,&bufrm,&strinf,
			&htok,&hstok,&hbuf,&hstr);
//	printf("tok=%d itok.number=%u bufrm=%s htok=%d hstok.number=%u nbuf=%s\n",
//	 tok,itok.number,bufrm,htok,hstok.number,hbuf);
	switch(htok){
		case tk_reg32:
			i=r32;
			possiblecpu=3;
		case tk_reg:
			switch(tok){
				case tk_reg32:
					if(i==r16){
						reg32expected(1);
						return FALSE;
					}
					op66(i);
					op(0x85);
					op(128+64+(unsigned int)itok.number*8+hstok.number);
					break;
				case tk_reg:
					if(i==r32){
						reg32expected(2);
						return FALSE;
					}
					op66(i);
					op(0x85);
					op(128+64+(unsigned int)itok.number*8+hstok.number);
					break;
				case tk_number:
				 	asmparam=FALSE;
					num=doconstdwordmath();
					if(mode){
						if(num<256&&hstok.number<4)goto testal;
						if(num<65536)i=r16;
					}
					op66(i);
					if(hstok.number==AX)op(0xA9);
					else{
						op(0xF7);
						op(128+64+hstok.number);
					}
					if(i==r16)outword((unsigned int)num);
					else outdword(num);
					next=0;
					break;
				case tk_postnumber:
					if(i==r32)return FALSE;
					op66(r16);
					if(hstok.number==AX)op(0xA9);
					else{
						op(0xF7);
						op(128+64+hstok.number);
					}
					(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
					outword(itok.number);	//<2F>뫮 0
					break;
				case tk_dwordvar:
				case tk_longvar:
					if(i==r16){
						reg32expected(1);
						return FALSE;
					}
					CheckAllMassiv(bufrm,i,&strinf);
					op66(i);
					outseg(&itok,2);
					op(0x85);
					op(hstok.number*8+itok.rm);
					outaddress(&itok);
					break;
				case tk_wordvar:
				case tk_intvar:
					if(i==r32){
						regexpected(1);
						return FALSE;
					}
					CheckAllMassiv(bufrm,i,&strinf);
					op66(i);
					outseg(&itok,2);
					op(0x85);
					op(hstok.number*8+itok.rm);
					outaddress(&itok);
					break;
				default: return FALSE;
			}
			break;
		case tk_beg:
			switch(tok){
				case tk_beg:
					op(0x84);
					op(128+64+(unsigned int)itok.number*8+hstok.number);
					break;
				case tk_number:
				 	asmparam=FALSE;
					num=doconstdwordmath();
testal:
					if(hstok.number==AL)op(0xA8);
					else{
						op(0xF6);
						op(128+64+hstok.number);
					}
					op(num);
					next=0;
					break;
				case tk_charvar:
				case tk_bytevar:
					CheckAllMassiv(bufrm,1,&strinf);
					outseg(&itok,2);
					op(0x84);
					op(hstok.number*8+itok.rm);
					outaddress(&itok);
					break;
				default: return FALSE;
			}
			break;
		case tk_dwordvar:
		case tk_longvar:
			i=r32;
			possiblecpu=3;
		case tk_wordvar:
		case tk_intvar:
			CheckAllMassiv(hbuf,i,&hstr,&hstok);
			switch(tok){
				case tk_reg32:
					if(i==r16){
						regexpected(2);
						return FALSE;
					}
					op66(i);
					outseg(&hstok,2);
					op(0x85);
					op((unsigned int)itok.number*8+hstok.rm);
					outaddress(&hstok);
					break;
				case tk_reg:
					if(i==r32){
						reg32expected(2);
						return FALSE;
					}
					op66(i);
					outseg(&hstok,2);
					op(0x85);
					op((unsigned int)itok.number*8+hstok.rm);
					outaddress(&hstok);
					break;
				case tk_number:
				 	asmparam=FALSE;
					num=doconstdwordmath();
					if(mode){
						if(num<256)goto testbyte;
						if(num<65536)i=r16;
					}
					op66(i);
					outseg(&hstok,2);
					op(0xF7);
					op(hstok.rm);
					outaddress(&hstok);
					if(i==r32)outdword(num);
					else outword((unsigned int)num);
					next=0;
					break;
				case tk_postnumber:
					op66(i);
					outseg(&hstok,2);
					if(i==r32)return FALSE;
					op(0xF7);
					op(hstok.rm);
					outaddress(&hstok);
					(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
					outword((unsigned int)itok.number);
					break;
				default: return FALSE;
			}
			break;
		case tk_charvar:
		case tk_bytevar:
			CheckAllMassiv(hbuf,1,&hstr,&hstok);
			switch(tok){
				case tk_beg:
					outseg(&hstok,2);
					op(0x84);
					op((unsigned int)itok.number*8+hstok.rm);
					outaddress(&hstok);
					break;
				case tk_number:
				 	asmparam=FALSE;
					num=doconstdwordmath();
testbyte:
					outseg(&hstok,2);
					op(0xF6);
					op(hstok.rm);
					outaddress(&hstok);
					op(num);
					next=0;
					break;
				default: return FALSE;
			}
			break;
		default: return FALSE;
	}
	if(cpu<possiblecpu)cpu=possiblecpu;
	if(next)nexttok();
	return TRUE;
}

void mmxiii(int type)
{
int num1,i=1;
int xmm=FALSE;
	nexttok();
	if(tok==tk_xmmreg)xmm=TRUE;
	else if(tok!=tk_mmxreg)mmxregexpected(1);
	num1=itok.number;
	nextexpecting2(tk_camma);
	switch(tok){
		case tk_mmxreg:
			if(xmm)xmmregorvarexpected(2);
			op(0x0F);
			op(type);
			op(rm_mod11+itok.number+num1*8);
			break;
		case tk_xmmreg:
			if(xmm==FALSE)mmxormem(2);
			outword(0x0F66);
			op(type);
			op(rm_mod11+itok.number+num1*8);
			break;
		case tk_qwordvar:
			i+=4;
		case tk_longvar:
		case tk_dwordvar:
		case tk_floatvar:
			i+=2;
		case tk_wordvar:
		case tk_intvar:
			i++;
		case tk_charvar:
		case tk_bytevar:
			CheckAllMassiv(bufrm,i,&strinf);
			outseg(&itok,xmm==FALSE?3:4);
			if(xmm)op(0x66);
			op(0x0F);
			op(type);
			op(itok.rm+num1*8);
			outaddress(&itok);
			break;
		default:
			mmxormem(2);
			break;
	}
	if(cpu<8)cpu=8;
	if(xmm&&cpu<9)cpu=9;
}

void prefetch(int code,int type)
{
int i=1;
	nexttok();
	switch(tok){
		case tk_qwordvar:
			i+=4;
		case tk_longvar:
		case tk_dwordvar:
		case tk_floatvar:
			i+=2;
		case tk_wordvar:
		case tk_intvar:
			i++;
		case tk_charvar:
		case tk_bytevar:
			CheckAllMassiv(bufrm,i,&strinf);
			KillVar(itok.name);
			outseg(&itok,3);
			op(0x0f);
			op(code);
			op(itok.rm+type*8);
			outaddress(&itok);
			break;
		default:
			datatype_expected(1);
			break;
	}
}

void pextrw()
{
int num1,num2;
int xmm=FALSE;
	nexttok();
	if(tok!=tk_reg32)reg32expected(1);
	num1=itok.number;
	ClearReg(num1);
	nextexpecting2(tk_camma);
	if(tok==tk_xmmreg)xmm=TRUE;
	else if(tok!=tk_mmxreg)mmxregexpected(2);
	num2=itok.number;
	nextexpecting2(tk_camma);
	if(tok!=tk_number)numexpected(3);
	if(xmm)op(0x66);
	outword(0xC50F);
	op(rm_mod11+num1+num2*8);
	op(doconstdwordmath());
	if(cpu<8)cpu=8;
	if(xmm&&cpu<9)cpu=9;
}

void pinsrw()
{
int num1,htok;
ITOK hstok;
char *hbuf;
SINFO hstr;
int xmm=FALSE;
	nexttok();
	if(tok==tk_xmmreg)xmm=TRUE;
	else if(tok!=tk_mmxreg)mmxregexpected(1);
	num1=itok.number;
	nextexpecting2(tk_camma);
	htok=tok;
	hstok=itok;
	hbuf=bufrm;
	bufrm=NULL;
	hstr=strinf;
	strinf.bufstr=NULL;
	nextexpecting2(tk_camma);
	if(tok!=tk_number)numexpected(3);
	switch(htok){
		case tk_reg32:
			if(xmm)op(0x66);
			outword(0xC40F);
			op(rm_mod11+num1+hstok.number*8);
			break;
		case tk_wordvar:
		case tk_intvar:
			CheckAllMassiv(hbuf,2,&hstr);
			outseg(&hstok,xmm==FALSE?3:4);
			if(xmm)op(0x66);
			outword(0xC40F);
			op(hstok.rm+num1*8);
			outaddress(&hstok);
			break;
		default:
			reg32orword(2);
			break;
	}
	op(doconstdwordmath());
	if(cpu<8)cpu=8;
	if(xmm&&cpu<9)cpu=9;
}

void pshufw()
{
int num1,htok;
ITOK hstok;
char *hbuf;
SINFO hstr;
int i=1;
	nexttok();
	if(tok!=tk_mmxreg)mmxregexpected(1);
	num1=itok.number;
	nextexpecting2(tk_camma);
	htok=tok;
	hstok=itok;
	hbuf=bufrm;
	bufrm=NULL;
	hstr=strinf;
	strinf.bufstr=NULL;
	nextexpecting2(tk_camma);
	if(tok!=tk_number)numexpected(3);
	switch(htok){
		case tk_mmxreg:
			outword(0x700F);
			op(rm_mod11+num1+hstok.number*8);
			break;
		case tk_longvar:
		case tk_dwordvar:
		case tk_floatvar:
			i+=2;
		case tk_wordvar:
		case tk_intvar:
			i++;
		case tk_charvar:
		case tk_bytevar:
			CheckAllMassiv(hbuf,i,&hstr);
			KillVar(hstok.name);
			outseg(&hstok,3);
			outword(0x700F);
			op(hstok.rm+num1*8);
			outaddress(&hstok);
			break;
		default:
			mmxregordwordexpected(2);
			break;
	}
	op(doconstdwordmath());
}

void xmminstr(int type,int sec,int op1,int op2)
{
int num1,i=1;
	nexttok();
	if(tok!=op1){
		if(op1==tk_mmxreg)mmxregexpected(1);
		else if(op1==tk_reg32)reg32expected(1);
		else xmmregexpected(1);
	}
	if(tok==tk_reg32)ClearReg(itok.number);
	num1=itok.number;
	nextexpecting2(tk_camma);
	switch ( tok ) {
		case tk_reg32:
		case tk_mmxreg:
		case tk_xmmreg:
			if(tok!=op2){
				if(op2==tk_mmxreg)mmxregexpected(2);
				else if(op2==tk_reg32)reg32expected(2);
				else xmmregexpected(2);
			}
			if(sec)op(sec);
			op(0x0F);
			op(type);
			op(rm_mod11+itok.number+num1*8);
			break;
		case tk_qwordvar:
			i+=4;
		case tk_longvar:
		case tk_dwordvar:
		case tk_floatvar:
			i+=2;
		case tk_wordvar:
		case tk_intvar:
			i++;
		case tk_charvar:
		case tk_bytevar:
			CheckAllMassiv(bufrm,i,&strinf);
			outseg(&itok,sec==0?3:4);
			if(sec)op(sec);
			op(0x0F);
			op(type);
			op(itok.rm+num1*8);
			outaddress(&itok);
			break;
		default:
			if(op2==tk_mmxreg)mmxregordwordexpected(2);
			else if(op2==tk_reg32)reg32orword(2);
			else xmmregorvarexpected(2);
			break;
	}
}

void xmm3instr(int type,int sec)	//xmm,xmm/mem,i8
{
int num1,i=1,htok;
ITOK hstok;
char *hbuf;
SINFO hstr;
	nexttok();
	if(tok!=tk_xmmreg)xmmregexpected(1);
	num1=itok.number;
	nextexpecting2(tk_camma);
	htok=tok;
	hstok=itok;
	hbuf=bufrm;
	bufrm=NULL;
	hstr=strinf;
	strinf.bufstr=NULL;
	nextexpecting2(tk_camma);
	if(tok!=tk_number)numexpected(3);
	switch(htok){
		case tk_xmmreg:
			if(sec)op(sec);
			op(0x0F);
			op(type);
			op(rm_mod11+hstok.number+num1*8);
			break;
		case tk_qwordvar:
			i+=4;
		case tk_longvar:
		case tk_dwordvar:
		case tk_floatvar:
			i+=2;
		case tk_wordvar:
		case tk_intvar:
			i++;
		case tk_charvar:
		case tk_bytevar:
			CheckAllMassiv(hbuf,i,&hstr);
			outseg(&hstok,sec==0?3:4);
			if(sec)op(sec);
			op(0x0F);
			op(type);
			op(hstok.rm+num1*8);
			outaddress(&hstok);
			break;
		default:
			xmmregorvarexpected(2);
			break;
	}
	op(doconstdwordmath());
}

void xmm2xmm(int code,int code2,int type)
{
int num;
	nexttok();
	if(tok!=type){
		if(type==tk_mmxreg)mmxregexpected(1);
		else if(type==tk_reg32)reg32expected(1);
		else xmmregexpected(1);
	}
	if(tok==tk_reg32)ClearReg(itok.number);
	num=itok.number;
	nextexpecting2(tk_camma);
	if(tok!=tk_xmmreg)xmmregexpected(2);
	if(code2)op(code2);
	op(0x0F);
	op(code);
	op(rm_mod11+itok.number+num*8);
}

void movxmm3(int code,int code2,int type)
{
int i=1,htok;
ITOK hstok;
char *hbuf;
SINFO hstr;
	nexttok();
	htok=tok;
	hstok=itok;
	hbuf=bufrm;
	bufrm=NULL;
	hstr=strinf;
	strinf.bufstr=NULL;
	nextexpecting2(tk_camma);
	if(tok!=type){
		if(type==tk_mmxreg)mmxregexpected(2);
		else if(type==tk_xmmreg)xmmregexpected(2);
		else reg32expected(2);
	}
	switch(htok){
		case tk_qwordvar:
			i+=4;
		case tk_longvar:
		case tk_dwordvar:
		case tk_floatvar:
			i+=2;
		case tk_wordvar:
		case tk_intvar:
			i+=1;
		case tk_charvar:
		case tk_bytevar:
			CheckAllMassiv(hbuf,i,&hstr);
			KillVar(hstok.name);
			outseg(&hstok,code2==0?3:4);
			if(code2)op(code2);
			op(0x0F);
			op(code);
			op(hstok.rm+itok.number*8);
			outaddress(&hstok);
			break;
		default: varexpected(1);
	}
}

void movxmm4(int code,int code2)
{
int i=1;
int num;
	nexttok();
	num=itok.number;
	if(tok!=tk_xmmreg)xmmregexpected(1);
	nextexpecting2(tk_camma);
	switch(tok){
		case tk_qwordvar:
			i+=4;
		case tk_longvar:
		case tk_dwordvar:
		case tk_floatvar:
			i+=2;
		case tk_wordvar:
		case tk_intvar:
			i+=1;
		case tk_charvar:
		case tk_bytevar:
			CheckAllMassiv(bufrm,i,&strinf);
			outseg(&itok,(code2==0?3:4));
			if(code2)op(code2);
			op(0x0F);
			op(code);
			op(itok.rm+num*8);
			outaddress(&itok);
			break;
		default: varexpected(2);
	}
}

void movxmm(int code,int code2,int addc)
{
int i=1,htok;
ITOK hstok;
char *hbuf;
SINFO hstr;
	nexttok();
	htok=tok;
	hstok=itok;
	hbuf=bufrm;
	bufrm=NULL;
	hstr=strinf;
	strinf.bufstr=NULL;
	nextexpecting2(tk_camma);
	switch(htok){
		case tk_xmmreg:
			switch(tok){
				case tk_xmmreg:
					if(code2)op(code2);
					op(0x0F);
					op(code);
					op(rm_mod11+itok.number+hstok.number*8);
					break;
				case tk_qwordvar:
					i+=4;
				case tk_longvar:
				case tk_dwordvar:
				case tk_floatvar:
					i+=2;
				case tk_wordvar:
				case tk_intvar:
					i++;
				case tk_charvar:
				case tk_bytevar:
					CheckAllMassiv(bufrm,i,&strinf);
					outseg(&itok,(code2==0?3:4));
					if(code2)op(code2);
					op(0x0F);
					op(code);
					op(itok.rm+hstok.number*8);
					outaddress(&itok);
					break;
				default:
					xmmregorvarexpected(2);
					break;
			}
			break;
		case tk_qwordvar:
			i+=4;
		case tk_longvar:
		case tk_dwordvar:
		case tk_floatvar:
			i+=2;
		case tk_wordvar:
		case tk_intvar:
			i++;
		case tk_charvar:
		case tk_bytevar:
			if(tok!=tk_xmmreg)xmmregexpected(2);
			CheckAllMassiv(hbuf,i,&hstr);
			KillVar(hstok.name);
			outseg(&hstok,code2==0?3:4);
			if(code2)op(code2);
			op(0x0F);
			op(code+addc);
			op(hstok.rm+itok.number*8);
			outaddress(&hstok);
			break;
		default:
			xmmregorvarexpected(1);
			break;
	}
}

void movxmm2(int code,int code2)
{
int i=1,htok;
ITOK hstok;
char *hbuf;
SINFO hstr;
	nexttok();
	htok=tok;
	hstok=itok;
	hbuf=bufrm;
	bufrm=NULL;
	hstr=strinf;
	strinf.bufstr=NULL;
	nextexpecting2(tk_camma);
	switch(htok){
		case tk_xmmreg:
			switch(tok){
				case tk_qwordvar:
					i+=4;
				case tk_longvar:
				case tk_dwordvar:
				case tk_floatvar:
					i+=2;
				case tk_wordvar:
				case tk_intvar:
					i++;
				case tk_charvar:
				case tk_bytevar:
					CheckAllMassiv(bufrm,i,&strinf);
					outseg(&itok,(code2==0?3:4));
					if(code2)op(code2);
					op(0x0F);
					op(code);
					op(itok.rm+hstok.number*8);
					outaddress(&itok);
					break;
				default:
					datatype_expected(2);
					break;
			}
			break;
		case tk_qwordvar:
			i+=4;
		case tk_longvar:
		case tk_dwordvar:
		case tk_floatvar:
			i+=2;
		case tk_wordvar:
		case tk_intvar:
			i++;
		case tk_charvar:
		case tk_bytevar:
			if(tok!=tk_xmmreg)xmmregexpected(2);
			CheckAllMassiv(hbuf,i,&hstr);
			KillVar(hstok.name);
			outseg(&hstok,code2==0?3:4);
			if(code2)op(code2);
			op(0x0F);
			op(code+1);
			op(hstok.rm+itok.number*8);
			outaddress(&hstok);
			break;
		default:
			xmmregorvarexpected(1);
			break;
	}
}

void shiftxmm(int rm)	//rxmm,i8
{
int num;
	nexttok();
	if(tok!=tk_xmmreg)xmmregexpected(1);
	num=itok.number;
	nextexpecting2(tk_camma);
	if(tok!=tk_number)numexpected(2);
	op(0x66);
	op(0x0F);
	op(0x73);
	op(rm*8+num+rm_mod11);
	op(doconstdwordmath());
}

void DDDW(int faradd)
{
int htok,i;
char name[IDLENGTH];
unsigned long hnumber;
	if(dbg&2)AddDataNullLine(faradd==0?2:4);
	dbgact++;
	asmparam=FALSE;
	do{
		i=1;
		nexttok();
		CheckIP();
		htok=tok;
		switch(tok){
			case tk_undefofs:
				tok=tk_number;
				strcpy(name,itok.name);
			case tk_number:
				hnumber=doconstdwordmath();
				if(tok==tk_id&&strcmp((char *)string,"dup")==0){
					i=hnumber;
					nexttok();
					CheckMinusNum();
					htok=tok;
					if(tok==tk_undefofs){
						tok=tk_number;
						strcpy(name,itok.name);
					}
					if(tok==tk_number)hnumber=doconstdwordmath();
					else numexpected();
				}
				for(;i!=0;i--){
				 	if(postnumflag&f_reloc)AddReloc();
				 	if(htok==tk_undefofs)AddUndefOff(2,name);
					if(faradd)outdword(hnumber);
					else outword(hnumber);
				}
				break;
			case tk_postnumber:
				setwordpost(&itok);
				if(faradd)outdword(itok.number);
				else outword(itok.number);
				nexttok();
				break;
			default:
				numexpected();
				nexttok();
				break;
		}
	}while(tok==tk_camma);
	dbgact--;
}

void AADM(int code)
{
	op(code);
	itok.number=10;
	if(tok2==tk_number)nexttok();
	op(itok.number);	//AAD
	ClearReg(AX);
}

int Push(ITOK *wtok)
{
int i;
int razr;
ITOK hstok;
unsigned long hnumber;
int possiblecpu=0;
int next=1;
	i=(am32+1)*2;
	razr=r16;
	switch(tok){
		case tk_id:
		case tk_ID:
			if((stricmp("dword",(char *)string)==0)||(stricmp("long",(char *)string)==0))i=r32;
			else if((stricmp("word",(char *)string)==0)||(stricmp("int",(char *)string)==0))i=r16;
			else return FALSE;
			goto swpushpar;
		case tk_dword:
		case tk_long:
			i=r32;
			goto swpushpar;
		case tk_int:
		case tk_word:
			i=r16;
swpushpar:
			nexttok();
			CheckMinusNum();
			if(tok==tk_number)goto pushnum;
			if(tok==tk_undefofs)goto pushundef;
			return FALSE;
		case tk_reg32:
			possiblecpu=3;
		case tk_reg:
			op66(tok==tk_reg?r16:r32);
			op(0x50+(unsigned int)itok.number);
			break;
		case tk_seg:
			PushSeg((unsigned int)itok.number);
			break;
		case tk_undefofs:
pushundef:
			hstok=itok;
			tok=tk_number;
			hnumber=doconstlongmath();
			op66(i);	////
			op(0x68);
		 	if(postnumflag&f_reloc)AddReloc();
		 	AddUndefOff(2,hstok.name);
			if(i==r16)outword(hnumber);
			else outdword(hnumber);
			possiblecpu=(unsigned char)(i==r16?2:3);
			next=0;
			break;
		case tk_minus:
			if(tok2!=tk_number)return FALSE;
		case tk_number:
pushnum:
			hnumber=doconstlongmath();
			if(i==r16)hnumber&=0xffff;
			else hnumber&=0xffffffff;
			if(wtok&&(postnumflag&f_reloc)==0)Const2Var(wtok,hnumber,i==r16?tk_word:tk_dword);
			op66(i);
			if((postnumflag&f_reloc)==0&&short_ok(hnumber,i/2-1)){
				op(0x6A);
				op(hnumber);
			}
			else{
				op(0x68);
				if((postnumflag&f_reloc)!=0)AddReloc();
				if(i==r16)outword(hnumber);
				else outdword(hnumber);
			}
			possiblecpu=(unsigned char)(i==r16?2:3);
			next=0;
			break;
		case tk_dwordvar:
		case tk_longvar:
			CheckAllMassiv(bufrm,4,&strinf);
			possiblecpu=3;
			razr=r32;
			goto push;
		case tk_wordvar:
		case tk_intvar:
			CheckAllMassiv(bufrm,2,&strinf);
push:
			op66(razr);
			outseg(&itok,2);
			op(0xFF);	op(0x30+itok.rm);
			outaddress(&itok);
			break;
		case tk_postnumber:
			op(0x68);
			(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
			if(am32==FALSE)outword((unsigned int)itok.number);
			else outdword(itok.number);
			break;
		case tk_string:
			op66(i);
			op(0x68);
			if(am32==FALSE)outword(addpoststring());
			else outdword(addpoststring());
			break;
		default:
			return FALSE;
	}
	if(cpu<possiblecpu)cpu=possiblecpu;
	asmparam=FALSE;
	if(next)nexttok();
	return i;
}
/* end of TOKR.C */