// Copyright Cheat Engine. All Rights Reserved.

unit autoassembler;

{$MODE Delphi}

interface


{$ifdef jni}
uses unixporthelper, Assemblerunit, classes, symbolhandler, sysutils,
     NewKernelHandler, ProcessHandlerUnit, commonTypeDefs;
{$else}



uses
   {$ifdef darwin}
   macport, math,
   {$endif}
   {$ifdef windows}
   jwawindows, windows,
   {$endif}
   Assemblerunit, classes, LCLIntf,symbolhandler, symbolhandlerstructs,
   sysutils,dialogs,controls, CEFuncProc, NewKernelHandler ,plugin,
   ProcessHandlerUnit, lua, lualib, lauxlib, LuaClass, commonTypeDefs, OpenSave,
   SymbolListHandler, tcclib,
   betterControls;


{$endif}

type
  TDisableInfo=class
  private
  public
    allocs: TCEAllocArray;
    exceptions:TCEExceptionListArray;
    registeredsymbols: tstringlist;
    ccodesymbols: TSymbolListHandler;
    sourcecodeinfo: TSourceCodeInfo;
    donotfreeccodedata: boolean;

    allsymbols: tstringlist; //filled at the end with all known symbols (allocs, labels, kallocs, aobscan results, defines that are addresses, etc...)

    constructor create;
    destructor destroy; override;
  end;

  TMemoryrecord=pointer;


function getenableanddisablepos(code:tstrings;var enablepos,disablepos: integer): boolean;
procedure getEnableOrDisableScript(code: TStrings; newscript: tstrings; enablescript: boolean);
function autoassemble(code: tstrings;popupmessages: boolean):boolean; overload;
function autoassemble(code: Tstrings; popupmessages,enable,syntaxcheckonly, targetself: boolean; disableinfo: TDisableInfo=nil; memrec: TMemoryrecord=nil): boolean; overload;

type TAutoAssemblerPrologue=procedure(code: TStrings; syntaxcheckonly: boolean) of object;
type TAutoAssemblerCallback=function(parameters: string; syntaxcheckonly: boolean): string of object;
type TRegisteredAutoAssemblerCommand=class
  command: string;
  callback: TAutoAssemblerCallback;
end;

type EAutoAssembler=class(exception);

procedure RegisterAutoAssemblerCommand(command: string; callback: TAutoAssemblerCallback);
procedure UnregisterAutoAssemblerCommand(command: string);
function registerAutoAssemblerPrologue(m: TAutoAssemblerPrologue; postAOBSCAN: boolean=false): integer;
procedure unregisterAutoAssemblerPrologue(id: integer);

var oldaamessage: boolean;


function autoassemble2(code: tstrings;popupmessages: boolean;syntaxcheckonly:boolean; targetself: boolean; disableinfo: TDisableInfo=nil; memrec: TMemoryRecord=nil):boolean;

implementation

{$ifdef jni}
uses strutils, memscan, disassembler, networkInterface, networkInterfaceApi,
     Parsers, Globals, memoryQuery,types;
{$else}


uses simpleaobscanner, StrUtils, LuaHandler, memscan, disassembler, networkInterface,
     networkInterfaceApi, LuaCaller, SynHighlighterAA, Parsers, Globals, memoryQuery,
     MemoryBrowserFormUnit, MemoryRecordUnit{$ifdef windows}, vmxfunctions{$endif}, autoassemblerexeptionhandler,
     UnexpectedExceptionsHelper, types, autoassemblercode, System.UITypes,
     frmautoinjectunit, DebuggerInterfaceAPIWrapper, GDBServerDebuggerInterface;
{$endif}


resourcestring
  rsForwardJumpWithNoLabelDefined = 'Forward jump with no label defined';
  rsThereIsCodeDefinedWithoutSpecifyingTheAddressItBel = 'There is code defined without specifying the address it belongs to';
  rsIsNotAValidBytestring = '%s is not a valid bytestring';
  rsTheBytesAtAreNotWhatWasExpected = 'The bytes at %s are not what was expected';
  rsTheMemoryAtCanNotBeRead = 'The memory at +%s can not be read';
  rsWrongSyntaxASSERTAddress1122335566 = 'Wrong syntax. ASSERT(address,11 22 33 ** 55 66)';
  rsIsNotAValidSize = '%s is not a valid size';
  rsWrongSyntaxGLOBALALLOCNameSize = 'Wrong syntax. GLOBALALLOC(name,size)';
  rsCouldNotBeFound = '%s could not be found';
  rsWrongSyntaxIncludeFilenameCea = 'Wrong syntax. Include(filename.cea)';
  rsWrongSyntaxCreateThreadAddress = 'Wrong syntax. CreateThread(address)';
  rsCouldNotBeInjected = '%s could not be injected';
  rsWrongSyntaxLoadLibraryFilename = 'Wrong syntax. LoadLibrary(filename)';
  rsWrongSyntaxLuaCall = 'Wrong Syntax. LuaCall(luacommand)';
  rsInvalidAddressForReadMem = 'Invalid address for ReadMem';
  rsInvalidSizeForReadMem = 'Invalid size for ReadMem';
  rsTheMemoryAtCouldNotBeFullyRead = 'The memory at %s could not be fully read';
  rsWrongSyntaxReadMemAddressSize = 'Wrong syntax. ReadMem(address,size)';
  rsTheFileDoesNotExist = 'The file %s does not exist';
  rsWrongSyntaxLoadBinaryAddressFilename = 'Wrong syntax. LoadBinary(address,filename)';
  rsWrongSyntaxReAssemble = 'Wrong syntax. Reassemble(address)';
  rsSyntaxError = 'Syntax error';
  rsTheArrayOfByteCouldNotBeFound = 'The array of byte ''%s'' could not be found';
  rsWrongSyntaxAOBSCANName11223355 = 'Wrong syntax. AOBSCAN(name,11 22 33 ** 55)';
  rsWrongSyntaxAOBSCANMODULEName11223355 = 'Wrong syntax. AOBSCANMODULE(name, module, 11 22 33 ** 55)';
  rsWrongSyntaxAOBSCANREGION = 'Wrong syntax. AOBSCANREGION(name, startaddress, stopaddress, 11 22 33 ** 55)';


  rsDefineAlreadyDefined = 'Define %s already defined';
  rsWrongSyntaxDEFINENameWhatever = 'Wrong syntax. DEFINE(name,whatever)';
  rsSyntaxErrorFullAccessAddressSize = 'Syntax error. FullAccess(address,size)';
  rsIsNotAValidIdentifier = '%s is not a valid identifier';
  rsIsBeingRedeclared = '%s is being redeclared';
  rsLabelIsBeingDefinedMoreThanOnce = 'label %s is being defined more than once';
  rsLabelIsNotDefinedInTheScript = 'label %s is not defined in the script';
  rsTheIdentifierHasAlreadyBeenDeclared = 'The identifier %s has already been declared';
  rsWrongSyntaxALLOCIdentifierSizeinbytes = 'Wrong syntax. ALLOC(identifier,sizeinbytes)';
  rsNeedToUseKernelmodeReadWriteprocessmemory = 'You need to use kernelmode read/writeprocessmemory if you want to use KALLOC';
  rsSorryButWithoutTheDriverKALLOCWillNotFunction = 'Sorry, but without the driver KALLOC will not function';
  rsWrongSyntaxKallocIdentifierSizeinbytes = 'Wrong syntax. kalloc(identifier,sizeinbytes)';
  rsThisAddressSpecifierIsNotValid = 'This address specifier is not valid';
  rsThisInstructionCanTBeCompiled = 'This instruction can''t be compiled';
  rsErrorInLine = 'Error in line %s (%s) :%s';
  rsWasSupposedToBeAddedToTheSymbollistButItIsnTDeclar = '%s was supposed to be added to the symbollist, but it isn''t declared';
  rsTheAddressInCreatethreadIsNotValid = 'The address in createthread(%s) is not valid';
  rsTheAddressInCreatethreadAndWaitIsNotValid = 'The address in createthreadandwait(%s) is not valid';
  rsTheAddressInLoadbinaryIsNotValid = 'The address in loadbinary(%s,%s) is not valid';
  rsThisCodeCanBeInjectedAreYouSure = 'This code can be injected. Are you sure?';
  rsFailureToAllocateMemory = 'Failure to allocate memory';
  rsNotAllInstructionsCouldBeInjected = 'Not all instructions could be injected';
  rsTheFollowingKernelAddressesWhereAllocated = 'The following kernel addresses where allocated';
  rsTheCodeInjectionWasSuccessfull = 'The code injection was successfull';
  rsYouCanOnlyHaveOneEnableSection = 'You can only have one enable section';
  rsYouCanOnlyHaveOneDisableSection = 'You can only have one disable section';
  rsYouHavnTSpecifiedAEnableSection = 'You havn''t specified a enable section';
  rsYouHavnTSpecifiedADisableSection = 'You havn''t specified a disable section';
  rsWrongSyntaxSHAREDALLOCNameSize = 'Wrong syntax. SHAREDALLOC(name,size)';
  rsAAErrorInTheStructureDefinitionOf = 'Error in the structure definition of %s at line %d';
  rsAAIsAReservedWord = '%s is a reserved word';
  rsAANoIdeaWhatXis = 'No idea what %s is';
  rsAANoEndFound = 'No end found';
  rsAATheArrayOfByteNamed = 'The array of byte named %s could not be found';
  rsXCouldNotBeFound = '%s could not be found';
  rsAAErrorWhileSacnningForAobs = 'Error while scanning for AOB''s : ';
  rsAAError = 'Error: ';
  rsAAModuleNotFound = 'module not found:';
  rsAALuaErrorInTheScriptAtLine = 'Lua error in the script at line ';
  rsGoTo = 'Go to ';
  rsMissingExcept = 'The {$TRY} at line %d has no matching {$EXCEPT}';
  rsNoPreferedRangeAllocWarning = 'None of the ALLOC statements specify a '
    +'prefered address.  Did you take into account that the JMP instruction is'
    +' going to be 14 bytes long?';
  rsFailureAlloc = 'Failure allocating memory near %.8x for variable named %s';
  rsFailureGettingOriginalInstruction = 'Failure getting the instruction at %x';
  rsNearbyAllocationError = 'Nearby allocation error';
  rsNearbyAllocationErrorMessageQuestion = 'This script uses nearby allocation'
    +' but it is impossible to allocate nearby %x. Please rewrite the script '
    +'to function without nearby allocation.  Try executing the script anyhow '
    +'and allocate on a region outside reach of 2GB? (The target will crash if'
    +' the script was not designed with this failure in mind)';
  rsFailureAssembling = 'Failure assembling %s at %.8x';

//type
//  TregisteredAutoAssemblerCommands =  TFPGList<TRegisteredAutoAssemblerCommand>;

type
  TAutoAssemblerPrologues=array of TAutoAssemblerPrologue;
  PAutoAssemblerPrologues=^TAutoAssemblerPrologues;
var
  registeredAutoAssemblerCommands: TList;

  AutoAssemblerPrologues: TAutoAssemblerPrologues;
  AutoAssemblerProloguesPostAOBSCAN: TAutoAssemblerPrologues;


type
  TAllocWarn=class
  public
    preferedaddress: ptruint;
    procedure AllocFailedQuestion;
    procedure warn;
  end;


procedure TAllocWarn.AllocFailedQuestion;
var r:TModalResult;
begin
  r:=MessageDlg(rsNearbyAllocationError, Format(
    rsNearbyAllocationErrorMessageQuestion, [preferedaddress]),
    mtError, [mbyes, mbno, mbYesToAll, mbNoToAll], 0);
  NearbyAllocationFailureFatal:=r in [mrNo,mrNoToAll];

  if r in [mrYesToAll, mrNoToAll] then
    WarnOnNearbyAllocationFailure:=false;
end;

procedure TAllocWarn.warn;
begin
  if MainThreadID=GetCurrentThreadId then
    AllocFailedQuestion
  else
    tthread.Synchronize(nil, AllocFailedQuestion);
end;



function registerAutoAssemblerPrologue(m: TAutoAssemblerPrologue; postAOBSCAN: boolean=false): integer;
var i: integer;
    prologues: PAutoAssemblerPrologues;
begin
  if postAOBSCAN then prologues:=@AutoAssemblerProloguesPostAOBSCAN
                 else prologues:=@AutoAssemblerPrologues;
  for i:=0 to length(prologues^)-1 do
  begin
    if assigned(prologues^[i])=false then
    begin
      prologues^[i]:=m;
      result:=i+1;

      if postAOBSCAN then
        result:=-result;

      exit;
    end
  end;

  result:=length(prologues^)+1;  //first one is id 1
  setlength(prologues^, result);
  prologues^[result-1]:=m;

  if postAOBSCAN then
    result:=-result; //first one is id -1
end;

procedure unregisterAutoAssemblerPrologue(id: integer);
var
  prologues: PAutoAssemblerPrologues;
begin
  if id=0 then exit; //does not exist

  if id<0 then
  begin
    prologues:=@AutoAssemblerProloguesPostAOBSCAN;
    id:=-id;
  end
  else
    prologues:=@AutoAssemblerPrologues;

  if id<=length(prologues^) then
  begin
    {$ifndef jni}
    CleanupLuaCall(TMethod(prologues^[id-1]));
    {$endif}
    prologues^[id-1]:=nil;
  end;
end;

procedure RegisterAutoAssemblerCommand(command: string; callback: TAutoAssemblerCallback);
var i: integer;
    c:TRegisteredAutoAssemblerCommand;
begin
  {$ifndef jni}
  if registeredAutoAssemblerCommands=nil then
    registeredAutoAssemblerCommands:=TList.Create;

  UnregisterAutoAssemblerCommand(command);

  command:=uppercase(command);
  c:=TRegisteredAutoAssemblerCommand.create;
  c.command:=command;
  c.callback:=callback;
  registeredAutoAssemblerCommands.Add(c);

  aa_AddExtraCommand(pchar(command));
  {$endif}
end;

procedure UnregisterAutoAssemblerCommand(command: string);
var i,j: integer;
    c:TRegisteredAutoAssemblerCommand;
begin
{$ifndef jni}
  command:=uppercase(command);
  i:=0;
  while i<registeredAutoAssemblerCommands.count do
  begin
    if TRegisteredAutoAssemblerCommand(registeredAutoAssemblerCommands[i]).command=command then
    begin
      c:=registeredAutoAssemblerCommands[i];
      CleanupLuaCall(tmethod(c.callback));
      registeredAutoAssemblerCommands.Delete(i);

      c.free;
    end
    else
      inc(i);
  end;

  aa_RemoveExtraCommand(pchar(command));
{$endif jni}
end;



//----------------------------

destructor TDisableInfo.destroy;
begin
  setlength(Allocs,0);
  setlength(exceptions,0);
  freeandnil(registeredsymbols);
  if (ccodesymbols<>nil) and (donotfreeccodedata=false) then
    freeandnil(ccodesymbols);

  if (sourcecodeinfo<>nil) and (donotfreeccodedata=false) then
    freeandnil(sourcecodeinfo);
end;

constructor TDisableInfo.create;
begin
  setlength(Allocs,0);
  setlength(exceptions,0);

  registeredsymbols:=tstringlist.create;
  registeredsymbols.CaseSensitive:=false;
  registeredsymbols.Duplicates:=dupIgnore;

  ccodesymbols:=TSymbolListHandler.create;
  ccodesymbols.PID:=processid;

  allsymbols:=TStringList.create;
  allsymbols.CaseSensitive:=false;
  allsymbols.Duplicates:=dupIgnore;
end;

function lastChanceAllocPrefered(prefered: ptruint; size: integer; protection:dword): ptruint;
var
  starttime: ptruint;
  distance: qword;
  address: ptruint;
  count: integer;
begin
  if SystemSupportsWritableExecutableMemory=false then
    protection:=PAGE_READWRITE;

  starttime:=gettickcount64;

  address:=0;
  distance:=0;
  count:=0;
  if prefered mod systeminfo.dwAllocationGranularity>0 then
    prefered:=prefered-(prefered mod systeminfo.dwAllocationGranularity);


  while (address=0) and ((count<10) or (gettickcount64<starttime+10000)) and (distance<$80000000) do
  begin
    address:=ptrUint(virtualallocex(processhandle,pointer(prefered+distance),size, MEM_RESERVE or MEM_COMMIT,protection));
    if (address=0) and (distance>0) then
      address:=ptrUint(virtualallocex(processhandle,pointer(prefered-distance),size, MEM_RESERVE or MEM_COMMIT,protection));

    if address=0 then
      inc(distance, systeminfo.dwAllocationGranularity);

    inc(count);
  end;

  result:=address;
end;

procedure tokenize(input: string; tokens: tstringlist);
var i: integer;
    a: integer;
    inquote: boolean=false;
    inquote2: boolean=false;
begin

  tokens.clear;
  a:=-1;
  for i:=1 to length(input) do
  begin
    if inquote and (input[i]<>'''') then continue;
    if inquote2 and (input[i]<>'"') then continue;

    case input[i] of
      'a'..'z','A'..'Z','0'..'9','.', '_','#','@', #128..#255: if a=-1 then a:=i;
      else
      begin
        if (input[i]='''') then
        begin
          if inquote then
          begin
            if a<>-1 then
              tokens.AddObject(copy(input,a,i-a),tobject(a));

            a:=-1;
            inquote:=false;
          end
          else
          begin
            inquote:=true;
            a:=i;
          end;

          continue;
        end;

        if (input[i]='"') then
        begin
          if inquote2 then
          begin
            if a<>-1 then
              tokens.AddObject(copy(input,a,i-a),tobject(a));

            a:=-1;
            inquote2:=false;
          end
          else
          begin
            inquote2:=true;
            a:=i;
          end;

          continue;
        end;

        if a<>-1 then
          tokens.AddObject(copy(input,a,i-a),tobject(a));
        a:=-1;
      end;
    end;
  end;

  if a<>-1 then
    tokens.AddObject(copy(input,a,length(input)),tobject(a));
end;

function tokencheck(input,token:string):boolean;
var tokens: tstringlist;
    i: integer;
begin
  tokens:=tstringlist.Create;
  try
    tokenize(input,tokens);
    result:=false;

    for i:=0 to tokens.Count-1 do
      if tokens[i]=token then
      begin
        result:=true;
        break;
      end;
  finally
    tokens.free;
  end;
end;

function replacetoken(input: string;token:string;replacewith:string):string;
var tokens: tstringlist;
    i,j: integer;
begin
  result:=input;
  tokens:=tstringlist.Create;
  try
    tokenize(result,tokens);
    for i:=tokens.Count-1 downto 0 do
      if tokens[i]=token then
      begin
        j:=integer(tokens.Objects[i]);
        result:=copy(result,1,j-1)+replacewith+copy(result,j+length(token),length(result));
      end;

  finally
    tokens.free;
  end;
end;

procedure tokenizeStruct(input: string; tokens: tstringlist);
//a version of tokenize using strutils to split up the strings. (I don't want to replace it yet since it is slightly different, probably better, but let's be safe for now till it's fully tested)
var delims: TSysCharSet;
    i: integer;
begin
  delims:=[' '];

  tokens.clear;
  for i:=1 to WordCount(input, delims) do
    tokens.add(ExtractWord(i, input, delims));

end;

procedure replaceStructWithDefines(code: Tstrings; linenr: integer);
{
parses the structure starting at the given line number.
removes the structure definition from the code
writes a define(xxxx,xxxxx) inplace starting from the linenumber

precondition: linenr is valid and code[linenr] is indeed a STRUCT name line

Structure format:
struct name
  db ?  db ? db ? db ?
  db ? ? ?
  dw ?
  dd ?
  dq ?
  resb 4 resb 4
  resw 4
  resd 2
  resq 1
elementname1:
  db ?
  resw 1
  dw ?
elementname2: dw ?

endstruct

Res is an alternate to the usual "d* ?" but is specifically for no fill  (Res stands for reserve)
Usage res* #  where # is the number of copies.  This is better suited for strings which can not be defined with db ?

when done the name.elementname1 and just elementname1 will be defined at the spot the structure was placed. Subsequent structure definitions can override these defines. Elements may NOT have reserved words as they will get replaced. (like assembler commands)
}


var
  currentOffset: integer;
  structname: string;
  elementname: string;
  i,j,k: integer;
  tokens: Tstringlist;

  elements: tstringlist;
  starttoken: integer;

  bytesize: integer;
  endfound: boolean;
  lastlinenr: integer;
  procedure structError(reason: string='');
  var error: string;
  begin
    error:=format(rsAAErrorInTheStructureDefinitionOf, [structname, lastlinenr+1]);
    if reason<>'' then
      error:=error+' :'+reason
    else
      error:=error+'.';

    raise exception.create(error);
  end;

begin
  lastlinenr:=linenr;
  endfound:=false;
  structname:=trim(copy(code[linenr], 7, length(code[linenr])));

  currentOffset:=0;
  tokens:=tstringlist.create;
  elements:=tstringlist.create;

  for i:=linenr+1 to code.count-1 do
  begin
    lastlinenr:=i;
    tokenizeStruct(code[i], tokens);

    j:=0;

    if tokens.count>0 then
    begin
      //first check if it's a label definition
      if tokens[0][length(tokens[0])]=':' then
      begin
        elementname:=copy(tokens[0], 1, Length(tokens[0])-1);
        if GetOpcodesIndex(elementname)<>-1 then
          structError(format(rsAAIsAReservedWord, [elementname]));

        elements.AddObject(elementname, tobject(currentOffset));

        j:=1;
      end;



      //then check if it's the end of the struct
      if (uppercase(tokens[0])='ENDSTRUCT') or (uppercase(tokens[0])='ENDS') then
      begin
        endfound:=true;
        break; //all done
      end;
    end;


    //if it's neither a label or structure end then it's a size defining token

    while j < tokens.count do
    begin
      tokens[j]:=uppercase(tokens[j]);

      case tokens[j][1] of
        'R':
        begin
          //could be res*
          if (length(tokens[j])=4) and (copy(tokens[j],1,3)='RES') then
          begin
            case tokens[j][4] of
              'B': bytesize:=1;
              'W': bytesize:=2;
              'D': bytesize:=4;
              'Q': bytesize:=8;
              else
                StructError;
            end;
            //now get the count
            inc(j);
            if j>=tokens.count then
              structError;

            try
              inc(currentOffset, bytesize*StrToInt(tokens[j]));
            except
              structerror;
            end;
          end else structerror;
        end;

        'D':
        begin
          //could be d* ?
          if length(tokens[j])=2 then
          begin
            case tokens[j][2] of
              'B': bytesize:=1;
              'W': bytesize:=2;
              'D': bytesize:=4;
              'Q': bytesize:=8;
              else
                StructError;
            end;

            inc(j);
            if j>=tokens.count then
              structError;

            inc(currentOffset, bytesize);

            //check if there are more ?'s after this (in case of dw ? ? ?)
            while j<tokens.count-1 do
            begin
              if tokens[j+1]='?' then  //check from the spot in front
              begin
                inc(currentOffset, bytesize);
                inc(j);
              end
              else
                break; //nope
            end;

          end else structerror;
        end;

        else
          structError(format(rsAANoIdeaWhatXis, [tokens[j]])); //we already dealth with labels, so this is wrong
      end;


      inc(j); //next token
    end;


  end;

  if endfound=false then
    structerror(rsAANoEndFound);

  //the elements have been filled in, delete the structure (between linenr and lastlinenr) and inject define(element,offset) and define(structname.element,offset)
  for i:=lastlinenr downto linenr do
    code.Delete(i);

  for i:=0 to elements.count-1 do
  begin
    code.Insert(linenr,'define('+elements[i]+','+inttohex(ptruint(elements.objects[i]),1)+')');
    code.Insert(linenr,'define('+structname+'.'+elements[i]+','+inttohex(ptruint(elements.objects[i]),1)+')');
  end;


  code.insert(linenr, 'define('+structname+'_size,'+inttohex(currentOffset,1)+')');



  tokens.Free;
  elements.free;



end;


procedure getPotentialLabels(code: Tstrings; labels: TStrings);
//parse the script for xxxx: lines and store them in labels
//this list gets used when it's about to error out on an undefined symbol, and if found in here, add it as a label

//pre: called after comments are removed
var
  i: integer;
  currentline: string;
  a: int64;
begin
  for i:=0 to code.count-1 do
  begin
    currentline:=trim(code[i]);
    if (currentline<>'') and (currentline[length(currentline)]=':') then
    begin
      if (pos('+', currentline)=0) and (pos('.', currentline)=0) then
      begin
        currentline:=copy(currentline,1,length(currentline)-1);
        if trystrtoint64('$'+currentline, a)=false then
          labels.add(currentline);
      end;
    end;
  end;
end;

procedure removecomments(code: tstrings);
var i,j: integer;
    currentline: string;
    instring: boolean;
    incomment: boolean;
    bracecomment: boolean;
begin
  //remove comments


  instring:=false;
  incomment:=false;
  bracecomment:=false;
  for i:=0 to code.count-1 do
  begin
    currentline:=code[i];
    instring:=false; //ce doesn't do multiline strings

    for j:=1 to length(currentline) do
    begin
      if incomment then
      begin


        //inside a comment, remove everything till a } is encountered
        if (bracecomment and ((currentline[j]='}') and (processhandler.SystemArchitecture<>archArm))) or
           ((not bracecomment) and (currentline[j]='*') and (j<length(currentline)) and (currentline[j+1]='/')) then
        begin
          incomment:=false; //and continue parsing the code...

          if (not bracecomment) then
            currentline[j+1]:=' ';
        end;

        currentline[j]:=' ';
      end
      else
      begin
        if (currentline[j]='''') then instring:=not instring;
        if currentline[j]=#9 then currentline[j]:=' '; //tabs are basicly comments

        if not instring then
        begin
          //not inside a string, so comment markers need to be dealt with
          if (currentline[j]='/') and (j<length(currentline)) and (currentline[j+1]='/') then //- comment (only the rest of the line)
          begin
            //cut off till the end of the line (and might as well jump out now)
            currentline:=copy(currentline,1,j-1);
            break;
          end;

          if ((currentline[j]='{') and (processhandler.SystemArchitecture<>archArm)) or
             ((currentline[j]='/') and (j<length(currentline)) and (currentline[j+1]='*')) then
          begin
            incomment:=true;
            bracecomment:=currentline[j]='{';

            currentline[j]:=' '; //replace from here till the first } with spaces, this goes on for multiple lines
          end;
        end;
      end;
    end;

    code[i]:=trim(currentline);
  end;

end;


procedure unlabeledlabels(code: tstrings);
var i,j: integer;
    lastseenlabel: integer;
    labels: array of string; //sorted in order of definition
    currentline: string;

begin
  //unlabeled label support
  //For those reading the source, PLEASE , try not to code scripts like that
  //the scripts you make look like crap, and are hard to read. (like using goto in a c app)
  //this is just to make one guy happy

  setlength(labels,0);
  i:=0;
  while i<code.count do
  begin
    currentline:=code[i];

    if length(currentline)>1 then
    begin
      if currentline='@@:' then
      begin
        currentline:='RandomLabel'+chr(ord('A')+random(26))+
                 chr(ord('A')+random(26))+
                 chr(ord('A')+random(26))+
                 chr(ord('A')+random(26))+
                 chr(ord('A')+random(26))+
                 chr(ord('A')+random(26))+
                 chr(ord('A')+random(26))+
                 chr(ord('A')+random(26))+
                 chr(ord('A')+random(26))+
                 ':';
        code[i]:=currentline;

        code.Insert(0,'label('+copy(currentline,1,length(currentline)-1)+')');
        inc(i);

        setlength(labels,length(labels)+1);
        labels[length(labels)-1]:=copy(currentline,1,length(currentline)-1);
      end else
      if currentline[length(currentline)]=':' then
      begin
        setlength(labels,length(labels)+1);
        labels[length(labels)-1]:=copy(currentline,1,length(currentline)-1);
      end;
    end;

    inc(i);
  end;

  //all label definitions have been filled in
  //now change @F (forward) and @B (back) to the labels in front and behind
  lastseenlabel:=-1;
  for i:=0 to code.Count-1 do
  begin
    currentline:=code[i];
    if length(currentline)>1 then
    begin
      if currentline[length(currentline)]=':' then
      begin
        //find this in the array
        currentline:=copy(currentline,1,length(currentline)-1);
        for j:=(lastseenlabel+1) to length(labels)-1 do  //lastseenlabel+1 since it is ordered in definition
        begin
          if uppercase(currentline)=uppercase(labels[j]) then
          begin
            lastseenlabel:=j;
            break;
          end;
        end;
        currentline:=currentline+':';
        //lastseenlabel is now updated to the current pos
      end else
      if pos('@f',lowercase(currentline))>0 then  //forward
      begin
        //forward label, so labels[lastseenlabel+1]
        if lastseenlabel+1 >= length(labels) then
          raise exception.Create(rsForwardJumpWithNoLabelDefined);

        currentline:=replacetoken(currentline,'@f',labels[lastseenlabel+1]);
        currentline:=replacetoken(currentline,'@F',labels[lastseenlabel+1]);
      end else
      if pos('@b',lowercase(currentline))>0 then //back
      begin
        //forward label, so labels[lastseenlabel]
        if lastseenlabel=-1 then
          raise exception.Create(rsThereIsCodeDefinedWithoutSpecifyingTheAddressItBel);

        currentline:=replacetoken(currentline,'@b',labels[lastseenlabel]);
        currentline:=replacetoken(currentline,'@B',labels[lastseenlabel]);
      end;
    end;
    code[i]:=currentline;

  end;
end;

function aobscans(code: tstrings; syntaxcheckonly: boolean): boolean;
//Replaces all AOBSCAN lines with DEFINE(NAME,ADDRESS)
type
  TAOBEntry = record
    name: string;
    aobstring: string;
    linenumber: integer;
  end;

  PAOBEntry=^TAOBEntry;

var i,j,k, m: integer;


    aobscanmodules: array of record
      name: string;
      entries: array of TAOBEntry;
      minaddress, maxaddress: ptruint;
      protection: string;
      memscan: TMemScan;
    end;

    a,b,c,d,e: integer;
    currentline: string;
    s1,s2, s3,s4: string;
    testptr: ptruint;

    cpucount: integer;
    threads: integer;
    mi: TModuleInfo;
    aobstrings: string;

    error: boolean;
    errorstring: string;

    aob1, aob2: dword;

    startaddress, stopaddress: ptruint;

  procedure finished(f: integer);
  //cleanup a memscan and fill in the results
  var i,j: integer;
      results: TAddresses;
      aoblist: string;
  begin
    setlength(results,0);
    if length(aobscanmodules[f].entries)=1 then
    begin
      //if only 1 entry a normal aobscan was done, so use GetOnlyOneResult instead
      if aobscanmodules[f].memscan.GetOnlyOneResult(testptr) then
      begin
        setlength(results,1);
        results[0]:=testptr;

        if not InRangeX(results[0], aobscanmodules[f].minaddress, aobscanmodules[f].maxaddress) then
        begin
          raise EAutoAssembler.Create('Invalid result for aob region scan');
        end;
      end;
    end
    else
      aobscanmodules[f].memscan.GetOnlyOneResults(results);

    if length(results)=length(aobscanmodules[f].entries) then
    begin
      for i:=0 to length(aobscanmodules[f].entries)-1 do
      begin
        if results[i]=0 then
        begin
          error:=true;
          errorstring:=format(rsAATheArrayOfByteNamed, [aobscanmodules[f].entries[i].name]);
        end
        else
          code[aobscanmodules[f].entries[i].linenumber]:='DEFINE('+aobscanmodules[f].entries[i].name+', '+inttohex(results[i],8)+')';
      end;
    end
    else
    begin
      error:=true;
      aoblist:='';
      for i:=0 to length(aobscanmodules[f].entries)-1 do
        aoblist:=aoblist+aobscanmodules[f].entries[i].name+' ';

      if aobscanmodules[f].memscan.GetErrorString<>'' then
        errorstring:=rsAAErrorWhileSacnningForAobs+aoblist+#13#10#13#10+rsAAError+aobscanmodules[f].memscan.GetErrorString
      else
        errorstring:=rsAAErrorWhileSacnningForAobs+aoblist+#13#10#13#10+rsAAError+'Not all results found';


    end;

    aobscanmodules[f].memscan.Free;
    aobscanmodules[f].memscan:=nil;

    dec(threads);
  end;

begin
  result:=false;
  error:=false;
  setlength(aobscanmodules,0);


  cpucount:=GetCPUCount;
  threads:=0;

  for i:=0 to code.Count-1 do
  begin
    //AOBSCAN(variable,aobtring)  (works like define)
    currentline:=code[i];

    if uppercase(copy(currentline,1,10))='AOBSCANEX(' then
    begin
      //convert this line from AOBSCANEX(varname,bytestring) to DEFINE(varname,address)
      a:=pos('(',currentline);
      b:=pos(',',currentline);
      c:=pos(')',currentline);

      if (a>0) and (b>0) and (c>0) then
      begin
        s1:=trim(copy(currentline,a+1,b-a-1));
        s2:=trim(copy(currentline,b+1,c-b-1));


        //s1=varname
        //s2=AOBstring
        testPtr:=0;
        if (not syntaxcheckonly) then
        begin

          //find the ' ' module (single space)
          m:=-1;
          for j:=0 to length(aobscanmodules)-1 do
            if aobscanmodules[j].name=' ' then
            begin
              m:=j;
              break;
            end;

          if m=-1 then
          begin
            setlength(aobscanmodules, length(aobscanmodules)+1);
            m:=length(aobscanmodules)-1;

            aobscanmodules[m].name:=' ';
            aobscanmodules[m].minaddress:=0;
            aobscanmodules[m].protection:='*C*W+X'; //don't care about copy on write or writable, but executable must be set

            {$ifdef cpu64}
            if processhandler.is64Bit then
              aobscanmodules[m].maxaddress:=qword($7fffffffffffffff)
            else
            {$endif}
            begin
              if Is64bitOS then
                aobscanmodules[m].maxaddress:=$ffffffff
              else
                aobscanmodules[m].maxaddress:=$7fffffff;
            end;

            aobscanmodules[m].maxaddress:=qword($ffffffffffffffff);
            setlength(aobscanmodules[m].entries,0); //shouldn't be needed, but do it anyhow
          end;

          j:=length(aobscanmodules[m].entries);
          setlength(aobscanmodules[m].entries, j+1);
          aobscanmodules[m].entries[j].name:=s1;
          aobscanmodules[m].entries[j].aobstring:=s2;
          aobscanmodules[m].entries[j].linenumber:=i;
        end
        else
          code[i]:='DEFINE('+s1+', 00000000)';


      end else raise exception.Create(rsWrongSyntaxAOBSCANName11223355);
    end;

    if uppercase(copy(currentline,1,8))='AOBSCAN(' then
    begin
      //convert this line from AOBSCAN(varname,bytestring) to DEFINE(varname,address)
      a:=pos('(',currentline);
      b:=pos(',',currentline);
      c:=pos(')',currentline);

      if (a>0) and (b>0) and (c>0) then
      begin
        s1:=trim(copy(currentline,a+1,b-a-1));
        s2:=trim(copy(currentline,b+1,c-b-1));


        //s1=varname
        //s2=AOBstring
        testPtr:=0;
        if (not syntaxcheckonly) then
        begin

          //find the '' module
          m:=-1;
          for j:=0 to length(aobscanmodules)-1 do
            if aobscanmodules[j].name='' then
            begin
              m:=j;
              break;
            end;

          if m=-1 then
          begin
            setlength(aobscanmodules, length(aobscanmodules)+1);
            m:=length(aobscanmodules)-1;

            aobscanmodules[m].name:='';
            aobscanmodules[m].minaddress:=0;

            {$ifdef cpu64}
            if processhandler.is64Bit then
              aobscanmodules[m].maxaddress:=qword($7fffffffffffffff)
            else
            {$endif}
            begin
              if Is64bitOS then
                aobscanmodules[m].maxaddress:=$ffffffff
              else
                aobscanmodules[m].maxaddress:=$7fffffff;
            end;

            aobscanmodules[m].maxaddress:=qword($ffffffffffffffff);
            setlength(aobscanmodules[m].entries,0); //shouldn't be needed, but do it anyhow
          end;

          j:=length(aobscanmodules[m].entries);
          setlength(aobscanmodules[m].entries, j+1);
          aobscanmodules[m].entries[j].name:=s1;
          aobscanmodules[m].entries[j].aobstring:=s2;
          aobscanmodules[m].entries[j].linenumber:=i;
        end
        else
          code[i]:='DEFINE('+s1+', 00000000)';


      end else raise exception.Create(rsWrongSyntaxAOBSCANName11223355);
    end;

    if uppercase(copy(currentline,1,14))='AOBSCANMODULE(' then //AOBSCANMODULE(varname, modulename, bytestring)
    begin
      a:=pos('(',currentline);
      b:=pos(',',currentline);
      c:=PosEx(',',currentline,b+1);
      d:=pos(')',currentline);

      if d<=a then raise exception.create(rsWrongSyntaxAOBSCANMODULEName11223355);



      if (a>0) and (b>0) and (c>0) then
      begin
        s1:=trim(copy(currentline,a+1,b-a-1));
        s2:=trim(copy(currentline,b+1,c-b-1));
        s3:=trim(copy(currentline,c+1,d-c-1));

        //s1=varname
        //s2=MODULE
        //s3=aob
        testPtr:=0;
        if (not syntaxcheckonly) then
        begin
          //find the s2 module
          m:=-1;
          for j:=0 to length(aobscanmodules)-1 do
            if aobscanmodules[j].name=uppercase(s2) then
            begin
              m:=j;
              break;
            end;

          if m=-1 then
          begin
            setlength(aobscanmodules, length(aobscanmodules)+1);
            m:=length(aobscanmodules)-1;

            aobscanmodules[m].name:=uppercase(s2);
            if symhandler.getmodulebyname(s2, mi) then
            begin
              aobscanmodules[m].minaddress:=mi.baseaddress;
              aobscanmodules[m].maxaddress:=mi.baseaddress+mi.basesize;
            end
            else
            begin
              //modulename not found. Perhaps a symbol was used
              try
                testptr:=symhandler.getAddressFromName(s2);
                if symhandler.getmodulebyaddress(testptr, mi) then
                begin
                  aobscanmodules[m].minaddress:=mi.baseaddress;
                  aobscanmodules[m].maxaddress:=mi.baseaddress+mi.basesize;
                end;
              except
                raise  exception.create(rsAAModuleNotFound+s2);
              end;
            end;

            setlength(aobscanmodules[m].entries,0);
          end;

          j:=length(aobscanmodules[m].entries);
          setlength(aobscanmodules[m].entries, j+1);
          aobscanmodules[m].entries[j].name:=s1;
          aobscanmodules[m].entries[j].aobstring:=s3;
          aobscanmodules[m].entries[j].linenumber:=i;
        end
        else
          code[i]:='DEFINE('+s1+', 00000000)';

      end else raise exception.Create(rsWrongSyntaxAOBSCANMODULEName11223355);
    end;

    if uppercase(copy(currentline,1,14))='AOBSCANREGION(' then //AOBSCANREGION(varname, startaddress, stopaddress, bytestring)
    begin
      a:=pos('(',currentline);
      b:=pos(',',currentline);
      c:=PosEx(',',currentline,b+1);
      d:=PosEx(',',currentline,c+1);
      e:=pos(')',currentline);

      if (d<=a) or (b<=a) or (c<=a) or (d<=a) or (e<=a) then raise exception.create(rsWrongSyntaxAOBSCANREGION);

      s1:=trim(copy(currentline,a+1,b-a-1));
      s2:=trim(copy(currentline,b+1,c-b-1));
      s3:=trim(copy(currentline,c+1,d-c-1));
      s4:=trim(copy(currentline,d+1,e-d-1));

      if (not syntaxcheckonly) then
      begin
        startaddress:=symhandler.getAddressFromName(s2);
        stopaddress:=symhandler.getAddressFromName(s3);

        //see if this region is already being scanned
        m:=-1;
        for j:=0 to length(aobscanmodules)-1 do
        begin
          //exact address only. No widening/appending of the groups is possible (Users may want to scan for 00 00 in a 16 byte region)
          if (startaddress=aobscanmodules[j].minaddress) and (stopaddress=aobscanmodules[j].maxaddress) then
          begin
            m:=j;
            break;
          end;
        end;

        if m=-1 then
        begin
          setlength(aobscanmodules, length(aobscanmodules)+1);
          m:=length(aobscanmodules)-1;
          aobscanmodules[m].name:='<REGION>';
          aobscanmodules[m].minaddress:=startaddress;
          aobscanmodules[m].maxaddress:=stopaddress;
          setlength(aobscanmodules[m].entries,0);
        end;

        j:=length(aobscanmodules[m].entries);
        setlength(aobscanmodules[m].entries, j+1);
        aobscanmodules[m].entries[j].name:=s1;
        aobscanmodules[m].entries[j].aobstring:=s4;
        aobscanmodules[m].entries[j].linenumber:=i;
      end
      else
        code[i]:='DEFINE('+s1+', 00000000)';

    end;
  end;
  //do simultaneous scans for the selected modules

  if length(aobscanmodules)>0 then
    result:=true; //script uses aobscan

  for i:=0 to length(aobscanmodules)-1 do
  begin

      //wait for one to finish
    j:=0;
    while threads>=cpucount do
    begin
      if (aobscanmodules[j].memscan<>nil) and (aobscanmodules[j].memscan.waittilldone(50)) then
      begin
        finished(j);
        break;
      end;

      j:=(j+1) mod i;
    end;

    inc(threads);
    aobscanmodules[i].memscan:=TMemScan.create(nil);
    aobscanmodules[i].memscan.OnlyOne:=true;

    aobstrings:='';
    for j:=0 to length(aobscanmodules[i].entries)-1 do
      aobstrings:=aobstrings+'('+aobscanmodules[i].entries[j].aobstring+')';

    if length(aobscanmodules[i].entries)=1 then //bytearrays is slightly slower, so only use it if more than one entry is to be scanned
      aobscanmodules[i].memscan.firstscan(soExactValue, vtByteArray, rtRounded, aobscanmodules[i].entries[0].aobstring, aobscanmodules[i].protection, aobscanmodules[i].minaddress, aobscanmodules[i].maxaddress, true, false, false, false, fsmNotAligned)
    else
      aobscanmodules[i].memscan.firstscan(soExactValue, vtByteArrays, rtRounded, aobstrings, aobscanmodules[i].protection, aobscanmodules[i].minaddress, aobscanmodules[i].maxaddress, true, false, false, false, fsmNotAligned);
  end;

  //now wait till all are finished
  for i:=0 to length(aobscanmodules)-1 do
    if aobscanmodules[i].memscan<>nil then
    begin
      aobscanmodules[i].memscan.waittilldone;
      finished(i);
    end;


  if error then raise EAutoAssembler.create(errorstring);


end;



procedure parseTryExcept(code: tstrings; var exceptionlist: TAAExceptionInfoList);
//Find and replace {$TRY} , {$EXCEPT} with labels
var
  i,j: integer;
  trynr: integer;
  trylist: array of record
    linenr: integer;
    trynr: integer;
    hasexcept: boolean;
    trylabel, exceptlabel: string;
  end;

  found: boolean;
begin
  trynr:=0;
  setlength(trylist,0);

  for i:=0 to code.Count-1 do
  begin
    if uppercase(code[i])='{$TRY}' then
    begin
      inc(trynr);

      j:=length(trylist);
      setlength(trylist,j+1);
      trylist[j].trynr:=trynr;
      trylist[j].hasexcept:=false;
      trylist[j].linenr:=integer(code.Objects[i]);
      trylist[j].trylabel:='tryoperation_'+inttostr(trynr);
      code[i]:=trylist[j].trylabel+':';
    end;

    if uppercase(code[i])='{$EXCEPT}' then
    begin
      //find the last try that doesn't have an except filled in
      found:=false;
      for j:=length(trylist)-1 downto 0 do
      begin
        if trylist[j].hasexcept=false then
        begin
          trylist[j].hasexcept:=true;
          trylist[j].exceptlabel:='tryoperation'+inttostr(trylist[j].trynr)+'_except';
          code[i]:=trylist[j].exceptlabel+':';
          found:=true;
          break;
        end;
      end;

      if not found then
        raise exception.create(format('Found an {$EXCEPT} at line %d with no matching {$TRY}',[integer(code.Objects[i])]));
    end;
  end;

  setlength(exceptionlist, length(trylist));

  for i:=0 to length(trylist)-1 do
  begin
    code.Insert(0,'label('+trylist[i].trylabel+')');
    code.Insert(0,'label('+trylist[i].exceptlabel+')');
    exceptionlist[i].trylabel:=trylist[i].trylabel;
    exceptionlist[i].exceptlabel:=trylist[i].exceptlabel;

    if trylist[i].hasexcept=false then raise exception.create(format(rsMissingExcept, [trylist[i].linenr]));
  end;
end;

procedure luacode(code: TStrings; syntaxcheckonly: boolean; memrec: TMemoryRecord=nil);
{
Find and execute the LUA parts:
function (syntaxcheck)
  <code>
end

If the functions return a string, substitute the code with the given string
}
var
  i,j,k: integer;
  s: tstringlist;
  stack: integer;
  str: string;
  error: boolean;
  L: Plua_State;
begin
  i:=0;

  while i<code.Count do
  begin
    //search for {$LUA}

    str:=uppercase(TrimRight(code[i]));
    if str='{$LUA}' then
    begin
      //search for {$ASM} or the end
      j:=i+1;
      while j<=code.count do
      begin

        if (j=code.count) or (uppercase(TrimRight(code[j]))='{$ASM}') then
        begin
          s:=TStringList.create;

          s.add('local syntaxcheck,memrec=...');

          code[i]:='';
          for k:=i+1 to j-1 do
          begin
            s.Add(code[k]);
            code[k]:=''; //empty
          end;

          if j<>code.count then
            code[j]:='';


{$ifndef NOLUA}
          L:=GetLuaState;


          try
            stack:=lua_Gettop(L);

            error:=false;

            luaL_loadstring(L, pchar(s.text));
            if lua_isfunction(L, -1) then
            begin
              lua_pushboolean(L, syntaxcheckonly);
              luaclass_newClass(L, memrec);

              if lua.lua_pcall(L, 2, 1, 0)=0 then
              begin
                if lua_isstring(L,-1) then
                begin
                  str:=Lua_ToString(L, -1);
                  s:=tstringlist.create;
                  s.text:=str;

                  for k:=0 to s.count-1 do
                    code.Insert(i+k, s[k]);

                  s.free;

                end;
              end
              else
                error:=true;
            end
            else
              error:=true;

            if error then
            begin
              if lua_isstring(L, -1) then
                raise exception.create(rsAALuaErrorInTheScriptAtLine+inttostr(integer(code.Objects[i]))+':'+lua_tostring(L, -1))
              else
                raise exception.create(rsAALuaErrorInTheScriptAtLine+inttostr(integer(code.Objects[i])));

            end;

          finally
            lua_settop(L, stack);
          end;
{$endif}
          break;

        end;
        inc(j);
      end;


    end
    else
      inc(i);
  end;


end;


var nextaaid: longint;

function autoassemble2(code: tstrings;popupmessages: boolean;syntaxcheckonly:boolean; targetself: boolean; disableinfo: TDisableInfo=nil; memrec: TMemoryRecord=nil):boolean;
{
registeredsymbols is a stringlist that is initialized by the caller as case insensitive and no duplicates
}

type tassembled=record
  address: ptrUint;
  bytes: TAssemblerbytes;
  createthreadandwait: integer;
end;


type tlabel=record
  defined: boolean;
  afterccode: boolean;
  insideAllocatedMemory: boolean;
  address:ptrUint;
  labelname: string;
  assemblerline: integer;
  references: array of integer; //index of assembled array
  references2: array of integer; //index of assemblerlines array
end;
type tfullaccess=record
  address: ptrUint;
  size: dword;
end;
type tdefine=record
  name: string;
  whatever: string;
end;
var i: integer=0;
    j: integer=0;
    k: integer=0;
    l: integer=0;
    e: integer=0;
    currentline: string='';
    currentline2: string='';
    currentlinenr: integer=0;
    currentlinep: pchar=nil;

    currentaddress: ptrUint=0;
    assembled: array of tassembled=[];
    x: ptruint=0;
    y:dword=0;
    op: dword=0;
    op2:dword=0;
    ok1:boolean=false;
    ok2:boolean=false;
    loadbinary: array of record
      address: string; //string since it might be a label/alloc/define
      filename: string;
    end=[];

    readmems: array of record
      bytelength: integer;
      bytes: PByteArray;
    end=[];

    //allocs:
    globalallocs: array of tcealloc=[];
    allocs:       array of tcealloc=[];
    kallocs:      array of tcealloc=[];
    sallocs:      array of tcealloc=[];


    tempalloc: tcealloc;
    labels: array of tlabel=[];
    defines: array of tdefine=[];
    fullaccess: array of tfullaccess=[];
    dealloc: array of PtrUInt=[];
    addsymbollist: array of string=[];
    deletesymbollist: array of string=[];
    createthread: array of string=[];

    createthreadandwait: array of record
      name: string;
      position: integer; //after what position should the call happen (This is so that the exception handlers can be registered before the final hookcode is written)
      timeout: integer;
    end;

    a,b,c,d: integer;
    s1,s2,s3: string;

    slist: TStringDynArray=[];
    sli: integer=0; //slist iterator

    diff: ptruint=0;


    assemblerlines: array of record
      linenr: integer;
      line: string;
    end=[];

    exceptionlist: TAAExceptionInfoList=[];
    {$ifdef onebytejumps}
    onebytejumps: TAAExceptionRIPChangeInfoList=[];
    {$endif}

    varsize: integer=0;
    tokens: tstringlist=nil;
    baseaddress: ptrUint=0;

    multilineinjection: tstringlist=nil;
    include: tstringlist=nil;
    testdword,bw: dword;
    testPtr: ptrUint=0;
    binaryfile: tmemorystream=nil;

    incomment: boolean=false;

    bytebuf: PByteArray=nil;

    processhandle: THandle=0;
    ProcessID: DWORD=0;

    bytes: tbytes=[];
    oldprefered: ptrUint=0;
    prefered: ptrUint=0;
    protection: dword=0;

    oldprocessid: dword;
    oldhandle: thandle=0;
    oldsymhandler: TSymHandler=nil;


    disassembler: TDisassembler=nil;

    threadhandle: THandle=0;

    potentiallabels: TStringlist=nil;


    connection: TCEConnection=nil;


    mi: TModuleInfo;
    aaid: longint=0;
    strictmode: boolean=false;
    hastryexcept: boolean=false;
    //aggressiveAlloc: boolean;
    createthreadandwaitid: integer=0;

    vpe: boolean=false;

    nops: Tassemblerbytes=[];
    mustbefar: boolean=false;
    usesaobscan: boolean=false;

    dataForAACodePass2: TAutoAssemblerCodePass2Data;


    debug_getAddressFromScript: boolean=false;

    function getAddressFromScript(name: string; alternate: boolean=false): ptruint;
    var
      found: boolean;
      j,k: integer;
      temps: string;
      oldname: string;
    begin
      if name='' then
      begin
        OutputDebugString('getAddressFromScript with an empty name');
        exit(0);
      end;

      result:=0;
      found:=false;

      if debug_getAddressFromScript then OutputDebugString('getAddressFromScript');

      oldname:=name;
      name:=uppercase(name);

      if debug_getAddressFromScript then OutputDebugString('looking for '+name);


      if debug_getAddressFromScript then OutputDebugString('allocs...');
      for j:=0 to length(allocs)-1 do
        if uppercase(allocs[j].varname)=name then
          exit(allocs[j].address);

      if debug_getAddressFromScript then OutputDebugString('kallocs...');
      for j:=0 to length(kallocs)-1 do
         if uppercase(kallocs[j].varname)=name then
           exit(kallocs[j].address);


      if debug_getAddressFromScript then OutputDebugString('labels...');
      for j:=0 to length(labels)-1 do
        if uppercase(labels[j].labelname)=name then
        begin
          if labels[j].defined then
            exit(labels[j].address);
        end;

      if debug_getAddressFromScript then OutputDebugString('defines...');
      for j:=0 to length(defines)-1 do
        if uppercase(defines[j].name)=name then
        begin
          try
            result:=symhandler.getAddressFromName(defines[j].whatever);
            exit;
          except
          end;
        end;

      if debug_getAddressFromScript then OutputDebugString('symbols original case...');
      try
        if targetself then
          result:=selfsymhandler.getAddressFromName(oldname)
        else
          result:=symhandler.getAddressFromName(oldname);

        if result<>0 then exit;

        if debug_getAddressFromScript then OutputDebugString('result=0 and no exception....');
      except
      end;

      if debug_getAddressFromScript then OutputDebugString('symbols uppercase...');
      try
        if targetself then
          result:=selfsymhandler.getAddressFromName(name)
        else
          result:=symhandler.getAddressFromName(name);

        if result<>0 then exit;

        if debug_getAddressFromScript then OutputDebugString('result=0 and no exception....');
      except
      end;

      if debug_getAddressFromScript then OutputDebugString('not a registered symbol');

      if (not alternate) and
         (not processhandler.is64Bit) and
         (name[1]='_') and
         (name[length(name)] in ['0'..'9']) and
         name.Contains('@')
      then
      begin
        //it could be a _symbolname@###
        j:=name.IndexOf('@');
        temps:=name.Substring(j+1);
        if TryStrToInt(temps,k) then
        begin
          //it is a _symbolname@###
          temps:=name.Substring(1,j-1);
          exit(getAddressFromScript(temps,true));
        end;
      end;


      if debug_getAddressFromScript then OutputDebugString('not found');
    end;

    procedure handleCreateThreadAndWait(ctawi: integer);
    begin
      //create the thread and wait for it's result
      testptr:=getAddressFromScript(createthreadandwait[ctawi].name);

      threadhandle:=createremotethread(processhandle,nil,0,pointer(testptr),nil,0,bw);
      ok2:=threadhandle>0;

      if ok2 then
      begin
        {$ifdef windows}
        try
          k:=createthreadandwait[ctawi].timeout;
          if k<=0 then y:=INFINITE else y:=k;

          if WaitForSingleObject(threadhandle, y)<>WAIT_OBJECT_0 then
            raise EAssemblerException.create('createthreadandwait did not execute properly');
        finally
          closehandle(threadhandle);
        end;
        {$else}
        sleep(5000); //todo: implement proper wait
        {$endif}

      end;

      createthreadandwait[ctawi].position:=-1; //mark it as handled
    end;

begin
  setlength(readmems,0);
  setlength(allocs,0);
  setlength(kallocs,0);
  setlength(globalallocs,0);
  setlength(sallocs,0);
  setlength(createthread,0);
  setlength(createthreadandwait,0);
  setlength(defines,0);
  setlength(labels,0);

  FillChar(dataForAACodePass2, sizeof(dataForAACodePass2),0);

  connection:=nil;
  i:=0;
  j:=0;
  k:=0;
  l:=0;
  e:=0;

  currentaddress:=0;


  //add all symbols as predefined labels
  if disableinfo<>nil then
  begin
    setlength(labels, disableinfo.allsymbols.count);
    for i:=0 to disableinfo.allsymbols.count-1 do
    begin
      FillMemory(@labels[length(labels)-1],sizeof(labels[0]),0);

      labels[i].defined:=true;
      labels[i].address:=ptruint(disableinfo.allsymbols.Objects[i]);
      labels[i].labelname:=disableinfo.allsymbols[i];
      labels[i].assemblerline:=-2; //undo symbol label
    end;
  end;


  {$ifndef jni}

  if targetself then
  begin
    //get this function to use the symbolhandler that's pointing to CE itself and the self processid/handle
    oldhandle:=processhandlerunit.ProcessHandle;
    oldprocessid:=processid;
    processid:=getcurrentprocessid;
    processhandle:=getcurrentprocess;
    oldsymhandler:=symhandler;
    symhandler:=selfsymhandler;
    processhandler.processid:=getcurrentprocessid;
    processhandler.processhandle:=processhandle;
  end
  else
  {$endif}
  begin
    processid:=processhandlerunit.ProcessID;
    processhandle:=processhandlerunit.ProcessHandle;
  end;

  {$ifndef darwin}

  symhandler.waitforsymbolsloaded(true);
  {$endif}

{$ifndef jni}
  if pluginhandler=nil then exit; //Error. Cheat Engine is not properly configured

  aaid:=InterLockedIncrement(nextaaid);
  pluginhandler.handleAutoAssemblerPlugin(@currentlinep, 0, aaid); //tell the plugins that an autoassembler script is about to get executed
{$endif}


  potentiallabels:=tstringlist.create;
  potentiallabels.CaseSensitive:=false;

//2 pass scanner
  try

    setlength(assembled,1);
    setlength(kallocs,0);
    setlength(allocs,0);
    setlength(dealloc,0);
    setlength(assemblerlines,0);
    setlength(fullaccess,0);
    setlength(addsymbollist,0);
    setlength(deletesymbollist,0);

    setlength(loadbinary,0);
    setlength(exceptionlist,0);

    tokens:=tstringlist.Create;

    incomment:=false;

    if not targetself then
      for i:=0 to length(AutoAssemblerPrologues)-1 do
        if assigned(AutoAssemblerPrologues[i]) then
          AutoAssemblerPrologues[i](code, syntaxcheckonly);

    luacode(code, syntaxcheckonly, memrec); //replaces {$lua}/{$asm} blocks with the output of those functions
    AutoAssemblerCodePass1(code,dataForAACodePass2, syntaxcheckonly, targetself); //replaces the {$luacode} and {$ccode} blocks with a call to extra routines added to the script
    //still here

    //c-symbol addition
    for i:=0 to length(dataForAACodePass2.cdata.symbols)-1 do
    begin
      //define the c-code symbol as an undefined labels
      j:=length(labels);
      setlength(labels, j+1);
      ZeroMemory(@labels[j],sizeof(labels[j]));

      labels[j].labelname:=dataForAACodePass2.cdata.symbols[i].name;
      labels[j].defined:=false;
      labels[j].afterccode:=true;
      labels[j].assemblerline:=-1;
      setlength(labels[j].references,0);
      setlength(labels[j].references2,0);
    end;
    //c-symbol addition^


    //one more time getting rid of {$ASM} lines that have been added while they shouldn't be required
    for i:=0 to code.count-1 do
      if uppercase(TrimRight(code[i]))='{$ASM}' then
        code[i]:='';



    strictmode:=false;
    hastryexcept:=false;
    for i:=0 to code.count-1 do
    begin
      currentline:=uppercase(TrimRight(code[i]));
      if currentline='{$STRICT}' then
        strictmode:=true;

      if currentline='{$TRY}' then
        hastryexcept:=true;

      //if currentline='{$AGGRESSIVEALLOC}' then
      //  aggressiveAlloc:=true;   //1: pause game, find mem_private block even close to here with some non-allocated space free, resize resume
      //                           //2: allocate in reserved memory

    end;


    if hastryexcept then
      parseTryExcept(code, exceptionlist);


    removecomments(code);  //also trims each line
    unlabeledlabels(code);

    if not strictmode then
      getPotentialLabels(code, potentiallabels);


    //6.3: do the aobscans first
    //this will break scripts that use define(state,33) aobscan(name, 11 22 state 44 55), but really, live with it

    usesaobscan:=aobscans(code, syntaxcheckonly);

    if not targetself then
      for i:=0 to length(AutoAssemblerProloguesPostAOBSCAN)-1 do
        if assigned(AutoAssemblerProloguesPostAOBSCAN[i]) then
          AutoAssemblerProloguesPostAOBSCAN[i](code, syntaxcheckonly);

    //first pass

    i:=0;
    while i<code.Count do
    begin
      try
        try
          currentline:=code[i];
          currentlinenr:=ptrUint(code.Objects[i]);

          //check if useless
          if length(currentline)=0 then continue;
          if copy(currentline,1,2)='//' then continue; //skip



          //do this first. Do not touch registersymbol with any kind of define/label/whatsoever
          if uppercase(copy(currentline,1,15))='REGISTERSYMBOL(' then
          begin
            //add this symbol to the register symbollist
            a:=pos('(',currentline);
            b:=pos(')',currentline);

            if (a>0) and (b>0) then
            begin
              s1:=trim(copy(currentline,a+1,b-a-1));
              slist:=s1.Split([',',' ']);

              for sli:=0 to length(slist)-1 do
              begin
                s1:=slist[sli];

                setlength(addsymbollist,length(addsymbollist)+1);
                addsymbollist[length(addsymbollist)-1]:=s1;

                if disableinfo<>nil then
                  disableinfo.registeredsymbols.Add(s1);
              end;
            end
            else raise exception.Create(rsSyntaxError);

            continue;
          end;



          //apply defines (before DEFINE since define(bla, 123) and define(xxx, bla+123) should work


          //also, do not touch define with any previous define
          if uppercase(copy(currentline,1,7))='DEFINE(' then
          begin
            //syntax: define(x,whatever)    x=variable name size=bytes
            //allocate memory



            a:=pos('(',currentline);
            b:=pos(',',currentline);
            c:=rpos(')',currentline);
            if (a>0) and (b>0) and (c>0) then
            begin
              s1:=trim(copy(currentline,a+1,b-a-1));
              s2:=copy(currentline,b+1,c-b-1);


              //apply earlier defines to the second part
              for j:=0 to length(defines)-1 do
                 s2:=replacetoken(s2,defines[j].name,defines[j].whatever);



              ok1:=true;
              for j:=0 to length(defines)-1 do
                if uppercase(defines[j].name)=uppercase(s1) then
                begin
                  //redefined from here on
                  ok1:=false;
                  defines[length(defines)-1].whatever:=s2
                end;

              if ok1 then //not duplicate, create it
              begin
                setlength(defines,length(defines)+1);
                defines[length(defines)-1].name:=s1;
                defines[length(defines)-1].whatever:=s2;
              end;

              continue;
            end else raise exception.Create(rsWrongSyntaxDEFINENameWhatever+' Got '+currentline);
          end;


          //normal loop code

          for j:=0 to length(defines)-1 do
             currentline:=replacetoken(currentline,defines[j].name,defines[j].whatever);



          setlength(assemblerlines,length(assemblerlines)+1);
          assemblerlines[length(assemblerlines)-1].linenr:=currentlinenr;
          assemblerlines[length(assemblerlines)-1].line:=currentline;

          //plugins
          currentlinep:=@currentline[1];
          {$ifndef jni}
          pluginhandler.handleAutoAssemblerPlugin(@currentlinep, 1,aaid);
          {$endif}
          currentline:=currentlinep;

          //lua extensions
          if registeredAutoAssemblerCommands<>nil then
          begin
            j:=pos('(', currentline);
            if j>0 then
            begin
              s1:=uppercase(copy(currentline, 1, j-1));
              for j:=0 to registeredAutoAssemblerCommands.count-1 do
              begin
                if TRegisteredAutoAssemblerCommand(registeredAutoAssemblerCommands[j]).command=s1 then
                begin
                  a:=pos('(',currentline);
                  b:=RPos(')',currentline);
                  s1:=copy(currentline, a+1, b-a-1);

                  currentline:=TRegisteredAutoAssemblerCommand(registeredAutoAssemblerCommands[j]).callback(s1, syntaxcheckonly);

                  //insert the current text as lines into the codelist
                  multilineinjection:=TStringList.create;
                  try
                    multilineinjection.Text:=currentline;

                    for k:=0 to multilineinjection.Count-1 do
                      code.InsertObject(i+1+k, multilineinjection[k], pointer(ptruint(currentlinenr)));
                  finally
                    multilineinjection.Free;
                  end;

                  //showmessage(code.text);

                  currentline:='';
                  break;
                end;
              end;
            end;
          end;

          //if the newline is empty then it has been handled and the plugin doesn't want it to be added for phase2
          if length(currentline)=0 then
          begin
            setlength(assemblerlines,length(assemblerlines)-1);
            continue;
          end;
          //otherwise it hasn't been handled, or it has been handled and the string is a compatible string that passes the phase1 tests (so variablenames converted to 00000000 and whatever else is needed)

          //plugins^^^

          if uppercase(copy(currentline,1,7))='ASSERT(' then //assert(address,aob)
          begin
            if not syntaxcheckonly then
            begin
              a:=pos('(',currentline);
              b:=pos(',',currentline);
              c:=pos(')',currentline);
              if (a>0) and (b>0) and (c>0) then
              begin
                s1:=trim(copy(currentline,a+1,b-a-1));
                s2:=trim(copy(currentline,b+1,c-b-1));

                testPtr:= symhandler.getAddressFromName(s1,false);

                setlength(bytes,0);
                try
                  ConvertStringToBytes(s2, true, bytes);
                except
                  raise exception.create(Format(rsIsNotAValidBytestring, [s2]));
                end;

                if length(bytes)>0 then
                begin
                  getmem(bytebuf,length(bytes));
                  try
                    if ReadProcessMemory(processhandle, pointer(testPtr), bytebuf, length(bytes),x) then
                    begin

                        for j:=0 to length(bytes)-1 do
                        begin
                          if bytes[j]>=0 then
                            if byte(bytes[j])<>bytebuf[j] then
                              raise exception.Create(Format(rsTheBytesAtAreNotWhatWasExpected, [s1]));
                        end;
                    end else raise exception.Create(Format(rsTheMemoryAtCanNotBeRead, [s1]));
                  finally
                    freememandnil(bytebuf);

                  end;

                end
                else raise exception.Create(Format(rsIsNotAValidBytestring, [s2]));

              end
              else
                raise exception.Create(rsWrongSyntaxASSERTAddress1122335566);
            end;

            setlength(assemblerlines,length(assemblerlines)-1);
            continue;
          end;
              {
          if uppercase(copy(currentline,1,12))='SHAREDALLOC(' then
          begin
            a:=pos('(',currentline);
            b:=pos(',',currentline);
            c:=pos(')',currentline);
            if (a>0) and (b>0) and (c>0) then
            begin
              s1:=trim(copy(currentline,a+1,b-a-1));
              s2:=trim(copy(currentline,b+1,c-b-1));

              try
                x:=strtoint(s2);
              except
                raise exception.Create(Format(rsIsNotAValidSize, [s2]));
              end;

              setlength(sallocs,length(sallocs)+1);
              sallocs[length(sallocs)-1].address:=allocateSharedMemoryIntoTargetProcess(s1,x);
              sallocs[length(sallocs)-1].varname:=s1;
              sallocs[length(sallocs)-1].size:=x;

              setlength(assemblerlines,length(assemblerlines)-1);
              continue;

            end
            else raise exception.Create(rsWrongSyntaxSHAREDALLOCNameSize);
          end;  }

          if uppercase(copy(currentline,1,12))='GLOBALALLOC(' then
          begin
            a:=pos('(',currentline);
            b:=pos(',',currentline);
            c:=PosEx(',',currentline,b+1);
            d:=pos(')',currentline);

            if (a>0) and (b>0) and (d>0) then
            begin
              s1:=trim(copy(currentline,a+1,b-a-1));

              if c>0 then
              begin
                s2:=trim(copy(currentline,b+1,c-b-1));
                s3:=trim(copy(currentline,c+1,d-c-1));
              end
              else
              begin
                s2:=trim(copy(currentline,b+1,d-b-1));
                s3:='';
              end;


              try
                x:=strtoint(s2);
              except
                raise exception.Create(Format(rsIsNotAValidSize, [s2]));
              end;

              //define it here already
              if s3<>'' then
                symhandler.SetUserdefinedSymbolAllocSize(s1,x, symhandler.getAddressFromName(s3))
              else
                symhandler.SetUserdefinedSymbolAllocSize(s1,x);

              setlength(globalallocs,length(globalallocs)+1);
              globalallocs[length(globalallocs)-1].address:=symhandler.GetUserdefinedSymbolByName(s1);
              globalallocs[length(globalallocs)-1].varname:=s1;
              globalallocs[length(globalallocs)-1].size:=x;


              setlength(assemblerlines,length(assemblerlines)-1);
              continue;

            end
            else raise exception.Create(rsWrongSyntaxGLOBALALLOCNameSize);
          end;

          if uppercase(copy(currentline,1,8))='INCLUDE(' then
          begin
            a:=pos('(',currentline);
            b:=pos(')',currentline);

            if (a>0) and (b>0) then
            begin
              s1:=trim(copy(currentline,a+1,b-a-1));

              if ExtractFileExt(uppercase(s1))='.' then
                s1:=s1+'CEA';

              if ExtractFileExt(uppercase(s1))='' then
                s1:=s1+'.CEA';

              if not fileexists(s1) then //check if it's inside the current location
              begin
                //if not, check the default paths
                s2:=cheatenginedir+'includes'+pathdelim+'s1';
                if fileexists(s2) then s1:=s2 else
                begin
                  s2:=cheatenginedir+s1;
                  if fileexists(s2) then s1:=s2
                  else
                  begin
                    s2:=tablesdir+s1;
                    if fileexists(s2) then s1:=s2;
                  end;
                end;

                if not fileexists(s1) then
                  raise exception.Create(Format(rsCouldNotBeFound, [s1]));
              end;

              include:=tstringlist.Create;
              try
                include.LoadFromFile(s1{$if FPC_FULLVERSION >= 030200}, true{$endif});
                removecomments(include);
                unlabeledlabels(include);

                for j:=i+1 to (i+1)+(include.Count-1) do
                  code.Insert(j,include[j-(i+1)]);
              finally
                include.Free;
              end;

              setlength(assemblerlines,length(assemblerlines)-1);
              continue;
            end
            else raise exception.Create(rsWrongSyntaxIncludeFilenameCea);
          end;

          if uppercase(copy(currentline,1,12))='CREATETHREAD' then
          begin
            if currentline[13]='(' then //CREATETHREAD(
            begin
              //create a thread
              a:=pos('(',currentline);
              b:=pos(')',currentline);
              if (a>0) and (b>0) then
              begin
                s1:=trim(copy(currentline,a+1,b-a-1));
                setlength(createthread,length(createthread)+1);
                createthread[length(createthread)-1]:=s1;

                setlength(assemblerlines,length(assemblerlines)-1);
                continue;
              end else raise exception.Create(rsWrongSyntaxCreateThreadAddress);
            end
            else
            begin
              //could be createthreadandwait
              if uppercase(copy(currentline,13,8))='ANDWAIT(' then //CREATETHREADANDWAIT(
              begin
                a:=pos('(',currentline);
                b:=pos(')',currentline);
                if (a>0) and (b>0) then
                begin
                  s1:=trim(copy(currentline,a+1,b-a-1));

                  slist:=s1.Split([',']);
                  if length(slist)=2 then
                  begin
                    try
                      j:=strtoint(trim(slist[1]));
                    except
                      raise exception.Create('Invalid timeout for createthreadandwait');
                    end;
                  end
                  else
                  begin
                    if (lastLoadedTableVersion>0) and (lastLoadedTableVersion<=30) then //when the current table was made with an older CE build and it uses  CREATETHREADANDWAIT
                      j:=5000
                    else
                      j:=0;
                  end;


                  setlength(createthreadandwait,length(createthreadandwait)+1);
                  createthreadandwait[length(createthreadandwait)-1].name:=slist[0];
                  createthreadandwait[length(createthreadandwait)-1].position:=length(assemblerlines)-1;
                  createthreadandwait[length(createthreadandwait)-1].timeout:=j;

                  setlength(assemblerlines,length(assemblerlines)-1);
                  continue;
                end else raise exception.Create(rsWrongSyntaxCreateThreadAddress);
              end;
            end;
          end;



          {$ifndef jni}

          {$ifdef ONEBYTEJUMPS}
          if uppercase(copy(currentline,1,5))='JMP1 ' then
          begin
            s1:=copy(currentline, 6);
            assemblerlines[length(assemblerlines)-1].linenr:=currentlinenr;
            assemblerlines[length(assemblerlines)-1].line:='<JMP1 '+s1+'>';
            continue;
          end;
          {$endif}

          if uppercase(copy(currentline,1,12))='LOADLIBRARY(' then
          begin
            //load a library into memory , this one already executes BEFORE the 2nd pass to get addressnames correct
            a:=pos('(',currentline);
            b:=pos(')',currentline);

            if (a>0) and (b>0) then
            begin
              s1:=trim(copy(currentline,a+1,b-a-1));

              if (length(s1)>1) and ((s1[1]='''') or (s1[1]='"')) then
                s1:=AnsiDequotedStr(s1,s1[1]);

              if pos(':',s1)=0 then
              begin
                s2:=extractfilename(s1);

                {$ifdef windows}
                if getConnection=nil then //no connection, so local. Check if the file can be found locally and if so, set the specific path
                begin
                {$endif}
                  if fileexists(cheatenginedir+s2) then s1:=cheatenginedir+s2 else
                    if fileexists(getcurrentdir+ PathDelim+s2) then s1:=getcurrentdir+PathDelim+s2 else
                      if fileexists(cheatenginedir+s1) then s1:=cheatenginedir+s1;
                {$ifdef windows}
                end;
                {$endif}

                //else just hope it's in the dll searchpath
              end; //else direct file path

              try
                if symhandler.getmodulebyname(extractfilename(s1), mi)=false then //check if it's already injected
                begin
                  InjectDll(s1,'');
                  symhandler.reinitialize;
                end;
                symhandler.waitforsymbolsloaded;
                symhandler.waitForExports;
              except
                raise exception.create(Format(rsCouldNotBeInjected, [s1]));
              end;

              setlength(assemblerlines,length(assemblerlines)-1);
              continue;
            end else raise exception.Create(rsWrongSyntaxLoadLibraryFilename);
          end;


          if uppercase(copy(currentline,1,8))='LUACALL(' then
          begin
            //execute a given lua command
            a:=pos('(',currentline);
            b:=length(currentline);

            if currentline[b]<>')' then b:=-1;

            if (a>0) and (b>0) then
            begin
              s1:=trim(copy(currentline,a+1,b-a-1));

              LUA_DoScript(s1); //raises an exception on error, which is exactly what we want here

              setlength(assemblerlines,length(assemblerlines)-1);
              continue;
            end else raise exception.Create(rsWrongSyntaxLuaCall);
          end;
          {$endif}

          if uppercase(copy(currentline,1,8))='READMEM(' then
          begin
            //read memory and place it here (readmem(address,size) )
            a:=pos('(',currentline);
            b:=pos(',',currentline);
            c:=pos(')',currentline);
            if (a>0) and (b>0) and (c>0) then
            begin
              s1:=trim(copy(currentline,a+1,b-a-1));
              s2:=trim(copy(currentline,b+1,c-b-1));

              //read memory and replace with lines of DB xx xx xx xx xx xx xx xx
              try
                testptr:=symhandler.getAddressFromName(s1);
              except
                if not syntaxcheckonly then
                  raise exception.Create(rsInvalidAddressForReadMem)
                else
                  testptr:=0;
              end;

              try
                a:=strtoint(s2);
              except
                raise exception.Create(rsInvalidSizeForReadMem);
              end;

              if a=0 then
                raise exception.Create(rsInvalidSizeForReadMem);


              getmem(bytebuf,a);
              try
                if not syntaxcheckonly then
                begin
                  if (not ReadProcessMemory(processhandle, pointer(testptr),bytebuf,a,x)) or (x<a) then
                    raise exception.Create(Format(rsTheMemoryAtCouldNotBeFullyRead, [s1]));
                end;
              except
                on e:exception do
                begin
                  if bytebuf<>nil then
                  begin
                    freememandnil(bytebuf);

                  end;

                  raise exception.create(e.Message);
                end;
              end;


              //still here so everything ok
              assemblerlines[length(assemblerlines)-1].linenr:=currentlinenr;
              assemblerlines[length(assemblerlines)-1].line:='<READMEM'+IntToStr(length(readmems))+'>';
              setlength(readmems, length(readmems)+1);
              readmems[length(readmems)-1].bytelength:=a;
              readmems[length(readmems)-1].bytes:=bytebuf;
              bytebuf:=nil;

              continue;



            end else raise exception.Create(rsWrongSyntaxReadMemAddressSize);

            continue;
          end;

          if uppercase(copy(currentline,1,11))='REASSEMBLE(' then
          begin
            a:=pos('(',currentline);
            b:=pos(')',currentline);

            if (a>0) and (b>0) then
            begin
              s1:=trim(copy(currentline,a+1,b-a-1));

              try
                testptr:=getAddressFromScript(s1);
              except
                raise exception.Create(format(rsXCouldNotBeFound, [s1]));
              end;

              if testptr=0 then
                raise exception.Create(format(rsXCouldNotBeFound, [s1]));



              multilineinjection:=TStringList.create;
              GetOriginalInstruction(testptr, multilineinjection, processhandler.is64Bit,true); //don't take on the symbol.  (module and section are ok, not symbols)

              if multilineinjection.count=0 then
                raise exception.create(format(rsFailureGettingOriginalInstruction, [testptr]));

              if trim(multilineinjection[0]).StartsWith('//') then    //skip comments
                setlength(assemblerlines, length(assemblerlines)-1)
              else
              begin
                assemblerlines[length(assemblerlines)-1].linenr:=currentlinenr;
                assemblerlines[length(assemblerlines)-1].line:=multilineinjection[0];
              end;

              for j:=1 to multilineinjection.Count-1 do
              begin
                setlength(assemblerlines, length(assemblerlines)+1);
                assemblerlines[length(assemblerlines)-1].linenr:=currentlinenr;
                assemblerlines[length(assemblerlines)-1].line:=multilineinjection[j];
              end;


              freeandnil(multilineinjection);
              continue;
              {
              disassembler:=TDisassembler.create;
              disassembler.dataOnly:=true;
              disassembler.disassemble(testptr, s1);

              if syntaxcheckonly then currentline:='nop' else
                currentline:=disassembler.LastDisassembleData.prefix+' '+Disassembler.LastDisassembleData.opcode+' '+disassembler.LastDisassembleData.parameters;;

              assemblerlines[length(assemblerlines)-1].linenr:=currentlinenr;
              assemblerlines[length(assemblerlines)-1].line:=currentline;
              disassembler.free;                                        }
            end else raise exception.Create(rsWrongSyntaxReAssemble);

          end;

          if uppercase(copy(currentline,1,11))='LOADBINARY(' then
          begin
            //load a binary file into memory
            a:=pos('(',currentline);
            b:=pos(',',currentline);
            c:=pos(')',currentline);
            if (a>0) and (b>0) and (c>0) then
            begin
              s1:=trim(copy(currentline,a+1,b-a-1));
              s2:=trim(copy(currentline,b+1,c-b-1));

              if not fileexists(s2) then raise exception.Create(Format(rsTheFileDoesNotExist, [s2]));

              setlength(loadbinary,length(loadbinary)+1);
              loadbinary[length(loadbinary)-1].address:=s1;
              loadbinary[length(loadbinary)-1].filename:=s2;

              setlength(assemblerlines,length(assemblerlines)-1);
              continue;
            end else raise exception.Create(rsWrongSyntaxLoadBinaryAddressFilename);
          end;



          if uppercase(copy(currentline,1,17))='UNREGISTERSYMBOL(' then
          begin
            //add this symbol to the register symbollist
            a:=pos('(',currentline);
            b:=pos(')',currentline);

            if (a>0) and (b>0) then
            begin
              s1:=trim(copy(currentline,a+1,b-a-1));

              if (disableinfo<>nil) and (s1='*') then
              begin
                j:=length(deletesymbollist);
                setlength(deletesymbollist, j+ disableinfo.registeredsymbols.Count);

                for k:=0 to disableinfo.registeredsymbols.Count-1 do
                  deletesymbollist[j+k]:=disableinfo.registeredsymbols[k];
              end
              else
              begin
                slist:=s1.Split([',',' ']);
                for sli:=0 to length(slist)-1 do
                begin
                  s1:=slist[sli];
                  setlength(deletesymbollist,length(deletesymbollist)+1);
                  deletesymbollist[length(deletesymbollist)-1]:=s1;
                end;
              end;
            end
            else raise exception.Create(rsSyntaxError);

            setlength(assemblerlines,length(assemblerlines)-1);
            continue;
          end;

          //AOBSCAN used to live here, but he moved up

          //define
          if uppercase(copy(currentline,1,7))='STRUCT ' then
          begin
            replaceStructWithDefines(code, i);
            setlength(assemblerlines,length(assemblerlines)-1);
            dec(i); //repeat from this line
            continue;
          end;



          if uppercase(copy(currentline,1,11))='FULLACCESS(' then
          begin
            a:=pos('(',currentline);
            b:=pos(',',currentline);
            c:=pos(')',currentline);

            if (a>0) and (b>0) and (c>0) then
            begin
              s1:=trim(copy(currentline,a+1,b-a-1));
              s2:=trim(copy(currentline,b+1,c-b-1));

              setlength(fullaccess,length(fullaccess)+1);
              fullaccess[length(fullaccess)-1].address:=symhandler.getAddressFromName(s1);
              fullaccess[length(fullaccess)-1].size:=strtoint(s2);
            end else raise exception.Create(rsSyntaxErrorFullAccessAddressSize);

            setlength(assemblerlines,length(assemblerlines)-1);
            continue;
          end;


          if uppercase(copy(currentline,1,6))='LABEL(' then
          begin
            //syntax: label(x)  x=name of the label
            //later on in the code there has to be a line with "labelname:"
            a:=pos('(',currentline);
            b:=pos(')',currentline);

            if (a>0) and (b>0) then
            begin
              s1:=trim(copy(currentline,a+1,b-a-1));

              slist:=s1.Split([',',' ']);

              for sli:=0 to length(slist)-1 do
              begin
                s1:=slist[sli];
                val('$'+s1,j,a);
                if a=0 then raise exception.Create(Format(rsIsNotAValidIdentifier, [s1]));

                varsize:=length(s1);

                j:=0;
                while (j<length(labels)) and (length(labels[j].labelname)>=varsize) do
                begin
                  //if labels[j].labelname=s1 then
                  //  raise exception.Create(Format(rsIsBeingRedeclared, [s1]));
                  inc(j);
                end;

                j:=length(labels);//quickfix
                l:=j;


                //check for the line "labelname:"
                ok1:=false;
                for j:=0 to code.Count-1 do
                  if trim(code[j])=s1+':' then
                  begin
                    if ok1 then raise exception.Create(Format(rsLabelIsBeingDefinedMoreThanOnce, [s1]));
                    ok1:=true;
                  end;

                if not ok1 then raise exception.Create(Format(rsLabelIsNotDefinedInTheScript, [s1]));


                //still here so ok
                //insert it
                setlength(labels,length(labels)+1);
                for k:=length(labels)-1 downto j+1 do
                  labels[k]:=labels[k-1];

                ZeroMemory(@labels[l], sizeof(labels[l]));
                labels[l].labelname:=s1;
                labels[l].defined:=false;

                setlength(labels[l].references,0);
                setlength(labels[l].references2,0);
              end;

              setlength(assemblerlines,length(assemblerlines)-1);
              continue;
            end else raise exception.Create(rsSyntaxError);
          end;

          if (uppercase(copy(currentline,1,8))='DEALLOC(') then
          begin
            //syntax: dealloc(x)  x=name of region to deallocate
            //later on in the code there has to be a line with "labelname:"
            a:=pos('(',currentline);
            b:=pos(')',currentline);

            if (a>0) and (b>0) then
            begin
              s1:=trim(copy(currentline,a+1,b-a-1));

              if (s1='*') then
              begin
                //everything that the script allocated
                if (disableinfo<>nil) then
                begin
                  setlength(dealloc, length(disableinfo.allocs));
                  for j:=0 to length(disableinfo.allocs)-1 do
                    dealloc[j]:=disableinfo.allocs[j].address;
                end;
              end
              else
              begin
                slist:=s1.Split([',',' ']);

                for sli:=0 to length(slist)-1 do
                begin
                  s1:=slist[sli];

                  //find s1 in the ceallocarray
                  for j:=0 to length(disableinfo.allocs)-1 do
                  begin
                    if uppercase(disableinfo.allocs[j].varname)=uppercase(s1) then
                    begin
                      setlength(dealloc,length(dealloc)+1);
                      dealloc[length(dealloc)-1]:=disableinfo.allocs[j].address;
                    end;
                  end;
                end;
              end;
            end;

            setlength(assemblerlines,length(assemblerlines)-1);
            continue;
          end;

          //memory alloc
          if (uppercase(copy(currentline,1,5))='ALLOC') and
             (
               (uppercase(copy(currentline,1,6))='ALLOC(') or
               (uppercase(copy(currentline,1,8))='ALLOCNX(') or
               (uppercase(copy(currentline,1,8))='ALLOCXO(')
             )
          then
          begin
            //syntax: alloc(x,size)    x=variable name size=bytes
            //or
            //syntax: alloc(x,size,prefered region)    x=variable name size=bytes
            //allocate memory
            a:=pos('(',currentline);
            b:=pos(',',currentline);
            c:=PosEx(',',currentline,b+1);
            d:=pos(')',currentline);

            if (a>0) and (b>0) and (d>0) then
            begin
              s1:=trim(copy(currentline,a+1,b-a-1));

              if c>0 then
              begin
                s2:=trim(copy(currentline,b+1,c-b-1));
                s3:=trim(copy(currentline,c+1,d-c-1));
              end
              else
              begin
                s2:=trim(copy(currentline,b+1,d-b-1));
                s3:='';
              end;

              val('$'+s1,j,a);
              if a=0 then raise exception.Create(Format(rsIsNotAValidIdentifier, [s1]));

              varsize:=length(s1);

              //check for duplicate identifiers
              j:=0;
              while (j<length(allocs)) and (length(allocs[j].varname)>varsize) do
              begin
                if allocs[j].varname=s1 then
                  raise exception.Create(Format(rsTheIdentifierHasAlreadyBeenDeclared, [s1]));

                inc(j);
              end;

              j:=length(allocs);//quickfix

              setlength(allocs,length(allocs)+1);

              //longest varnames first so the rename of a shorter matching var wont override the longer one
              //move up the other allocs so I can inser this element (A linked list might have been better)
              for k:=length(allocs)-1 downto j+1 do
                allocs[k]:=allocs[k-1];

              allocs[j].varname:=s1;
              allocs[j].size:=StrToInt(s2);
              if s3<>'' then
                allocs[j].prefered:=symhandler.getAddressFromName(s3)
              else
                allocs[j].prefered:=0;

              if SystemSupportsWritableExecutableMemory then
                allocs[j].protection:=PAGE_EXECUTE_READWRITE
              else
                allocs[j].protection:=PAGE_EXECUTE_READ;

              if uppercase(copy(currentline,1,8))='ALLOCNX(' then
                allocs[j].protection:=PAGE_READWRITE
              else
              if uppercase(copy(currentline,1,8))='ALLOCXO(' then
                allocs[j].protection:=PAGE_EXECUTE_READ;


              setlength(assemblerlines,length(assemblerlines)-1);   //don't bother with this in the 2nd pass
              continue;
            end else raise exception.Create(rsWrongSyntaxALLOCIdentifierSizeinbytes);
          end;


          //replace ALLOC identifiers with values so the assemble error check doesnt crash on that
          if processhandler.is64bit then
          begin
            for j:=0 to length(allocs)-1 do
              currentline:=replacetoken(currentline,allocs[j].varname,'ffffffffffffffff');
          end
          else
          begin
            for j:=0 to length(allocs)-1 do
              currentline:=replacetoken(currentline,allocs[j].varname,'00000000');
          end;



          {$ifndef net}

          //memory kalloc
          {$ifdef windows}
          if uppercase(copy(currentline,1,7))='KALLOC(' then
          begin
            if not DBKReadWrite then raise exception.Create(rsNeedToUseKernelmodeReadWriteprocessmemory);

            if DBKLoaded=false then
              raise exception.Create(rsSorryButWithoutTheDriverKALLOCWillNotFunction);

            //syntax: kalloc(x,size)    x=variable name size=bytes
            //kallocate memory
            a:=pos('(',currentline);
            b:=pos(',',currentline);
            c:=pos(')',currentline);

            if (a>0) and (b>0) and (c>0) then
            begin
              s1:=trim(copy(currentline,a+1,b-a-1));
              s2:=trim(copy(currentline,b+1,c-b-1));

              val('$'+s1,j,a);
              if a=0 then raise exception.Create(Format(rsIsNotAValidIdentifier, [s1]));

              varsize:=length(s1);

              //check for duplicate identifiers
              j:=0;
              while (j<length(kallocs)) and (length(kallocs[j].varname)>varsize) do
              begin
                if kallocs[j].varname=s1 then
                  raise exception.Create(Format(rsTheIdentifierHasAlreadyBeenDeclared, [s1]));

                inc(j);
              end;

              j:=length(kallocs);//quickfix

              setlength(kallocs,length(kallocs)+1);

              //longest varnames first so the rename of a shorter matching var wont override the longer one
              //move up the other kallocs so I can inser this element (A linked list might have been better)
              for k:=length(kallocs)-1 downto j+1 do
                kallocs[k]:=kallocs[k-1];

              kallocs[j].varname:=s1;
              kallocs[j].size:=StrToInt(s2);

              setlength(assemblerlines,length(assemblerlines)-1);   //don't bother with this in the 2nd pass
              continue;
            end else raise exception.Create(rsWrongSyntaxKallocIdentifierSizeinbytes);
          end;
          {$endif}

          {$endif}

          //replace KALLOC identifiers with values so the assemble error check doesnt crash on that
          {$ifdef windows}
          if processhandler.is64bit then
          begin
            for j:=0 to length(kallocs)-1 do
              currentline:=replacetoken(currentline,kallocs[j].varname,'ffffffffffffffff');
          end
          else
          begin
            for j:=0 to length(kallocs)-1 do
              currentline:=replacetoken(currentline,kallocs[j].varname,'00000000');
          end;
          {$endif}



          //check for assembler errors
          //address

          if currentline[length(currentline)]=':' then
          begin
            try
              ok1:=false;
              for j:=0 to length(labels)-1 do
                if currentline=labels[j].labelname+':' then
                begin
                  labels[j].assemblerline:=length(assemblerlines)-1;
                  ok1:=true;
                  continue;
                end;

              if ok1 then continue; //no check


              //still here, so more complex
              if syntaxcheckonly and (disableinfo<>nil) then
              begin
                //replace tokens with registered symbols from the enable part
                for j:=0 to disableinfo.registeredsymbols.count-1 do
                  currentline:=replacetoken(currentline, disableinfo.registeredsymbols[j], '00000000');
              end;

              try
                s1:=copy(currentline,1,length(currentline)-1);

                if s1<>'' then
                  testPtr:=symhandler.getAddressFromName(s1);


              except
                currentline:=inttohex(symhandler.getaddressfromname(copy(currentline,1,length(currentline)-1)),8)+':';
                assemblerlines[length(assemblerlines)-1].linenr:=currentlinenr;
                assemblerlines[length(assemblerlines)-1].line:=currentline;
              end;


            except
              //add this as a label if a potential label
              if potentiallabels.IndexOf(copy(currentline,1,length(currentline)-1))=-1 then
                raise symexception.Create(rsThisAddressSpecifierIsNotValid);

              j:=length(labels);
              setlength(labels,j+1);
              ZeroMemory(@labels[j],sizeof(labels[j]));

              labels[j].labelname:=copy(currentline,1,length(currentline)-1);
              labels[j].assemblerline:=length(assemblerlines)-1;
              labels[j].defined:=false;

              setlength(labels[j].references,0);
              setlength(labels[j].references2,0);

              //setlength(assemblerlines, length(assemblerlines)-1);
//              assemblerlines[length(assemblerlines)-1]:='';

//              continue;

              //raise exception.Create(rsThisAddressSpecifierIsNotValid);
            end;

            continue; //next line
          end;

          //replace label references with 00000000 so the assembler check doesn't complain about it

          if processhandler.is64bit then
          begin
            for j:=0 to length(labels)-1 do
              currentline:=replacetoken(currentline,labels[j].labelname,'ffffffffffffffff');
          end
          else
          begin
            for j:=0 to length(labels)-1 do
              currentline:=replacetoken(currentline,labels[j].labelname,'00000000');
          end;





          try
            //replace identifiers in the line with their address
            ok1:=false;
            try
              ok1:=assemble(currentline,currentaddress,assembled[0].bytes, apNone, true);
            except
            end;

            if not ok1 then //the instruction could not be assembled as it is right now
            begin
              //try potential labels
              ok1:=false;

              for j:=0 to potentiallabels.count-1 do
              begin
                if processhandler.is64bit then
                  currentline:=replacetoken(currentline,potentiallabels[j],'ffffffffffffffff')
                else
                  currentline:=replacetoken(currentline,potentiallabels[j],'00000000');

                try
                  ok1:=assemble(currentline,currentaddress,assembled[0].bytes, apNone, true);
                  if ok1 then
                  begin
                    //define this potential label as a full label
                    k:=length(labels);
                    setlength(labels, k+1);
                    ZeroMemory(@labels[k],sizeof(labels[k]));
                    labels[k].labelname:=potentiallabels[j];
                    labels[k].defined:=false;
                    labels[k].afterccode:=false;
                    setlength(labels[k].references,0);
                    setlength(labels[k].references2,0);

                    break;
                  end;
                except
                  //don't quit yet
                  on e: exception do
                  begin
                    OutputDebugString('Potential labeling error:'+e.message);
                  end
                end;
              end;



            end;

            if not ok1 then
              raise EAutoAssembler.Create('bla');
          except
            //ShowMessage(code.text);
            raise EAutoAssembler.Create(rsThisInstructionCanTBeCompiled);
          end;

        finally
          inc(i);
        end;

      except
        on E:exception do
          raise EAutoAssembler.Create(Format(rsErrorInLine, [IntToStr(currentlinenr), currentline, e.Message]));

      end;
    end;

    if length(addsymbollist)>0 then
    begin
      //now scan the addsymbollist entries for allocs and labels and see if they exist
      for i:=0 to length(addsymbollist)-1 do
      begin
        ok1:=false;
        for j:=0 to length(allocs)-1 do  //scan allocs
          if uppercase(addsymbollist[i])=uppercase(allocs[j].varname) then
          begin
            ok1:=true;
            break;
          end;

        if not ok1 then //scan labels
          for j:=0 to length(labels)-1 do
            if uppercase(addsymbollist[i])=uppercase(labels[j].labelname) then
            begin
              ok1:=true;
              break;
            end;

        if not ok1 then //scan defines
          for j:=0 to length(defines)-1 do
            if uppercase(addsymbollist[i])=uppercase(defines[j].name) then
            begin
              ok1:=true;
              break;
            end;

        if not ok1 then raise EAssemblerException.create(Format(rsWasSupposedToBeAddedToTheSymbollistButItIsnTDeclar, [addsymbollist[i]]));
      end;
    end;

    //check to see if the addresses are valid (label, alloc, define)
    if length(createthread)>0 then
      for i:=0 to length(createthread)-1 do
      begin
        ok1:=true;
        try
          testptr:=symhandler.getAddressFromName(createthread[i]);
        except
          ok1:=false;
        end;

        if not ok1 then
          for j:=0 to length(labels)-1 do
            if uppercase(labels[j].labelname)=uppercase(createthread[i]) then
            begin
              ok1:=true;
              break;
            end;

        if not ok1 then
          for j:=0 to length(allocs)-1 do
            if uppercase(allocs[j].varname)=uppercase(createthread[i]) then
            begin
              ok1:=true;
              break;
            end;

        {$ifndef net}
        if not ok1 then
          for j:=0 to length(kallocs)-1 do
            if uppercase(kallocs[j].varname)=uppercase(createthread[i]) then
            begin
              ok1:=true;
              break;
            end;
        {$endif}

        if not ok1 then
          for j:=0 to length(defines)-1 do
            if uppercase(defines[j].name)=uppercase(createthread[i]) then
            begin
              try
                testptr:=symhandler.getAddressFromName(defines[j].whatever);
                ok1:=true;
              except
              end;
              break;
            end;

        if not ok1 then raise EAssemblerException.create(Format(rsTheAddressInCreatethreadIsNotValid, [createthread[i]]));

      end;

    if length(createthreadandwait)>0 then
      for i:=0 to length(createthreadandwait)-1 do
      begin
        ok1:=true;

        try
          testptr:=symhandler.getAddressFromName(createthreadandwait[i].name);
        except
          ok1:=false;
        end;

        if not ok1 then
          for j:=0 to length(labels)-1 do
            if uppercase(labels[j].labelname)=uppercase(createthreadandwait[i].name) then
            begin
              ok1:=true;
              break;
            end;

        if not ok1 then
          for j:=0 to length(allocs)-1 do
            if uppercase(allocs[j].varname)=uppercase(createthreadandwait[i].name) then
            begin
              ok1:=true;
              break;
            end;

        {$ifndef net}
        if not ok1 then
          for j:=0 to length(kallocs)-1 do
            if uppercase(kallocs[j].varname)=uppercase(createthreadandwait[i].name) then
            begin
              ok1:=true;
              break;
            end;
        {$endif}

        if not ok1 then
          for j:=0 to length(defines)-1 do
            if uppercase(defines[j].name)=uppercase(createthreadandwait[i].name) then
            begin
              try
                testptr:=symhandler.getAddressFromName(defines[j].whatever);
                ok1:=true;
              except
              end;
              break;
            end;

        if not ok1 then
        begin
          raise EAssemblerException.create(Format(rsTheAddressInCreatethreadAndWaitIsNotValid, [createthreadandwait[i].name]));
        end;

      end;

    if length(loadbinary)>0 then
      for i:=0 to length(loadbinary)-1 do
      begin
        ok1:=true;

        try
          testptr:=symhandler.getAddressFromName(loadbinary[i].address);
        except
          ok1:=false;
        end;

        if not ok1 then
          for j:=0 to length(labels)-1 do
            if uppercase(labels[j].labelname)=uppercase(loadbinary[i].address) then
            begin
              ok1:=true;
              break;
            end;

        if not ok1 then
          for j:=0 to length(allocs)-1 do
            if uppercase(allocs[j].varname)=uppercase(loadbinary[i].address) then
            begin
              ok1:=true;
              break;
            end;

        {$ifndef net}
        if not ok1 then
          for j:=0 to length(kallocs)-1 do
            if uppercase(kallocs[j].varname)=uppercase(loadbinary[i].address) then
            begin
              ok1:=true;
              break;
            end;
        {$endif}

        if not ok1 then
          for j:=0 to length(defines)-1 do
            if uppercase(defines[j].name)=uppercase(loadbinary[i].address) then
            begin
              try
                testptr:=symhandler.getAddressFromName(defines[j].whatever);
                ok1:=true;
              except
              end;
              break;
            end;

        if not ok1 then raise EAssemblerException.create(Format(rsTheAddressInLoadbinaryIsNotValid, [loadbinary[i].address, loadbinary[i].filename]));

      end;

    {
    //check for the 3th alloc parameter when testing the validity of the script, and ask if the user understands what will happen
    if popupmessages and processhandler.is64Bit and usesaobscan and (length(allocs)>0) then
    begin
      //check if a prefered address is used
      prefered:=0;

      for i:=0 to length(allocs)-1 do
        if allocs[i].prefered<>0 then
        begin
          prefered:=allocs[i].prefered;
          break;
        end;

      if (prefered=0) and (MessageDlg(rsNoPreferedRangeAllocWarning, mtWarning, [mbyes, mbno], 0)<>mryes) then
        exit(false);
    end;}

    if syntaxcheckonly then
      exit(true);

    {$ifndef jni}
    if popupmessages and (messagedlg(rsThisCodeCanBeInjectedAreYouSure, mtConfirmation, [mbyes, mbno], 0)<>mryes) then exit;
    {$endif}

    //allocate the memory

    if length(allocs)>0 then
    begin
      //move ceinternal_autofree allocs to the end
      k:=length(allocs);

      i:=0;
      while i<k do
      begin
        if allocs[i].varname.StartsWith('ceinternal_autofree') then
        begin
          //move it to the back
          tempalloc:=allocs[i];
          for j:=i to length(allocs)-2 do
            allocs[j]:=allocs[j+1];

          allocs[length(allocs)-1]:=tempalloc;
          dec(k);
        end
        else inc(i);
      end;


      j:=0; //entry to go from
      prefered:=allocs[0].prefered;
      protection:=allocs[0].protection;
      x:=allocs[0].size;

      for i:=1 to length(allocs)-1 do
      begin
        //does this entry have a prefered location or a non default protection

        if allocs[i].protection<>protection then
        begin
          //increment x to the next pagebase
          {$ifdef windows}
          if (x and $fff>0) then
          begin
            y:=$1000- (x and $fff);
            inc(x,y);
            inc(allocs[i-1].size,y); //adjust the previous entry's size
          end;
          {$else}
          if (x and (getPageSize-1)>0) then
          begin
            y:=getPageSize- (x and (getPageSize-1));
            inc(x,y);
            inc(allocs[i-1].size,y); //adjust the previous entry's size
          end;
          {$endif}

          protection:=allocs[i].protection;
        end;

        if (allocs[i].prefered<>0) then
        begin
          //if yes, is it the same as the previous entry? (or was the previous one that doesn't care?)
          if prefered=0 then
            prefered:=allocs[i].prefered;

          if (prefered<>allocs[i].prefered) then
          begin
            //different prefered address

            if x>0 then //it has some previous entries with compatible locations
            begin
              k:=10;
              allocs[j].address:=0;
              while (k>0) and (allocs[j].address=0) do
              begin
                //try allocating until a memory region has been found (e.g due to quick allocating by the game)

                if (prefered=0) and (j>0) then //if not a prefered address but there is a previous alloc, allocate near there
                  prefered:=allocs[j-1].address;

                oldprefered:=prefered;
                prefered:=ptrUint(FindFreeBlockForRegion(prefered,x));

                if (prefered=0) and (oldprefered<>0) then
                  prefered:=oldprefered;

                if SystemSupportsWritableExecutableMemory then
                  allocs[j].address:=ptrUint(virtualallocex(processhandle,pointer(prefered),x, MEM_RESERVE or MEM_COMMIT,PAGE_EXECUTE_READWRITE))
                else
                  allocs[j].address:=ptrUint(virtualallocex(processhandle,pointer(prefered),x, MEM_RESERVE or MEM_COMMIT,PAGE_READWRITE));
                if allocs[j].address=0 then
                begin
                  OutputDebugString(rsFailureToAllocateMemory+' 1');
                  inc(prefered,65536);
                end;

                dec(k);
              end;

              if allocs[j].address=0 then
                allocs[j].address:=lastChanceAllocPrefered(prefered,x, protection);

              if allocs[j].address=0 then
              begin
                if WarnOnNearbyAllocationFailure then
                begin
                  with TAllocWarn.create do
                  begin
                    if allocs[j].prefered<>0 then
                      preferedaddress:=allocs[j].prefered
                    else
                      preferedaddress:=prefered;

                    warn;
                    free;
                  end;
                end;

                if NearbyAllocationFailureFatal then
                  raise EAssemblerException.create(format(rsFailureAlloc, [prefered,allocs[j].varname]))
                else
                begin
                  if SystemSupportsWritableExecutableMemory then
                    allocs[j].address:=ptrUint(virtualallocex(processhandle,nil,x, MEM_RESERVE or MEM_COMMIT,PAGE_EXECUTE_READWRITE))
                  else
                    allocs[j].address:=ptrUint(virtualallocex(processhandle,nil,x, MEM_RESERVE or MEM_COMMIT,PAGE_READWRITE));
                end;
              end;

              if allocs[j].address=0 then raise EAssemblerException.create(rsFailureToAllocateMemory);

              //adjust the addresses of entries that are part of this block
              for k:=j+1 to i-1 do
                allocs[k].address:=allocs[k-1].address+allocs[k-1].size;
              x:=0;
            end;

            //new prefered address
            j:=i;
            prefered:=allocs[i].prefered;
            protection:=allocs[i].protection;
          end;

        end;

        //no prefered location specified, OR same prefered location


        inc(x,allocs[i].size);
      end; //after the loop


      if x>0 then
      begin
        //adjust the address of entries that are part of this final block
        k:=10;
        allocs[j].address:=0;

        while (k>0) and (allocs[j].address=0) do
        begin
          i:=0;

          if (prefered=0) and (j>0) then //if not a prefered address but there is a previous alloc, allocate near there
            prefered:=allocs[j-1].address;

          oldprefered:=prefered;
          prefered:=ptrUint(FindFreeBlockForRegion(prefered,x));

          if (prefered=0) and (oldprefered<>0) then
            prefered:=oldprefered;

          if SystemSupportsWritableExecutableMemory then
            allocs[j].address:=ptrUint(virtualallocex(processhandle,pointer(prefered),x, MEM_RESERVE or MEM_COMMIT,PAGE_EXECUTE_READWRITE))
          else
            allocs[j].address:=ptrUint(virtualallocex(processhandle,pointer(prefered),x, MEM_RESERVE or MEM_COMMIT,PAGE_READWRITE));

          if allocs[j].address=0 then
          begin
            OutputDebugString(rsFailureToAllocateMemory+' 3 (prefered='+inttohex(prefered,8)+')');
            inc(prefered, 65536);
          end;
          dec(k);
        end;

        if allocs[j].address=0 then
          allocs[j].address:=lastChanceAllocPrefered(prefered,x, protection);

        if allocs[j].address=0 then
        begin
          if WarnOnNearbyAllocationFailure then
          begin
            with TAllocWarn.create do
            begin
              if allocs[j].prefered<>0 then
                preferedaddress:=allocs[j].prefered
              else
                preferedaddress:=prefered;
              warn;
              free;
            end;
          end;

          if NearbyAllocationFailureFatal then
            raise EAssemblerException.create(format(rsFailureAlloc, [prefered,allocs[j].varname]))
          else
          begin
            if SystemSupportsWritableExecutableMemory then
              allocs[j].address:=ptrUint(virtualallocex(processhandle,nil,x, MEM_RESERVE or MEM_COMMIT,PAGE_EXECUTE_READWRITE))
            else
              allocs[j].address:=ptrUint(virtualallocex(processhandle,nil,x, MEM_RESERVE or MEM_COMMIT,PAGE_READWRITE));
          end;
        end;

         // allocs[j].address:=ptrUint(virtualallocex(processhandle,nil,x, MEM_RESERVE or MEM_COMMIT,protection));

        if allocs[j].address=0 then raise EAssemblerException.create(rsFailureToAllocateMemory);

        for i:=j+1 to length(allocs)-1 do
          allocs[i].address:=allocs[i-1].address+allocs[i-1].size;


      end;

      //apply protections:
      for i:=0 to length(allocs)-1 do
      begin
        if (not SystemSupportsWritableExecutableMemory) or (allocs[i].protection<>PAGE_EXECUTE_READWRITE) then
          VirtualProtectEx(processhandle, pointer(allocs[i].address), allocs[i].size, allocs[i].protection,protection);
      end;
    end;

    {$ifdef windows}
    {$ifndef net}
    //kernel alloc
    if length(kallocs)>0 then
    begin
      x:=0;
      for i:=0 to length(kallocs)-1 do
       inc(x,kallocs[i].size);

      kallocs[0].address:=ptrUint(KernelAlloc(x));

      for i:=1 to length(kallocs)-1 do
        kallocs[i].address:=kallocs[i-1].address+kallocs[i-1].size;
    end;
    {$endif}
    {$endif}


    //-----------------------2nd pass------------------------
    //assemblerlines only contains label specifiers and assembler instructions

    setlength(assembled,0);
    currentlinenr:=0;
    try
      for i:=0 to length(assemblerlines)-1 do
      begin
        currentline:=assemblerlines[i].line;
        currentlinenr:=assemblerlines[i].linenr;

        createthreadandwaitid:=-1;
        for j:=0 to length(createthreadandwait)-1 do //there can be multiple at the time of assembly.  All entries up to the higest value will be picked at a blockwrite (and made 0 so next blockwrite won't do them)
        begin
          if (i>createthreadandwait[j].position) or (i=length(Assemblerlines)-1) then //if it's the last line, then do all remaining
            createthreadandwaitid:=j;
        end;

        //plugin
        {$ifndef jni}
        if length(currentline)>0 then
        begin
          currentlinep:=@currentline[1];
          pluginhandler.handleAutoAssemblerPlugin(@currentlinep, 2,aaid);
          currentline:=currentlinep;
          //if handled currentline will have it's identifiers regarding the plugin's previously registered stuff replaced
          //note that this can be called in a multithreaded situation, so the plugin must hld storage containers on a threadid base and handle the locking itself
        end;
        {$endif}
        //plugin



        tokenize(currentline,tokens);
        //if alloc then replace with the address
        for j:=0 to length(allocs)-1 do
          currentline:=replacetoken(currentline,allocs[j].varname,IntToHex(allocs[j].address,8));

        //if kalloc then replace with the address
        for j:=0 to length(kallocs)-1 do
          currentline:=replacetoken(currentline,kallocs[j].varname,IntToHex(kallocs[j].address,8));

        for j:=0 to length(defines)-1 do
          currentline:=replacetoken(currentline,defines[j].name,defines[j].whatever);

        ok1:=false;
        if currentline[length(currentline)]<>':' then //if it's not a definition then
        begin
          for j:=0 to length(labels)-1 do
          begin
            if (tokencheck(currentline,labels[j].labelname)) then
            begin
              //this instruction references a label
              if not labels[j].defined then
              begin
                //the address hasn't been found yet
                //this is the part that causes those nops after a short jump below the current instruction

                //problem: The size of these instructions determine where this label will be defined

                //close
                s1:=replacetoken(currentline,labels[j].labelname,IntToHex(currentaddress,8));

                //far and big

                if processhandler.SystemArchitecture=archarm then
                begin
                  currentline:=replacetoken(currentline,labels[j].labelname,IntToHex(currentaddress+$4FFFFF8,8));
                end
                else
                begin
                  if (processhandler.is64Bit) then //and not in region
                  begin
                    //check if between here and the definition of labels[j].labelname is an write pointer change specifier to a region too far away from currentaddress, if not, LONG will suffice

                    //tip: you 'could' disassemble everything inbetween and see if a small jmp is possible as well (just a lot slower)

                    mustbefar:=false;
                    for l:=i+1 to length(assemblerlines)-1 do
                    begin
                      currentline2:=assemblerlines[l].line;
                      if currentline2=labels[j].labelname+':' then break; //reached the label

                      if currentline2[length(currentline2)]=':' then
                      begin
                        //check if it's just a label or alloc in the same group
                        for k:=0 to length(defines)-1 do
                          currentline2:=replacetoken(currentline2,defines[k].name,defines[k].whatever);


                        s2:=copy(currentline2,1,length(currentline2)-1);
                        for k:=0 to length(allocs)-1 do
                        begin
                          if allocs[k].varname=s2 then
                          begin
                            if currentaddress>allocs[k].address then
                              diff:=currentaddress-allocs[k].address
                            else
                              diff:=allocs[k].address-currentaddress;

                            if diff>=$80000000 then
                            begin
                              mustbefar:=true;
                              break;
                            end;
                          end;
                        end;

                        if mustbefar then break;

                        for k:=0 to length(kallocs)-1 do
                        begin
                          if kallocs[k].varname=s2 then
                          begin
                            if currentaddress>kallocs[k].address then
                              diff:=currentaddress-kallocs[k].address
                            else
                              diff:=kallocs[k].address-currentaddress;

                            if diff>=$80000000 then
                            begin
                              mustbefar:=true;
                              break;
                            end;
                          end;
                        end;

                        if mustbefar then break;

                        //if it's a label it's ok
                        ok1:=false;
                        for k:=0 to length(labels)-1 do
                        begin
                          if labels[k].labelname=s2 then
                          begin
                            ok1:=true;
                            break;
                          end;
                        end;

                        if ok1 then continue; //it's a label, no need to do a heavy symbol lookup

                        //not an alloc or kalloc
                        try
                          testptr:=getAddressFromScript(s2);
                          if testptr=0 then
                            testptr:=symhandler.getAddressFromName(s2);

                          if currentaddress>testptr then
                            diff:=currentaddress-testptr
                          else
                            diff:=testptr-currentaddress;

                          if diff>=$80000000 then
                          begin
                            mustbefar:=true;
                            break;
                          end;

                        except
                          mustbefar:=true;
                        end;


                        if mustbefar then break;
                      end;
                    end;

                    if mustbefar=false then
                    begin
                      if dataForAACodePass2.cdata.cscript<>nil then
                      begin
                        for k:=0 to length(dataForAACodePass2.cdata.symbols)-1 do
                        begin
                          if lowercase(labels[j].labelname)=lowercase(dataForAACodePass2.cdata.symbols[k].name) then
                          begin
                            //the c code could be outside reach from the current point
                            testptr:=getAddressFromScript('ceinternal_autofree_ccode');
                            if currentaddress>testptr then
                              diff:=currentaddress-testptr
                            else
                              diff:=testptr-currentaddress;

                            if diff>=$80000000 then
                              mustbefar:=true;

                            break;
                          end;
                        end;
                      end;
                    end;

                    if mustbefar then
                      currentline:=replacetoken(currentline,labels[j].labelname,IntToHex(currentaddress+$2000FFFFF,8))
                    else
                      currentline:=replacetoken(currentline,labels[j].labelname,IntToHex(currentaddress+$FFFFF,8));
                  end
                  else
                    currentline:=replacetoken(currentline,labels[j].labelname,IntToHex(currentaddress+$FFFFF,8));
                end;


                setlength(assembled,length(assembled)+1);
                assembled[length(assembled)-1].createthreadandwait:=createthreadandwaitid;
                assembled[length(assembled)-1].address:=currentaddress;
                ok1:=assemble(currentline,currentaddress,assembled[length(assembled)-1].bytes, apnone, true); //far
                a:=length(assembled[length(assembled)-1].bytes);
                ok2:=assemble(s1,currentaddress,assembled[length(assembled)-1].bytes, apnone, true); //close
                b:=length(assembled[length(assembled)-1].bytes);

                if not (ok1 or ok2) then
                  raise exception.create(assemblerlines[l].line+' can not be assembled');

                if a>b then //pick the biggest one
                  assemble(currentline,currentaddress,assembled[length(assembled)-1].bytes);

                //add this instruction to the list of lines that reference this label
                setlength(labels[j].references,length(labels[j].references)+1);
                labels[j].references[length(labels[j].references)-1]:=length(assembled)-1;

                setlength(labels[j].references2,length(labels[j].references2)+1);
                labels[j].references2[length(labels[j].references2)-1]:=i;

                inc(currentaddress,length(assembled[length(assembled)-1].bytes));
                ok1:=true;
              end else currentline:=replacetoken(currentline,labels[j].labelname,IntToHex(labels[j].address,8));

              //break;
            end;
          end;
        end;

        if ok1 then continue;

        if currentline[length(currentline)]=':' then //address setter/assigner
        begin
          ok1:=false;
          for j:=0 to length(labels)-1 do
          begin
            if i=labels[j].assemblerline then
            begin
              if labels[j].defined=true then
              begin
                currentaddress:=labels[j].address
              end
              else
              begin
                labels[j].address:=currentaddress;
                labels[j].defined:=true;
              end;
              ok1:=true;


              //reassemble the instructions that had no target
              for k:=0 to length(labels[j].references)-1 do
              begin
                a:=length(assembled[labels[j].references[k]].bytes); //original size of the assembled code
                s1:=replacetoken(assemblerlines[labels[j].references2[k]].line,labels[j].labelname,IntToHex(labels[j].address,8));
                {$ifdef cpu64}
                if processhandler.is64Bit then
                  ok1:=assemble(s1,assembled[labels[j].references[k]].address,assembled[labels[j].references[k]].bytes)
                else
                {$endif}
                  ok1:=assemble(s1,assembled[labels[j].references[k]].address,assembled[labels[j].references[k]].bytes, apLong);

                if not ok1 then raise exception.create(format(rsFailureAssembling,[s1, assembled[labels[j].references[k]].address]));

                b:=length(assembled[labels[j].references[k]].bytes); //new size
                setlength(assembled[labels[j].references[k]].bytes,a); //original size (original size is always bigger or equal than newsize)

                if b>a then
                begin
                  raise exception.create('Assembler error. The generated instruction referencing a label ended up bigger than expected. Try using the far indicator');
                end;

                if (b<a) and (a<12) then //try to grow the instruction as some people cry about nops (unless it was a megajmp/call as those are less efficient)
                begin
                  //try a bigger one
                  assemble(s1,assembled[labels[j].references[k]].address,nops, apLong);
                  if length(nops)=a then //found a match size
                  begin
                    copymemory(@assembled[labels[j].references[k]].bytes[0], @nops[0], a);
                    b:=a;
                  end;

                end;


                //fill the difference with nops (not the most efficient approach, but it should work)
                if processhandler.SystemArchitecture=archarm then
                begin
                  for l:=0 to ((a-b+3) div 4)-1 do
                    pdword(@assembled[labels[j].references[k]].bytes[b+l*4])^:=$e1a00000;      //<mov r0,r0: (nop equivalent)
                end
                else
                begin
  //              todo:  if a-b>8 then replace with the far version
                  assemble('nop '+inttohex(a-b,1),0,nops);

                  for l:=b to a-1 do
                    assembled[labels[j].references[k]].bytes[l]:=nops[l-b];

  //                for l:=b to a-1 do
  //                  assembled[labels[j].references[k]].bytes[l]:=$90; //nop

                end;
              end;


              break;
            end;
          end;
          if ok1 then continue;

          try
            currentaddress:=symhandler.getAddressFromName(copy(currentline,1,length(currentline)-1));
            continue; //next line
          except
            raise EAssemblerException.create(rsThisAddressSpecifierIsNotValid);
          end;
        end;


        setlength(assembled,length(assembled)+1);
        assembled[length(assembled)-1].address:=currentaddress;
        assembled[length(assembled)-1].createthreadandwait:=createthreadandwaitid;

        if (currentline<>'') and (currentline[1]='<') then //special assembler instruction
        begin

          if copy(currentline,1,8)='<READMEM' then
          begin
            //lets try this for once
            sscanf(currentline, '<READMEM%d>', [@l]);
            setlength(assembled[length(assembled)-1].bytes, readmems[l].bytelength);
            CopyMemory(@assembled[length(assembled)-1].bytes[0], readmems[l].bytes, readmems[l].bytelength);
          end
          {$ifdef onebytejumps}
          else
          if copy(currentline,1,6)='<JMP1 ' then
          begin
            s1:=copy(currentline,7);
            s1:=copy(s1,1,length(s1)-1);

            setlength(onebytejumps, length(onebytejumps)+1);
            onebytejumps[length(onebytejumps)-1].destinationlabel:=s1;
            onebytejumps[length(onebytejumps)-1].originaddress:=currentaddress;

            setlength(assembled[length(assembled)-1].bytes,1);
            assembled[length(assembled)-1].bytes[0]:=$cc;
          end
          {$endif}
          else
          begin
            assemble(currentline,currentaddress,assembled[length(assembled)-1].bytes);
          end;
        end
        else
        begin
          if assemble(currentline,currentaddress,assembled[length(assembled)-1].bytes) =false then
            raise exception.create(Format(rsFailureAssembling, [currentline, currentaddress]));
        end;

        inc(currentaddress,length(assembled[length(assembled)-1].bytes));
      end;

    except
      on e:exception do
        raise EAssemblerException.create(inttostr(currentlinenr)+':'+e.message);
    end;
    //end of loop

    ok2:=true;

    //unprotectmemory
    if SystemSupportsWritableExecutableMemory then
    begin
      for i:=0 to length(fullaccess)-1 do
      begin
        virtualprotectex(processhandle,pointer(fullaccess[i].address),fullaccess[i].size,PAGE_EXECUTE_READWRITE,op);

        {$ifdef windows}
        if (fullaccess[i].address>$80000000) and (DBKLoaded) then
          MakeWritable(fullaccess[i].address,(fullaccess[i].size div 4096)*4096,false);
        {$endif}
      end;
    end;

    //load binaries
    if length(loadbinary)>0 then
    begin
      for i:=0 to length(loadbinary)-1 do
      begin
        testptr:=getAddressFromScript(loadbinary[i].address);

        if testptr<>0 then
        begin
          binaryfile:=tmemorystream.Create;
          try
            binaryfile.LoadFromFile(loadbinary[i].filename);
            if (CurrentDebuggerInterface is TGDBServerDebuggerInterface) and GDBWriteProcessMemoryCodeOnly then
              ok2:=TGDBServerDebuggerInterface(CurrentDebuggerInterface).writeBytes(testptr, binaryfile.Memory, binaryfile.size)
            else
              ok2:=writeprocessmemory(processhandle,pointer(testptr),binaryfile.Memory,binaryfile.Size,x);
          finally
            binaryfile.free;
          end;
        end
        else
          raise exception.create('Failure ');
      end;
    end;

    //fill in the addresses requested by dataForAACodePass2 and finish the compilation
    if dataForAACodePass2.cdata.cscript<>nil then
    begin
      dataForAACodePass2.cdata.address:=getAddressFromScript('ceinternal_autofree_ccode'); //warning: do not step over this with the debugger
      for i:=0 to length(dataForAACodePass2.cdata.references)-1 do
      begin
        dataForAACodePass2.cdata.references[i].address:=getAddressFromScript(dataForAACodePass2.cdata.references[i].name);
        if dataForAACodePass2.cdata.references[i].address=0 then
        begin
          OutputDebugString('Failure getting reference for '+dataForAACodePass2.cdata.references[i].name);
        end;
      end;

      if disableinfo<>nil then
        AutoassemblerCodePass2(dataForAACodePass2, disableinfo.ccodesymbols)
      else
        AutoassemblerCodePass2(dataForAACodePass2, nil);

      if disableinfo<>nil then
      begin
        if targetself then
          selfsymhandler.AddSymbolList(disableinfo.ccodesymbols)
        else
          symhandler.AddSymbolList(disableinfo.ccodesymbols);

        disableinfo.sourcecodeinfo:=dataForAACodePass2.cdata.sourceCodeInfo;

        if disableinfo.sourcecodeinfo<>nil then
          disableinfo.sourcecodeinfo.register;
      end
      else
      begin
        //else do not register the symbols (You can't disable them otherwise)
        freeandnil(dataForAACodePass2.cdata.sourceCodeInfo);
      end;


      //reassemble c-code reference
      for j:=0 to length(labels)-1 do
      begin
        if labels[j].afterccode then
        begin
          ok1:=false;
          for k:=0 to length(dataForAACodePass2.cdata.symbols)-1 do
          begin
            if labels[j].labelname=dataForAACodePass2.cdata.symbols[k].name then
            begin
              labels[j].address:=dataForAACodePass2.cdata.symbols[k].address;
              labels[j].defined:=true;
              ok1:=labels[j].address<>0;
              break;
            end;
          end;
          if not ok1 then raise exception.create('Failure getting the address for c-symbol '+labels[j].labelname);

          //todo: change to a function so both originallabel and this can use it
          for k:=0 to length(labels[j].references)-1 do
          begin
            a:=length(assembled[labels[j].references[k]].bytes); //original size of the assembled code
            s1:=replacetoken(assemblerlines[labels[j].references2[k]].line,labels[j].labelname,IntToHex(labels[j].address,8));
            {$ifdef cpu64}
            if processhandler.is64Bit then
              assemble(s1,assembled[labels[j].references[k]].address,assembled[labels[j].references[k]].bytes)
            else
            {$endif}
            assemble(s1,assembled[labels[j].references[k]].address,assembled[labels[j].references[k]].bytes, apLong);

            b:=length(assembled[labels[j].references[k]].bytes); //new size
            setlength(assembled[labels[j].references[k]].bytes,a); //original size (original size is always bigger or equal than newsize)

            if (b<a) and (a<12) then //try to grow the instruction as some people cry about nops (unless it was a megajmp/call as those are less efficient)
            begin
              //try a bigger one
              assemble(s1,assembled[labels[j].references[k]].address,nops, apLong);
              if length(nops)=a then //found a match size
              begin
                copymemory(@assembled[labels[j].references[k]].bytes[0], @nops[0], a);
                b:=a;
              end;
            end;


            //fill the difference with nops (not the most efficient approach, but it should work)
            if processhandler.SystemArchitecture=archarm then
            begin
              for l:=0 to ((a-b+3) div 4)-1 do
                pdword(@assembled[labels[j].references[k]].bytes[b+l*4])^:=$e1a00000;      //<mov r0,r0: (nop equivalent)
            end
            else
            begin
              assemble('nop '+inttohex(a-b,1),0,nops);

              for l:=b to a-1 do
                assembled[labels[j].references[k]].bytes[l]:=nops[l-b];
            end;
          end;
        end;
      end;
    end;


    //we're still here so inject the rest of it
    //addresses are known here, so parse the exception list if there is one


    if (length(exceptionlist)>0) {$ifdef onebytejumps}or (length(onebytejumps)>0){$endif} then
      InitializeAutoAssemblerExceptionHandler;


    if length(exceptionlist)>0 then
      for i:=length(exceptionlist)-1 downto 0 do //add it in the reverse order so the nested try/excepts come first
        AutoAssemblerExceptionHandlerAddExceptionRange(getAddressFromScript(exceptionlist[i].trylabel), getAddressFromScript(exceptionlist[i].exceptlabel));

    {$ifdef onebytejumps}
    if length(onebytejumps)>0 then
      for i:=0 to length(onebytejumps)-1 do
        AutoAssemblerExceptionHandlerAddChangeRIPEntry(onebytejumps[i].originaddress, getAddressFromScript(onebytejumps[i].destinationlabel));
    {$endif}

    if (length(exceptionlist)>0) {$ifdef onebytejumps}or (length(onebytejumps)>0){$endif} then
      AutoAssemblerExceptionHandlerApplyChanges;

    {$ifdef windows}

    connection:=getconnection;
    if connection<>nil then
      connection.beginWriteProcessMemory; //group all writes
    {$endif}

    //combine assembly lines
    j:=0;
    for i:=1 to length(assembled)-1 do
    begin
      if assembled[i].address=assembled[j].address+length(assembled[j].bytes) then //matches the previous entry
      begin
        //group
        k:=length(assembled[j].bytes);
        setlength(assembled[j].bytes, k+length(assembled[i].bytes));
        copymemory(@assembled[j].bytes[k], @assembled[i].bytes[0], length(assembled[i].bytes));

        assembled[j].createthreadandwait:=max(assembled[j].createthreadandwait, assembled[i].createthreadandwait); //should always pick i


        //mark it as empty
        setlength(assembled[i].bytes,0);
        assembled[i].address:=0;
        assembled[i].createthreadandwait:=-1;
      end
      else
      begin
        j:=i; //new block
      end;
    end;

    if (not SystemSupportsWritableExecutableMemory) and (not SkipVirtualProtectEx) and (ProcessID<>GetCurrentProcessId) then
    begin
      if (CurrentDebuggerInterface is TGDBServerDebuggerInterface) then
        TGDBServerDebuggerInterface(CurrentDebuggerInterface).suspendProcess
      else
        ntsuspendProcess(processhandle);
    end;


    for i:=0 to length(assembled)-1 do
    begin
      if length(assembled[i].bytes)=0 then continue;

      testptr:=assembled[i].address;

      op:=0;
      if SystemSupportsWritableExecutableMemory or SkipVirtualProtectEx then
        vpe:=(SkipVirtualProtectEx=false) and virtualprotectex(processhandle,pointer(testptr),length(assembled[i].bytes),PAGE_EXECUTE_READWRITE,op)
      else
        vpe:=(SkipVirtualProtectEx=false) and virtualprotectex(processhandle,pointer(testptr),length(assembled[i].bytes),PAGE_READWRITE,op);

      if vpe then
        outputdebugstring('autoassemble: original protection was '+op.ToString);

      if (CurrentDebuggerInterface is TGDBServerDebuggerInterface) and GDBWriteProcessMemoryCodeOnly then
        ok1:=TGDBServerDebuggerInterface(CurrentDebuggerInterface).writeBytes(testptr, @assembled[i].bytes[0], length(assembled[i].bytes))
      else
        ok1:={$ifdef windows}WriteProcessMemoryWithCloakSupport{$else}WriteProcessMemory{$endif}(processhandle, pointer(testptr),@assembled[i].bytes[0],length(assembled[i].bytes),x);

      if vpe then
        virtualprotectex(processhandle,pointer(testptr),length(assembled[i].bytes),op,op2);

      if not ok1 then ok2:=false;

      if ok2 and (assembled[i].createthreadandwait<>-1) then
      begin
        //create threads
        for j:=0 to assembled[i].createthreadandwait do
        begin
          if createthreadandwait[j].position<>-1 then
            HandleCreateThreadAndWait(j);
        end;
      end;
    end;

    if (not SystemSupportsWritableExecutableMemory) and (not SkipVirtualProtectEx) and (ProcessID<>GetCurrentProcessId) then
    begin
      if (CurrentDebuggerInterface is TGDBServerDebuggerInterface) then
        TGDBServerDebuggerInterface(CurrentDebuggerInterface).resumeProcess
      else
        ntresumeProcess(processhandle);
    end;


    {$ifdef windows}
    if connection<>nil then  //group all writes
    begin
      if connection.endWriteProcessMemory=false then
        ok2:=false;
    end;
    {$endif}


    //handle the unhandled createthreadandwait blocks
    for i:=0 to length(createthreadandwait)-1 do
    begin
      if createthreadandwait[i].position<>-1 then
        HandleCreateThreadAndWait(i);
    end;






    if not ok2 then
    begin
      {$ifndef jni}
      if popupmessages then showmessage(rsNotAllInstructionsCouldBeInjected)
      else
      begin
        if memrec<>nil then //there is an memrec provided, so also an ewxception handler
          raise exception.create(rsNotAllInstructionsCouldBeInjected);
      end;
      {$endif}


    end
    else
    begin
      if disableinfo<>nil then
      begin
        //see if all allocs are deallocated
        for i:=0 to length(disableinfo.allocs)-1 do
        begin
          //free the ceinternal_autofree entries (if they aren't already marked)
          if disableinfo.allocs[i].varname.StartsWith('ceinternal_autofree') then
          begin
            ok1:=false;
            for j:=0 to length(dealloc)-1 do
            begin
              if dealloc[j]=disableinfo.allocs[i].address then
              begin
                ok1:=true;
                break;
              end;
            end;


            if ok1=false then //not in the list yet, add it
            begin
              j:=length(dealloc);
              setlength(dealloc, j+1);
              dealloc[j]:=disableinfo.allocs[i].address;
            end;
          end;
        end;

        if (length(dealloc)>0) and (length(dealloc)=length(disableinfo.allocs)) then //free everything
        begin
          {$ifdef cpu64}
          baseaddress:=ptrUint($FFFFFFFFFFFFFFFF);
          {$else}
          baseaddress:=$FFFFFFFF;
          {$endif}

          for i:=0 to length(disableinfo.allocs)-1 do
          begin
            virtualfreeex(processhandle,pointer(dealloc[i]),0,MEM_RELEASE);
            if (targetself=false) and allocsAddToUnexpectedExceptionList then
              RemoveUnexpectedExceptionRegion(dealloc[i],0);
{            if ceallocarray[i].address<baseaddress then
              baseaddress:=ceallocarray[i].address;}
          end;

          //virtualfreeex(processhandle,pointer(baseaddress),0,MEM_RELEASE);

          disableinfo.ccodesymbols.clear;
          disableinfo.ccodesymbols.unregisterList;

          freeandnil(disableinfo.sourcecodeinfo);
        end;

        setlength(disableinfo.allocs,length(allocs));
        for i:=0 to length(allocs)-1 do
          disableinfo.allocs[i]:=allocs[i];


        if (length(disableinfo.exceptions)>0) and (AutoAssemblerExceptionHandlerHasEntries) then
        begin
          for i:=0 to length(disableinfo.exceptions)-1 do
            AutoAssemblerExceptionHandlerRemoveExceptionRange(disableinfo.exceptions[i]);

          AutoAssemblerExceptionHandlerApplyChanges;
        end;

        setlength(disableinfo.exceptions, length(exceptionlist));
        for i:=0 to length(disableinfo.exceptions)-1 do
          disableinfo.exceptions[i]:=getAddressFromScript(exceptionlist[i].trylabel);
      end;
      //check the addsymbollist array and deletesymbollist array

      //first delete
      for i:=0 to length(deletesymbollist)-1 do
        symhandler.DeleteUserdefinedSymbol(deletesymbollist[i]);

      //now scan the addsymbollist array and add them to the userdefined list
      for i:=0 to length(addsymbollist)-1 do
      begin
        ok1:=false;
        for j:=0 to length(allocs)-1 do
          if uppercase(addsymbollist[i])=uppercase(allocs[j].varname) then
          begin
            try
              symhandler.DeleteUserdefinedSymbol(addsymbollist[i]); //delete old one so you can add the new one
              symhandler.AddUserdefinedSymbol(inttohex(allocs[j].address,8),addsymbollist[i], true);
              ok1:=true;
            except
              //don't crash when it's already defined or address=0
            end;

            break;
          end;

        if not ok1 then
          for j:=0 to length(labels)-1 do
            if uppercase(addsymbollist[i])=uppercase(labels[j].labelname) then
            begin
              try
                symhandler.DeleteUserdefinedSymbol(addsymbollist[i]); //delete old one so you can add the new one
                symhandler.AddUserdefinedSymbol(inttohex(labels[j].address,8),addsymbollist[i], true);
                ok1:=true;
              except
                //don't crash when it's already defined or address=0
              end;

            end;

        if not ok1 then
          for j:=0 to length(defines)-1 do
            if uppercase(addsymbollist[i])=uppercase(defines[j].name) then
            begin
              try
                symhandler.DeleteUserdefinedSymbol(addsymbollist[i]); //delete old one so you can add the new one
                symhandler.AddUserdefinedSymbol(defines[j].whatever, addsymbollist[i], true);
                ok1:=true;
              except
              end;
            end;
      end;

      //still here, so create threads if needed
      if length(createthread)>0 then
      begin
        for i:=0 to length(createthread)-1 do
        begin
          testptr:=getAddressFromScript(createthread[i]);
          ok1:=testptr<>0;

          if ok1 then //address found
          begin
            try
              threadhandle:=createremotethread(processhandle,nil,0,pointer(testptr),nil,0,bw);
              ok2:=threadhandle>0;

              if ok2 then
                closehandle(threadhandle);
            finally
            end;
          end;
        end;
      end;  //^ thread creation

      //fill "allSymbols"
      if disableinfo<>nil then
      begin
        for i:=0 to length(labels)-1 do
          disableinfo.allsymbols.AddObject(labels[i].labelname, tobject(labels[i].address));

        for i:=0 to length(allocs)-1 do
          disableinfo.allsymbols.AddObject(allocs[i].varname, tobject(allocs[i].address));

        for i:=0 to length(kallocs)-1 do
          disableinfo.allsymbols.AddObject(kallocs[i].varname, tobject(kallocs[i].address));

        for i:=0 to length(defines)-1 do
        begin
          testptr:=symhandler.getAddressFromName(defines[i].whatever,false,ok1);
          if ok1=false then
            disableinfo.allsymbols.AddObject(defines[i].name, tobject(testptr));
        end;
      end;


      {$IFNDEF jni}
      if popupmessages then
      begin
        testPtr:=0;

        s1:='';
        for i:=0 to length(globalallocs)-1 do
        begin
          if testPtr=0 then testPtr:=globalallocs[i].address;

          s1:=s1+#13#10+globalallocs[i].varname+'='+IntToHex(globalallocs[i].address,8);
        end;


        for i:=0 to length(allocs)-1 do
        begin
          if allocs[i].varname.StartsWith('ceinternal_') then continue; //don't show these

          if testPtr=0 then testPtr:=allocs[i].address;
          s1:=s1+#13#10+allocs[i].varname+'='+IntToHex(allocs[i].address,8);
        end;

        if length(kallocs)>0 then
        begin
          if testPtr=0 then testPtr:=kallocs[i].address;

          s1:=#13#10+rsTheFollowingKernelAddressesWhereAllocated+':';
          for i:=0 to length(kallocs)-1 do
            s1:=s1+#13#10+kallocs[i].varname+'='+IntToHex(kallocs[i].address,8);
        end;

       // if messagedl
        if (testPtr=0) or (oldaamessage) then
          showmessage(rsTheCodeInjectionWasSuccessfull+s1)
        else
        begin
          if MessageDlg(rsTheCodeInjectionWasSuccessfull+s1+#13#10+rsGoTo+inttohex(testptr,8)+'?', mtInformation,[mbYes, mbNo], 0, mbno)=mrYes then
          begin
            memorybrowser.disassemblerview.selectedaddress:=testptr;
            memorybrowser.show;
          end;
        end;
      end;
      {$ENDIF}
    end;

    result:=ok2;

    if result and allocsAddToUnexpectedExceptionList and (not targetself) then
    begin
      for i:=0 to length(allocs)-1 do
        AddUnexpectedExceptionRegion(allocs[i].address,allocs[i].size);
    end;

  finally
    if dataForAACodePass2.cdata.cscript<>nil then
      freeandnil(dataForAACodePass2.cdata.cscript);

    for i:=0 to length(assembled)-1 do
      setlength(assembled[i].bytes,0);

    setlength(assembled,0);

    for i:=0 to length(readmems)-1 do
      if readmems[i].bytes<>nil then
      begin
        freememandnil(readmems[i].bytes);

      end;

    setlength(readmems,0);


    if tokens<>nil then
      freeandnil(tokens);

    {$IFNDEF jni}
    if pluginhandler<>nil then
      pluginhandler.handleAutoAssemblerPlugin(@currentlinep, 3,aaid); //tell the plugins to free their data

    if targetself then
    begin
      processhandler.processid:=oldprocessid;
      processhandler.processhandle:=oldhandle;
      symhandler:=oldsymhandler;
    end;
    {$ENDIF}

    if potentiallabels<>nil then
      freeandnil(potentiallabels);
  end;
end;

function getenableanddisablepos(code:tstrings;var enablepos,disablepos: integer): boolean;
var i,j: integer;
    currentline: string;
begin
  result:=false;
  enablepos:=-1;
  disablepos:=-1;

  for i:=0 to code.Count-1 do
  begin
    currentline:=code[i];
    j:=pos('//',currentline);
    if j>0 then
      currentline:=copy(currentline,1,j-1);

    while (length(currentline)>0) and (currentline[1]=' ') do currentline:=copy(currentline,2,length(currentline)-1);
    while (length(currentline)>0) and (currentline[length(currentline)]=' ') do currentline:=copy(currentline,1,length(currentline)-1);

    if length(currentline)=0 then continue;
    if copy(currentline,1,2)='//' then continue; //skip

    if (uppercase(currentline))='[ENABLE]' then
    begin
      result:=true; //there's at least a enable section, so it's ok
      if enablepos<>-1 then
      begin
        enablepos:=-2;
        exit;
      end;

      enablepos:=i;
    end;

    if (uppercase(currentline))='[DISABLE]' then
    begin
      if disablepos<>-1 then
      begin
        disablepos:=-2;
        exit;
      end;

      disablepos:=i;
    end;

  end;
end;


procedure getEnableOrDisableScript(code: TStrings; newscript: tstrings; enablescript: boolean);
{
removes the enable or disable section from a script leaving only the outer code and the selected script routine
}
var
  i: integer;
  insideenable: boolean;
  insidedisable: boolean;
begin
  insideenable:=false;
  insidedisable:=false;

  for i:=0 to code.Count-1 do
  begin
    if (uppercase(trim(code[i])))='[ENABLE]' then
    begin
      insideenable:=true;
      insidedisable:=false;
      continue;
    end;

    if (uppercase(trim(code[i])))='[DISABLE]' then
    begin
      insideenable:=false;
      insidedisable:=true;
      continue;
    end;

    //
    if ((not insideenable) and (not insidedisable)) or
       (insideenable and enablescript) or
       (insidedisable and not enablescript) then newscript.AddObject(code[i], code.Objects[i]);



  end;

end;

procedure stripCPUspecificCode(code: tstrings; strip32bit: boolean);
var i: integer;
  s: string;
  inexcludedbitblock: boolean;

begin
  inexcludedbitblock:=false;
  for i:=0 to code.Count-1 do
  begin
    s:=uppercase(Trim(code[i]));

    if s='[32-BIT]' then
    begin
      if strip32bit then
        inexcludedbitblock:=true;

      code[i]:=' ';
    end;

    if s='[/32-BIT]' then
    begin
      if strip32bit then
        inexcludedbitblock:=false;

      code[i]:=' ';
    end;

    if s='[64-BIT]' then
    begin
      if not strip32bit then
        inexcludedbitblock:=true;

      code[i]:=' ';
    end;

    if s='[/64-BIT]' then
    begin
      if not strip32bit then
        inexcludedbitblock:=false;
      code[i]:=' ';
    end;

    if inexcludedbitblock then
      code[i]:=' ';



  end;
end;

function autoassemble(code: Tstrings; popupmessages,enable,syntaxcheckonly, targetself: boolean; disableinfo: TDisableinfo=nil; memrec: TMemoryRecord=nil): boolean; overload;
{
targetself defines if the process that gets injected to is CE itself or the target process
}
var tempstrings: tstringlist;
    i,j: integer;
    currentline: string;
    enablepos,disablepos: integer;

    strip32bitcode: boolean;
begin
  //add line numbers to the code
  for i:=0 to code.Count-1 do
    code.Objects[i]:=pointer(i+1);

  getenableanddisablepos(code,enablepos,disablepos);

  result:=false;

  if enablepos=-2 then
  begin
    raise EAssemblerException.create(rsYouCanOnlyHaveOneEnableSection);
  end;

  if disablepos=-2 then
  begin
    raise EAssemblerException.create(rsYouCanOnlyHaveOneDisableSection);
  end;

  tempstrings:=tstringlist.create;
  try
    if (enablepos=-1) and (disablepos=-1) then
    begin
      //everything
      tempstrings.AddStrings(code);
    end
    else
    begin
      if (enablepos=-1) then
      begin
        if not popupmessages then exit;
        raise EAssemblerException.create(rsYouHavnTSpecifiedAEnableSection);

      end;

      if (disablepos=-1) then
      begin
        if not popupmessages then exit;
        raise EAssemblerException.create(rsYouHavnTSpecifiedADisableSection);

      end;

      if enable then
      begin
        getEnableOrDisableScript(code, tempstrings, true);
      end
      else
      begin
        getEnableOrDisableScript(code, tempstrings,false);
      end;
    end;

    strip32bitcode:=processhandler.is64Bit;
    if targetself then
      strip32bitcode:={$ifdef cpu64}true{$else}false{$endif};

    Stripcpuspecificcode(tempstrings, strip32bitcode); //todo: change to set for other types like arm

    result:=autoassemble2(tempstrings,popupmessages,syntaxcheckonly,targetself, disableinfo, memrec);
  finally
    tempstrings.Free;
  end;
end;

function autoassemble(code: tstrings;popupmessages: boolean):boolean; overload;
begin
  result:=autoassemble(code,popupmessages,true,false,false);
end;


end.