U8 *LexStmt2Bin(CCmpCtrl *cc,I64 *_type,I64 cmp_flags=0)
{//Compile one cc stmt to bin code.
  I64 size,i,j,k,*res=INVALID_PTR;
  CCodeCtrl *tmpcbh;
  if (_type) *_type=RT_I64;
  Btr(&cc->flags,CCf_PASS_TRACE_PRESENT);
  if (cc->aot_depth==2)
    COCPush(cc);
  COCInit(cc);
  if (!PrsStmt(cc,,,cmp_flags)) {
    if (cc->coc.coc_head.next!=&cc->coc.coc_head) {
      cc->coc.coc_head.last->ic_flags&=~ICF_RES_NOT_USED;
      ICAdd(cc,IC_RETURN_VAL2,0,0);
      ICAdd(cc,IC_RET,0,0);
      if (res=COCCompile(cc,&size,NULL,_type)) {
        if (cc->flags&CCF_AOT_COMPILE) {
          j=cc->aotc->rip;
          k=(size+7)>>3;
          for (i=0;i<k;i++)
            AOTStoreCodeU64(cc,res[i]);
          Free(res);
          res=j;
        }
      }
    } //TODO: else del misc?
  } else //TODO: too dangerous to del Misc?
    QueDel(&cc->coc.coc_head.next);
  if (cc->aot_depth==2) {
    tmpcbh=COCPopNoFree(cc);
    COCAppend(cc,tmpcbh);
  }
  return res;
}

CAOT *CmpJoin(CCmpCtrl *cc,I64 cmp_flags,U8 *map_name=NULL,U8 mapfile_drv_let=0)
{
  CAOTCtrl *aotc,*old_aot=cc->aotc;
  I64 i,j,l;
  U8 *buf;
  CAOTBinBlk *tmpbin;
  CAOTImportExport *tmpie;
  Bool okay=TRUE;
  CLexHashTableContext *htc=MAlloc(sizeof(CLexHashTableContext));
  CAOT *res=CAlloc(sizeof(CAOT)),*parent;
  if (parent=cc->aot) {
    res->parent_aot=parent;
    QueIns(res,parent->last);
  } else
    QueInit(res);
  cc->aot=res;

  res->next_ie=res->last_ie=&res->next_ie;
  cc->aotc=aotc=CAlloc(sizeof(CAOTCtrl));
  cc->aot_depth++;

  aotc->bin=CAlloc(sizeof(CAOTBinBlk));
  aotc->max_align_bits=0;
  aotc->org=INVALID_PTR;

  MemCpy(htc,&cc->htc,sizeof(CLexHashTableContext));
  if (cc->htc.fun)
    cc->htc.glbl_hash_table=HashTableNew(128);
  else
    cc->htc.glbl_hash_table=HashTableNew(1024);
  if (cc->flags&CCF_AOT_COMPILE) {
    cc->htc.define_hash_table=cc->htc.glbl_hash_table;
    if (cc->aot_depth<=1)
      cc->htc.glbl_hash_table->next=cmp.asm_hash;
    else
      cc->htc.glbl_hash_table->next=htc->glbl_hash_table;
  } else
    cc->htc.glbl_hash_table->next=Fs->hash_table;
  cc->htc.hash_table_lst=cc->htc.local_hash_table=HashTableNew(16);
  cc->htc.local_hash_table->next=cc->htc.glbl_hash_table;
  cc->htc.local_var_lst=cc->htc.fun; //HolyC local vars
  cc->htc.fun=NULL;
  try {
    if (cmp_flags&CMPF_LEX_FIRST)
      Lex(cc);
    if (!(cmp_flags&CMPF_ONE_ASM_INS))
      cmp_flags|=CMPF_PRS_SEMICOLON;
    if (cc->flags&CCF_AOT_COMPILE) {
      while (cc->token!=TK_EOF) {
        buf=LexStmt2Bin(cc,NULL,cmp_flags);
        if (buf!=INVALID_PTR) {
          tmpie=CAlloc(sizeof(CAOTImportExport));
          tmpie->type=IET_MAIN;
          tmpie->rip=buf;
          QueIns(tmpie,res->last_ie);
        }
        if (cmp_flags&CMPF_ASM_BLK)
          break;
      }
    } else
      PrsStmt(cc,,,cmp_flags);
    AOTGlblsResolve(cc,res);
  } catch {
    if (Fs->except_ch=='Compiler' && !(cmp_flags&CMPF_ASM_BLK)) {
      LexPutPos(cc);
      Fs->catch_except=TRUE;
    }
    okay=FALSE;
  }
  if (!okay) {
    if (cc->error_cnt<1)
      cc->error_cnt=1;
    cc->aot=res->parent_aot;
    Free(res);
    LinkedLstDel(aotc->bin);
    res=NULL;
  } else {
    if (map_name)
      MapFileWrite(cc->htc.glbl_hash_table,map_name,mapfile_drv_let);
    HashTableDel(cc->htc.local_hash_table);
    HashTableDel(cc->htc.glbl_hash_table);

    if (!aotc->num_bin_U8s)
      res->buf=NULL;
    else {
      if (cc->flags&CCF_AOT_COMPILE)
        res->buf=MAlloc(aotc->num_bin_U8s);
      else {
        if (aotc->org==INVALID_PTR)
          res->buf=MAlloc(aotc->num_bin_U8s,Fs->code_heap);
        else
          res->buf=aotc->org;
      }
      res->aot_U8s=aotc->num_bin_U8s;
      tmpbin=aotc->bin;
      j=0;
      l=aotc->num_bin_U8s;
      while (tmpbin) {
        i=l;
        if (i>AOT_BIN_BLK_SIZE)
          i=AOT_BIN_BLK_SIZE;
        MemCpy(res->buf+j,tmpbin->body,i);
        j+=i;
        l-=i;
        tmpbin=tmpbin->next;
      }
    }
    LinkedLstDel(aotc->bin);
    res->abss=aotc->abss;
    res->heap_glbls=aotc->heap_glbls;
    res->max_align_bits=aotc->max_align_bits;
    res->org=aotc->org;
  }
  cc->aot=parent;
  MemCpy(&cc->htc,htc,sizeof(CLexHashTableContext));
  Free(htc);
  Free(aotc);
  cc->aotc=old_aot;
  cc->aot_depth--;
  return res;
}

CAOT *CmpBuf(U8 *buf,U8 *map_name=NULL,
  I64 *error_cnt=NULL, I64 *warning_cnt=NULL,U8 mapfile_drv_let=0)
{
  CCmpCtrl *cc;
  CAOT *res=NULL;
  cc=CmpCtrlNew(buf,CCF_DONT_FREE_BUF);
  cc->flags|=CCF_AOT_COMPILE;
  QueIns(cc,Fs->last_cc);
  res=CmpJoin(cc,CMPF_LEX_FIRST,map_name,mapfile_drv_let);
  if (error_cnt)   *error_cnt=cc->error_cnt;
  if (warning_cnt) *warning_cnt=cc->warning_cnt;
  QueRem(cc);
  if (res)
    CmpCtrlDel(cc);
  return res;
}

U0 CmpFixUpJITAsm(CCmpCtrl *cc,CAOT *tmpaot)
{
  I64 i,rip2=tmpaot->buf+tmpaot->rip,*str=NULL;
  U8 *ptr;
  CCodeMisc *g_lb;
  CAOTAbsAddr *tmpa,*tmpa1;
  CAOTImportExport *tmpie,*tmpie1;
  CHashExport *tmpex;

  tmpa=tmpaot->abss;
  while (tmpa) {
    tmpa1=tmpa->next;
    ptr=rip2+tmpa->rip;
    switch [tmpa->type] {
      case AAT_ADD_U8:  *ptr(U8 *) +=rip2; break;
      case AAT_SUB_U8:  *ptr(U8 *) -=rip2; break;
      case AAT_ADD_U16: *ptr(U16 *)+=rip2; break;
      case AAT_SUB_U16: *ptr(U16 *)-=rip2; break;
      case AAT_ADD_U32: *ptr(U32 *)+=rip2; break;
      case AAT_SUB_U32: *ptr(U32 *)-=rip2; break;
      case AAT_ADD_U64: *ptr(I64 *)+=rip2; break;
      case AAT_SUB_U64: *ptr(I64 *)-=rip2; break;
    }
    Free(tmpa);
    tmpa=tmpa1;
  }
  tmpie=tmpaot->next_ie;
  while (tmpie!=&tmpaot->next_ie) {
    tmpie1=tmpie->next;
    if (tmpie->str) {
      Free(str);
      str=tmpie->str;
    }
    switch (tmpie->type) {
      case IET_REL32_EXPORT:
      case IET_IMM32_EXPORT:
      case IET_REL64_EXPORT:
      case IET_IMM64_EXPORT:
        tmpex=CAlloc(sizeof(CHashExport));
        tmpex->str=str;
        str=NULL;
        tmpex->type=HTT_EXPORT_SYS_SYM|HTF_IMM;
        if (tmpie->type==IET_IMM32_EXPORT||tmpie->type==IET_IMM64_EXPORT)
          tmpex->val=tmpie->rip;
        else
          tmpex->val=tmpie->rip+rip2;
        tmpex->src_link=tmpie->src_link;
        tmpie->src_link=NULL;
        HashAdd(tmpex,Fs->hash_table);
        SysSymImportsResolve(tmpex->str);
        break;
      case IET_REL_I0...IET_IMM_I64:
        if (tmpie->str) {
          if (tmpie->flags&IEF_GOTO_LABEL) {
            if(!(g_lb=COCGoToLabelFind(cc,str)))
              "Unresolved Reference:%s\n",str;
            else {
              g_lb->use_cnt++;
              g_lb=OptLabelFwd(g_lb);
              i=g_lb->addr+tmpaot->buf;
            }
            tmpex=NULL;
          } else {
            if (!(tmpex=HashFind(str,Fs->hash_table,
                  HTG_ALL-HTT_IMPORT_SYS_SYM)))
              "Unresolved Reference:%s\n",str;
            else {
              if (tmpex->type & HTT_FUN)
                i=tmpex(CHashFun *)->exe_addr;
              else if (tmpex->type & HTT_GLBL_VAR)
                i=tmpex(CHashGlblVar *)->data_addr;
              else
                i=tmpex->val;
            }
            g_lb=NULL;
          }
        }
        if (tmpex || g_lb) {
          ptr=tmpie->rip+rip2;
          switch [tmpie->type] {
            case IET_REL_I0:
            case IET_IMM_U0:
              break;
            case IET_REL_I8:
              if (!(I8_MIN<=i-ptr-1<=I8_MAX))
                LexExcept(cc,"Branch out of range at ");
              *ptr(U8 *) =i-ptr-1;
              break;
            case IET_IMM_U8:
              *ptr(U8 *) =i;
              break;
            case IET_REL_I16:
              if (!(I16_MIN<=i-ptr-2<=I16_MAX))
                LexExcept(cc,"Branch out of range at ");
              *ptr(U16 *)=i-ptr-2;
              break;
            case IET_IMM_U16:
              *ptr(U16 *)=i;
              break;
            case IET_REL_I32:
              if (!(I32_MIN<=i-ptr-4<=I32_MAX))
                LexExcept(cc,"Branch out of range at ");
              *ptr(U32 *)=i-ptr-4;
              break;
            case IET_IMM_U32:
              *ptr(U32 *)=i;
              break;
            case IET_REL_I64:
              *ptr(I64 *)=i-ptr-8;
              break;
            case IET_IMM_I64:
              *ptr(I64 *)=i;
              break;
          }
        }
        break;
    }
    Free(tmpie->src_link);
    Free(tmpie);
    tmpie=tmpie1;
  }
  Free(str);
  if (!cc->aot_depth && Bt(&cc->opts,OPTf_TRACE))
    Un(rip2,tmpaot->aot_U8s,64);
  QueRem(tmpaot);
  Free(tmpaot);
}

U0 CmpFixUpAOTAsm(CCmpCtrl *cc,CAOT *tmpaot)
{
  CAOTCtrl *aotc=cc->aotc;
  I64 i,rip2=tmpaot->rip+cc->aotc->rip;
  U8 *ptr;
  CCodeMisc *g_lb=NULL;
  CAOTAbsAddr *tmpa,*tmpa1;
  CAOTImportExport *tmpie,*tmpie1;

  tmpa=tmpaot->abss;
  while (tmpa) {
    tmpa1=tmpa->next;
    tmpa->next=aotc->abss;
    ptr=tmpaot->buf+tmpaot->rip+tmpa->rip;
    switch [tmpa->type] {
      case AAT_ADD_U8:  *ptr(U8 *)+=rip2;       break;
      case AAT_SUB_U8:  *ptr(U8 *)-=rip2;       break;
      case AAT_ADD_U16: *ptr(U16 *)+=rip2;      break;
      case AAT_SUB_U16: *ptr(U16 *)-=rip2;      break;
      case AAT_ADD_U32: *ptr(U32 *)+=rip2;      break;
      case AAT_SUB_U32: *ptr(U32 *)-=rip2;      break;
      case AAT_ADD_U64: *ptr(I64 *)+=rip2;      break;
      case AAT_SUB_U64: *ptr(I64 *)-=rip2;      break;
    }
    aotc->abss=tmpa;
    tmpa->rip+=rip2;
    tmpa=tmpa1;
  }

  tmpie=tmpaot->next_ie;
  while (tmpie!=&tmpaot->next_ie) {
    tmpie1=tmpie->next;
    QueRem(tmpie);
    if (IET_REL_I0<=tmpie->type<=IET_IMM_I64) {
      if (tmpie->str) {
        if (tmpie->flags&IEF_GOTO_LABEL) {
          if(!(g_lb=COCGoToLabelFind(cc,tmpie->str)))
            "Unresolved Reference:%s\n",tmpie->str;
          else {
            g_lb->use_cnt++;
            g_lb=OptLabelFwd(g_lb);
          }
        } else
          g_lb=NULL;
      }
    } else
      g_lb=NULL;

    ptr=tmpaot->buf+tmpaot->rip+tmpie->rip;
    if (g_lb) {
      i=g_lb->addr+tmpaot->buf;
      switch [tmpie->type] {
        case IET_REL_I0:
        case IET_IMM_U0:
          break;
        case IET_REL_I8:
          if (!(I8_MIN<=i-ptr-1<=I8_MAX))
            LexExcept(cc,"Branch out of range at ");
          *ptr(U8 *) =i-ptr-1;
          break;
        case IET_IMM_U8:
          *ptr(U8 *) =i;
          break;
        case IET_REL_I16:
          if (!(I16_MIN<=i-ptr-2<=I16_MAX))
            LexExcept(cc,"Branch out of range at ");
          *ptr(U16 *)=i-ptr-2;
          break;
        case IET_IMM_U16:
          *ptr(U16 *)=i;
          break;
        case IET_REL_I32:
          if (!(I32_MIN<=i-ptr-4<=I32_MAX))
            LexExcept(cc,"Branch out of range at ");
          *ptr(U32 *)=i-ptr-4;
          break;
        case IET_IMM_U32:
          *ptr(U32 *)=i;
          break;
        case IET_REL_I64:
          *ptr(I64 *)=i-ptr-8;
          break;
        case IET_IMM_I64:
          *ptr(I64 *)=i;
          break;
      }
      Free(tmpie->src_link);
      Free(tmpie);
    } else {
      switch (tmpie->type) {
        start:
          case IET_REL32_EXPORT:
          case IET_IMM32_EXPORT:
          case IET_REL64_EXPORT:
          case IET_IMM64_EXPORT:
          case IET_IMM_U0:
          case IET_IMM_U8:
          case IET_IMM_U16:
          case IET_IMM_U32:
          case IET_IMM_I64:
          case IET_REL_I0:
            break;
          case IET_REL_I8:          *ptr(U8 *) -=rip2;      break;
          case IET_REL_I16:         *ptr(U16 *)-=rip2;      break;
          case IET_REL_I32:         *ptr(U32 *)-=rip2;      break;
          case IET_REL_I64:         *ptr(I64 *)-=rip2;      break;
        end:
          tmpie->rip+=rip2;
          break;
      }
      tmpie->aot=NULL;
      QueIns(tmpie,tmpaot->parent_aot->last_ie);
    }
    tmpie=tmpie1;
  }
}

I64 Cmp(U8 *filename,U8 *map_name=NULL,U8 *out_name=NULL,U8 mapfile_drv_let=0)
{//AOT Compile HC or PRJ file a and output BIN file. Returns err_cnt.
  U8 *ptr,*fbuf=NULL,*fbuf2=NULL,*fbuf3=NULL,
        *patch_table=MAlloc(0x20000);
  CAOT *tmpaot;
  I64 i,cnt,size=0,error_cnt=0,warning_cnt=0,aot_U8s=0;
  CBinFile *bfh;
  CAOTImportExport *tmpie,*tmpie1;
  CAOTAbsAddr *tmpa,*tmpa1;
  CAOTHeapGlblRef *tmphgr,*tmphgr1;
  CAOTHeapGlbl *tmphg,*tmphg1;

  fbuf=ExtDft(filename,"PRJ.Z");
  fbuf2=MStrPrint("#include \"%s\"",fbuf);
  if (map_name)
    fbuf3=ExtDft(map_name,"MAP.Z");

  if (tmpaot=CmpBuf(fbuf2,fbuf3,&error_cnt,&warning_cnt,mapfile_drv_let)) {
    aot_U8s=tmpaot->aot_U8s;
    ptr=patch_table;
//See Load()
    cnt=0;
    tmpa=tmpaot->abss;
    while (tmpa) {
      if (!(tmpa->type&IEF_IMM_NOT_REL))
        cnt++;
      tmpa=tmpa->next;
    }
    if (cnt) {
      *ptr++=IET_ABS_ADDR;
      *ptr(U32 *)++=cnt;
      *ptr++=0;
      tmpa=tmpaot->abss;
      while (tmpa) {
        tmpa1=tmpa->next;
        if (!(tmpa->type&IEF_IMM_NOT_REL))
          *ptr(U32 *)++ =tmpa->rip;
        Free(tmpa);
        tmpa=tmpa1;
      }
    }
    tmphg=tmpaot->heap_glbls;
    while (tmphg) {
      tmphg1=tmphg->next;
      cnt=0;
      tmphgr=tmphg->references;
      while (tmphgr) {
        cnt++;
        tmphgr=tmphgr->next;
      }
      if (cnt) {
        *ptr++=IET_DATA_HEAP;
        *ptr(U32 *)++=cnt;
        if (tmphg->str) {
          i=StrLen(tmphg->str);
          MemCpy(ptr,tmphg->str,i+1);
          Free(tmphg->str);
          ptr+=i+1;
        } else
          *ptr++=0;
        *ptr(I64 *)++=tmphg->size;
        tmphgr=tmphg->references;
        while (tmphgr) {
          tmphgr1=tmphgr->next;
          *ptr(U32 *)++=tmphgr->rip;
          Free(tmphgr);
          tmphgr=tmphgr1;
        }
      }
      Free(tmphg);
      tmphg=tmphg1;
    }

    //Do exports first
    tmpie=tmpaot->next_ie;
    while (tmpie!=&tmpaot->next_ie) {
      tmpie1=tmpie->next;
      if (!tmpie->type || IET_REL32_EXPORT<=tmpie->type<=IET_IMM64_EXPORT) {
        QueRem(tmpie);
        *ptr++=tmpie->type;
        *ptr(U32 *)++=tmpie->rip;
        if (tmpie->str) {
          i=StrLen(tmpie->str);
          MemCpy(ptr,tmpie->str,i+1);
          Free(tmpie->str);
          ptr+=i+1;
        } else
          *ptr++=0;
        Free(tmpie->src_link);
        Free(tmpie);
      }
      tmpie=tmpie1;
    }

    //Do imports second
    tmpie=tmpaot->next_ie;
    while (tmpie!=&tmpaot->next_ie) {
      tmpie1=tmpie->next;
      QueRem(tmpie);
      *ptr++=tmpie->type;
      if (tmpie->aot)
        tmpie->rip+=tmpie->aot->rip2;
      *ptr(U32 *)++=tmpie->rip;
      if (tmpie->str) {
        i=StrLen(tmpie->str);
        MemCpy(ptr,tmpie->str,i+1);
        Free(tmpie->str);
        ptr+=i+1;
      } else
        *ptr++=0;
      Free(tmpie->src_link);
      Free(tmpie);
      tmpie=tmpie1;
    }

    *ptr++=IET_END;
    MemSet(ptr,0,16);
    i=ptr-patch_table;
//Needs 16 ALIGN
    size=(sizeof(CBinFile)+aot_U8s+i+15)&-16;
    bfh=MAlloc(size);
    bfh->jmp=0xEB+256*(sizeof(CBinFile)-2);
#assert sizeof(CBinFile)-2<=I8_MAX
    bfh->reserved=0;
    bfh->bin_signature=BIN_SIGNATURE_VAL;
    bfh->org=tmpaot->org;
    bfh->module_align_bits=tmpaot->max_align_bits;
    bfh->patch_table_offset=sizeof(CBinFile)+aot_U8s;
    bfh->file_size=size;
    MemCpy(bfh(U8 *)+sizeof(CBinFile),tmpaot->buf,aot_U8s);
    MemCpy(bfh(U8 *)+sizeof(CBinFile)+aot_U8s,patch_table,
          size-aot_U8s-sizeof(CBinFile));
    Free(fbuf2);
    if (out_name)
      fbuf2=ExtDft(out_name,"BIN.Z");
    else
      fbuf2=ExtChg(fbuf,"BIN.Z");
    FileWrite(fbuf2,bfh,size);
    Free(bfh);
    Free(tmpaot->buf);
    QueDel(tmpaot);
    Free(tmpaot);
  }
  Free(patch_table);
  Free(fbuf);
  Free(fbuf2);
  Free(fbuf3);
  Print("Errs:%d Warns:%d Code:%X Size:%X\n",
        error_cnt,warning_cnt,aot_U8s,size);
  return error_cnt;
}

I64 ExePutS(U8 *buf,U8 *filename=NULL,
        I64 ccf_flags=0,CLexHashTableContext *htc=NULL)
{//JIT Compile and execute text from a puts("").
  I64 res;
  Bool okay=TRUE;
  CCmpCtrl *cc;
  if (!filename)
    filename=blkdev.tmp_filename;
  cc=CmpCtrlNew(buf,ccf_flags|CCF_DONT_FREE_BUF,filename);
  if (Fs->last_cc!=&Fs->next_cc) {
    cc->opts=Fs->last_cc->opts;
    if (htc) {
      cc->flags=cc->flags &~CCF_ASM_EXPRESSIONS |
            htc->old_flags&CCF_ASM_EXPRESSIONS;
      MemCpy(&cc->htc,htc,sizeof(CLexHashTableContext));
    }
  }
  QueIns(cc,Fs->last_cc);
  try {
    Lex(cc);
    res=ExeCmdLine(cc);
  } catch {
    if (Fs->except_ch=='Compiler' || Fs->except_ch=='Break') {
      Fs->catch_except=TRUE;
      okay=FALSE;
      res=0;
    }
  }
  QueRem(cc);
  if (okay)
    CmpCtrlDel(cc); //TODO: can crash
  return res;
}

I64 ExePrint(U8 *fmt,...)
{//JIT Compile and execute text from a printf().
  I64 res;
  U8 *buf=StrPrintJoin(NULL,fmt,argc,argv);
  res=ExePutS(buf);
  Free(buf);
  return res;
}

I64 ExeFile(U8 *name,I64 ccf_flags=0)
{//JIT Compile and execute a file.
  I64 res;
  U8 *name2=ExtDft(name,"HC.Z"),
        *st=MStrPrint("#include \"%s\";",name2);
  res=ExePutS(st,name,ccf_flags);
  Free(st);
  Free(name2);
  return res;
}

I64 RunFile(U8 *name,I64 ccf_flags=0,...)
{//ExeFile() with args using LastFun().
  ExeFile(name,ccf_flags);
  return LastFun(argc,argv);
}

I64 ExePutS2(U8 *buf,U8 *filename=NULL,I64 ccf_flags=0)
{//throws exceptions
  I64 res;
  CCmpCtrl *cc;
  if (!filename)
    filename=blkdev.tmp_filename;
  cc=CmpCtrlNew(buf,ccf_flags|CCF_DONT_FREE_BUF,filename);
  if (Fs->last_cc!=&Fs->next_cc)
    cc->opts=Fs->last_cc->opts;
  QueIns(cc,Fs->last_cc);
  Lex(cc);
  res=ExeCmdLine(cc);
  QueRem(cc);
  CmpCtrlDel(cc);
  return res;
}

I64 ExePrint2(U8 *fmt,...)
{//throws exceptions
  I64 res;
  U8 *buf=StrPrintJoin(NULL,fmt,argc,argv);
  res=ExePutS2(buf);
  Free(buf);
  return res;
}

I64 ExeFile2(U8 *name,I64 ccf_flags=0)
{//throws exceptions
  I64 res;
  U8 *name2=ExtDft(name,"HC.Z"),*st=MStrPrint("#include \"%s\";",name2);
  res=ExePutS2(st,name,ccf_flags);
  Free(st);
  Free(name2);
  return res;
}

I64 RunFile2(U8 *name,I64 ccf_flags=0,...)
{//ExeFile2() with args using LastFun(). throws exceptions.
  ExeFile2(name,ccf_flags);
  return LastFun(argc,argv);
}

I64 StreamExePrint(U8 *fmt,...)
{//Causes value from stream to be used in an #exe{} block.
  U8 *buf=StrPrintJoin(NULL,fmt,argc,argv);
  I64 res=0;
  CLexHashTableContext *htc;
  CCmpCtrl *cc=Fs->last_cc;
  if (cc==&Fs->next_cc)
    PrintErr("Not Compiling\n");
  else {
    if (!(cc->flags&CCF_EXE_BLK))
      LexExcept(cc,"StreamExePrint only allowed in AOT compiled #exe{} mode.");
    if (htc=cc->htc.next)
      res=ExePutS(buf,,,htc);
  }
  Free(buf);
  return res;
}

U0 CInit()
{
  CmpLoadDefines;
  CmpFillTables;
  QueInit(&cmp.ic_nop);
  cmp.ic_nop.ic_class=cmp.internal_types[RT_I64];
  cmp.ic_nop.ic_code=IC_NOP1;
  AsmHashLoad;
  UAsmHashLoad;
}

CInit;