#define IAMNOTEIC
#include <eic.h>
#define PATH_MAX 4096
#include <bastard.h>


/* wrapper functions */
static val_t eic_DBSaveState(void) {
   val_t v;
   v.p.sp = v.p.p = DBSaveState();
   v.p.ep = (char *)v.p.p + (sizeof(int));
   /* ret: void * args:  */
   return(v);
}
static val_t eic_DBRestoreState(void) {
   val_t v;
   v.ival = DBRestoreState(arg(0, getargs(), void *));
   /* ret: int args: void *state */
   return(v);
}
static val_t eic_DBIndexFirst(void) {
   val_t v;
   v.ival = DBIndexFirst(arg(0, getargs(), int), arg(1,getargs(), void *));
   /* ret: int args: int index, void *dest */
   return(v);
}
static val_t eic_DBIndexNext(void) {
   val_t v;
   v.ival = DBIndexNext(arg(0, getargs(), int), arg(1,getargs(), void *));
   /* ret: int args: int index, void *dest */
   return(v);
}
static val_t eic_DBIndexPrev(void) {
   val_t v;
   v.ival = DBIndexPrev(arg(0, getargs(), int), arg(1,getargs(), void *));
   /* ret: int args: int index, void *dest */
   return(v);
}
static val_t eic_DBIndexLast(void) {
   val_t v;
   v.ival = DBIndexLast(arg(0, getargs(), int), arg(1,getargs(), void *));
   /* ret: int args: int index, void *dest */
   return(v);
}
static val_t eic_DBIndexFind(void) {
   val_t v;
   v.ival = DBIndexFind(arg(0, getargs(), int), arg(1,getargs(), void *), 
                          arg(2,getargs(), void *));
   /* ret: int args: int index, void *value, void *dest */
   return(v);
}
static val_t eic_DBTableFirst(void) {
   val_t v;
   v.ival = DBTableFirst(arg(0, getargs(), int), arg(1,getargs(), void *));
   /* ret: int args: int table, void *dest */
   return(v);
}
static val_t eic_DBTableNext(void) {
   val_t v;
   v.ival = DBTableNext(arg(0, getargs(), int), arg(1,getargs(), void *));
   /* ret: int args: int table, void *dest */
   return(v);
}
static val_t eic_DBTablePrev(void) {
   val_t v;
   v.ival = DBTablePrev(arg(0, getargs(), int), arg(1,getargs(), void *));
   /* ret: int args: int table, void *dest */
   return(v);
}
static val_t eic_DBTableLast(void) {
   val_t v;
   v.ival = DBTableLast(arg(0, getargs(), int), arg(1,getargs(), void *));
   /* ret: int args: int table, void *dest */
   return(v);
}
static val_t eic_DBRecordInsert(void) {
   val_t v;
   v.ival = DBRecordInsert(arg(0, getargs(), int), arg(1,getargs(), void *));
   /* ret: int args: int table, void *src */
   return(v);
}
static val_t eic_DBRecordUpdate(void) {
   val_t v;
   v.ival = DBRecordUpdate(arg(0, getargs(), int), arg(1,getargs(), void *), 
                          arg(2,getargs(), void *));
   /* ret: int args: int index, void *value, void *src */
   return(v);
}
static val_t eic_DBRecordDelete(void) {
   val_t v;
   v.ival = DBRecordDelete(arg(0, getargs(), int), arg(1,getargs(), void *));
   /* ret: int args: int index, void *value */
   return(v);
}
static val_t eic_DBFindClosestPrev(void) {
   val_t v;
   v.ival = DBFindClosestPrev(arg(0, getargs(), int), arg(1,getargs(), void *), 
                          arg(2,getargs(), void *));
   /* ret: int args: int index, void *value, void *dest */
   return(v);
}
static val_t eic_DBFindClosestNext(void) {
   val_t v;
   v.ival = DBFindClosestNext(arg(0, getargs(), int), arg(1,getargs(), void *), 
                          arg(2,getargs(), void *));
   /* ret: int args: int index, void *value, void *dest */
   return(v);
}
static val_t eic_GetAddressObject(void) {
   val_t v;
   v.up = GetAddressObject(arg(0, getargs(), long));
   /* ret: struct address * args: long rva */
   return(v);
}
static val_t eic_GetCodeObject(void) {
   val_t v;
   v.up = GetCodeObject(arg(0, getargs(), long));
   /* ret: struct code * args: long rva */
   return(v);
}
static val_t eic_GetAddrExpObject(void) {
   val_t v;
   v.up = GetAddrExpObject(arg(0, getargs(), int));
   /* ret: struct code * args: long rva */
   return(v);
}
static val_t eic_GetCodeEffectObject(void) {
   val_t v;
   v.up = GetCodeEffectObject(arg(0, getargs(), int));
   /* ret: struct code * args: long rva */
   return(v);
}
static val_t eic_GetSectionObject(void) {
   val_t v;
   v.up = GetSectionObject(arg(0, getargs(), void *));
   /* ret: struct section * args: char *name */
   return(v);
}
static val_t eic_GetXrefObject(void) {
   val_t v;
   v.up = GetXrefObject(arg(0, getargs(), int));
   /* ret: struct xref * args: int id */
   return(v);
}
static val_t eic_GetIntCodeObject(void) {
   val_t v;
   v.up = GetIntCodeObject(arg(0, getargs(), int));
   /* ret: struct int_code * args: int id */
   return(v);
}
static val_t eic_GetFinCodeObject(void) {
   val_t v;
   v.up = GetFinCodeObject(arg(0, getargs(), int));
   /* ret: struct fin_code * args: int id */
   return(v);
}
static val_t eic_GetExportObject(void) {
   val_t v;
   v.up = GetExportObject(arg(0, getargs(), long));
   /* ret: struct export * args: long rva */
   return(v);
}
static val_t eic_GetImportObject(void) {
   val_t v;
   v.up = GetImportObject(arg(0, getargs(), long));
   /* ret: struct import * args: long rva */
   return(v);
}
static val_t eic_GetStringObject(void) {
   val_t v;
   v.up = GetStringObject(arg(0, getargs(), long));
   /* ret: struct string * args: long rva */
   return(v);
}
static val_t eic_GetNameObject(void) {
   val_t v;
   v.up = GetNameObject(arg(0, getargs(), long));
   /* ret: struct name * args: long rva */
   return(v);
}
static val_t eic_GetCommentObject(void) {
   val_t v;
   v.up = GetCommentObject(arg(0, getargs(), int));
   /* ret: struct comment * args: int id */
   return(v);
}
static val_t eic_GetFunctionObject(void) {
   val_t v;
   v.up = GetFunctionObject(arg(0, getargs(), int));
   /* ret: struct function * args: int id */
   return(v);
}
static val_t eic_GetFuncParamObject(void) {
   val_t v;
   v.up = GetFuncParamObject(arg(0, getargs(), int));
   /* ret: struct func_param * args: int id */
   return(v);
}
static val_t eic_GetFuncLocalObject(void) {
   val_t v;
   v.up = GetFuncLocalObject(arg(0, getargs(), int));
   /* ret: struct func_local * args: int id */
   return(v);
}
static val_t eic_GetFuncEffectObject(void) {
   val_t v;
   v.up = GetFuncEffectObject(arg(0, getargs(), int));
   /* ret: struct code * args: long rva */
   return(v);
}
static val_t eic_GetFInlineObject(void) {
   val_t v;
   v.up = GetFInlineObject(arg(0, getargs(), int));
   /* ret: struct f_inline * args: int id */
   return(v);
}
static val_t eic_GetStructureObject(void) {
   val_t v;
   v.up = GetStructureObject(arg(0, getargs(), int));
   /* ret: struct structure * args: int id */
   return(v);
}
static val_t eic_GetStructMemberObject(void) {
   val_t v;
   v.up = GetStructMemberObject(arg(0, getargs(), int));
   /* ret: struct struct_member * args: int id */
   return(v);
}
static val_t eic_GetDataTypeObject(void) {
   val_t v;
   v.up = GetDataTypeObject(arg(0, getargs(), int));
   /* ret: struct data_type * args: int id */
   return(v);
}
static val_t eic_GetConstantObject(void) {
   val_t v;
   v.up = GetConstantObject(arg(0, getargs(), int));
   /* ret: struct constant * args: int id */
   return(v);
}
static val_t eic_GetBCMacroObject(void) {
   val_t v;
   v.up = GetBCMacroObject(arg(0, getargs(), int));
   /* ret: struct seer_macro * args: int id */
   return(v);
}
static val_t eic_DisPrologue(void) {
   val_t v;
   v.ival = DisPrologue(arg(0, getargs(), void *));
   /* ret: int args: struct code **c */
   return(v);
}
static val_t eic_DisEpilogue(void) {
   val_t v;
   v.ival = DisEpilogue(arg(0, getargs(), void *));
   /* ret: int args: struct code **c */
   return(v);
}
static val_t eic_LoadTarget(void) {
   val_t v;
   v.ival = LoadTarget(arg(0, getargs(), void *));
   /* ret: int args:  char *target  */
   return(v);
}
static val_t eic_LoadBDB(void) {
   val_t v;
   v.ival = LoadBDB(arg(0, getargs(), void *));
   /* ret: int args:  char *dbname  */
   return(v);
}
static val_t eic_SetTargetFormat(void) {
   val_t v;
   v.ival = SetTargetFormat(arg(0, getargs(), void *));
   /* ret: int args:  char *file_format  */
   return(v);
}
static val_t eic_ApplyTargetFormat(void) {
   val_t v;
   v.ival = ApplyTargetFormat();
   /* ret: int args:  char *file_format  */
   return(v);
}
static val_t eic_SetTargetArch(void) {
   val_t v;
   v.ival = SetTargetArch(arg(0, getargs(), void *));
   /* ret: int args:  char *file_arch  */
   return(v);
}
static val_t eic_SetTargetAssembler(void) {
   val_t v;
   v.ival = SetTargetAssembler(arg(0, getargs(), void *));
   /* ret: int args:  char *asm_output  */
   return(v);
}
static val_t eic_SetTargetLanguage(void) {
   val_t v;
   v.ival = SetTargetLanguage(arg(0, getargs(), void *));
   /* ret: int args:  char *language  */
   return(v);
}
static val_t eic_LoadPlugin(void) {
   val_t v;
   v.ival = LoadPlugin(arg(0, getargs(), char *));
   /* ret: int args:  char *plugin  */
   return(v);
}
static val_t eic_RunPlugin(void) {
   val_t v;
   v.ival = RunPlugin(arg(0, getargs(), void *));
   return(v);
}
static val_t eic_UnloadPlugin(void) {
   val_t v;
   v.ival = UnloadPlugin();
   return(v);
}
static val_t eic_SaveDB(void) {
   val_t v;
   SaveDB();
   /* ret: void args:   */
   return(v);
}
static val_t eic_SaveDBBak(void) {
   val_t v;
   SaveDBBak();
   /* ret: void args:   */
   return(v);
}
static val_t eic_CloseDB(void) {
   val_t v;
   CloseDB();
   /* ret: void args:   */
   return(v);
}
static val_t eic_SaveDBAs(void) {
   val_t v;
   SaveDBAs(arg(0, getargs(), void *));
   /* ret: void args:  char *filename  */
   return(v);
}
static val_t eic_SaveAsASM(void) {
   val_t v;
   v.ival = SaveAsASM(arg(0, getargs(), void *));
   /* ret: int args:  char *filename  */
   return(v);
}
static val_t eic_SaveAsHLL(void) {
   val_t v;
   v.ival = SaveAsHLL(arg(0, getargs(), void *));
   /* ret: int args:  char *filename  */
   return(v);
}
static val_t eic_SaveAsLST(void) {
   val_t v;
   v.ival = SaveAsLST(arg(0, getargs(), void *));
   /* ret: int args:  char *filename  */
   return(v);
}
static val_t eic_SaveAsDump(void) {
   val_t v;
   v.ival = SaveAsDump(arg(0, getargs(), void *));
   /* ret: int args:  char *filename  */
   return(v);
}
static val_t eic_SaveAsDiff(void) {
   val_t v;
   v.ival = SaveAsDiff(arg(0, getargs(), void *));
   /* ret: int args:  char *filename  */
   return(v);
}
static val_t eic_SaveAsBinary(void) {
   val_t v;
   v.ival = SaveAsBinary(arg(0, getargs(), void *));
   /* ret: int args:  char *filename  */
   return(v);
}
static val_t eic_CreateSection(void) {
   val_t v;
   v.ival = CreateSection(arg(0, getargs(), void *), 
                          arg(1, getargs(), long),
                          arg(2, getargs(), int),
                          arg(3, getargs(), long),
                          arg(4, getargs(), int) );
   /* ret: int args:  char *name, long start, int size, long pa, int type  */
   return(v);
}
static val_t eic_DeleteSection(void) {
   val_t v;
   v.ival = DeleteSection(arg(0, getargs(), void *));
   /* ret: int args:  char *name  */
   return(v);
}
static val_t eic_GetSection(void) {
   val_t v;
   v.ival = GetSection(arg(0, getargs(), long),
                       arg(1, getargs(), void *) );
   /* ret: int args:  long rva, struct section *s */
   return(v);
}
static val_t eic_GetSectionStart(void) {
   val_t v;
   v.lval = GetSectionStart(arg(0, getargs(), void *));
   /* ret: long args:  char *name  */
   return(v);
}
static val_t eic_GetSectionEnd(void) {
   val_t v;
   v.lval = GetSectionEnd(arg(0, getargs(), void *));
   /* ret: long args:  char *name  */
   return(v);
}
static val_t eic_GetSectionName(void) {
   val_t v;
   v.ival = GetSectionName(arg(0, getargs(), long),
                           arg(1, getargs(), void *) );
   /* ret: int  args:  long rva, char* buf  */
   return(v);
}
static val_t eic_GetSectionFlags(void) {
   val_t v;
   v.ival = GetSectionFlags(arg(0, getargs(), void *));
   /* ret: int  args:  char *name  */
   return(v);
}
static val_t eic_SetSectionStart(void) {
   val_t v;
   v.ival = SetSectionStart(arg(0, getargs(), void *), 
                            arg(1, getargs(), long) );
   /* ret: int  args:  char *name, long start  */
   return(v);
}
static val_t eic_SetSectionEnd(void) {
   val_t v;
   v.ival = SetSectionEnd(arg(0, getargs(), void *), 
                          arg(1, getargs(), long) );
   /* ret: int  args:  char *name, long end  */
   return(v);
}
static val_t eic_SetSectionName(void) {
   val_t v;
   v.ival = SetSectionName(arg(0, getargs(), void *), 
                           arg(1, getargs(), void *) );
   /* ret: int  args:  char *name, char *new_name  */
   return(v);
}
static val_t eic_SetSectionFlags(void) {
   val_t v;
   v.ival = SetSectionFlags(arg(0, getargs(), void *),
                            arg(1, getargs(), int) );
   /* ret: int  args:  char *name, int flags  */
   return(v);
}
static val_t eic_CreateHeader(void) {
   val_t v;
   v.ival = CreateHeader(arg(0, getargs(), void *));
   /* ret: int args:  char *header  */
   return(v);
}
static val_t eic_PrintHeader(void) {
   val_t v;
   PrintHeader();
   /* ret: void args:   */
   return(v);
}
static val_t eic_DisassembleTarget(void) {
   val_t v;
   v.ival = DisassembleTarget(arg(0, getargs(), char *),
                               arg(1, getargs(), void *));
   /* ret: int args:  char *name  */
   return(v);
}
static val_t eic_DisassembleSection(void) {
   val_t v;
   v.ival = DisassembleSection(arg(0, getargs(), void *));
   /* ret: int args:  char *name  */
   return(v);
}
static val_t eic_DisassembleRange(void) {
   val_t v;
   v.ival = DisassembleRange(arg(0, getargs(), long), 
                             arg(1, getargs(), int) );
   /* ret: int args:  long rva, int size  */
   return(v);
}
static val_t eic_DisassembleForward(void) {
   val_t v;
   v.ival = DisassembleForward(arg(0, getargs(), long));
   /* ret: int args:  long rva  */
   return(v);
}
static val_t eic_DisassemblePass(void) {
   val_t v;
   v.ival = DisassemblePass(arg(0, getargs(), int),
                           arg(1, getargs(),int));
   /* ret: int args:  int pass  */
   return(v);
}
static val_t eic_IsValidAddr(void) {
   val_t v;
   v.ival = IsValidAddr(arg(0, getargs(), long));
   /* ret: int args:  long rva  */
   return(v);
}
static val_t eic_IsValidCodeAddr(void) {
   val_t v;
   v.ival = IsValidCodeAddr(arg(0, getargs(), long));
   /* ret: int args:  long rva  */
   return(v);
}
static val_t eic_AddrExists(void) {
   val_t v;
   v.ival = AddrExists(arg(0, getargs(), long));
   /* ret: int args:  long rva  */
   return(v);
}
static val_t eic_FindClosestAddr(void) {
   val_t v;
   v.lval = FindClosestAddr(arg(0, getargs(), long));
   /* ret: long args:  long rva  */
   return(v);
}
static val_t eic_DefineAddr(void) {
   val_t v;
   v.ival = DefineAddr(arg(0, getargs(), long),
                       arg(1, getargs(), int),
                       arg(2, getargs(), long),
                       arg(3, getargs(), int) );
   /* ret: int args:  long rva, int size, long pa, int flags  */
   return(v);
}
static val_t eic_UndefineAddr(void) {
   val_t v;
   v.ival = UndefineAddr(arg(0, getargs(), long));
   /* ret: int args:  long rva  */
   return(v);
}
static val_t eic_asmsprintf(void) {
   val_t v;
   v.ival = asmsprintf(arg(0, getargs(), void *), 
                       arg(1, getargs(), void *),
                       arg(2, getargs(), void *) );
   /* ret: int args: char *buf, char *format, struct address *addr */
   return(v);
}
static val_t eic_PrintAddress(void) {
   val_t v;
   v.ival = PrintAddress(arg(0, getargs(), long));
   /* ret: int args:  long rva  */
   return(v);
}
static val_t eic_MakeCode(void) {
   val_t v;
   v.ival = MakeCode(arg(0, getargs(), long));
   /* ret: int args:  long addr  */
   return(v);
}
static val_t eic_MakeData(void) {
   val_t v;
   v.ival = MakeData(arg(0, getargs(), long));
   /* ret: int args:  long addr  */
   return(v);
}
static val_t eic_GetPA(void) {
   val_t v;
   v.lval = GetPA(arg(0, getargs(), long));
   /* ret: long args:  long rva  */
   return(v);
}
static val_t eic_GetRVA(void) {
   val_t v;
   v.lval = GetRVA(arg(0, getargs(), long));
   /* ret: long args:  long pa  */
   return(v);
}
static val_t eic_GetAddrType(void) {
   val_t v;
   v.ival = GetAddrType(arg(0, getargs(), long));
   /* ret: int args:  long rva  */
   return(v);
}
static val_t eic_GetAddrSize(void) {
   val_t v;
   v.ival = GetAddrSize(arg(0, getargs(), long));
   /* ret: int args:  long rva  */
   return(v);
}
static val_t eic_GetFlags(void) {
   val_t v;
   v.ival = GetFlags(arg(0, getargs(), long));
   /* ret: int args:  long addr  */
   return(v);
}
static val_t eic_GetAddrBytes(void) {
   val_t v;
   v.ival = GetAddrBytes(arg(0, getargs(), long),
                         arg(1, getargs(), void *) );
   /* ret: int args:  long rva, char *buf  */
   return(v);
}
static val_t eic_GetNextAddr(void) {
   val_t v;
   v.lval = GetNextAddr(arg(0, getargs(), long));
   /* ret: long args:  long rva  */
   return(v);
}
static val_t eic_GetPrevAddr(void) {
   val_t v;
   v.lval = GetPrevAddr(arg(0, getargs(), long));
   /* ret: long args:  long rva  */
   return(v);
}
static val_t eic_SetFlags(void) {
   val_t v;
   v.ival = SetFlags(arg(0, getargs(), long),
                     arg(1, getargs(), int) );
   /* ret: int args:  long rva, int flags  */
   return(v);
}
static val_t eic_SetName(void) {
   val_t v;
   v.ival = SetName(arg(0, getargs(), long),
                    arg(1, getargs(), void *),
                    arg(2, getargs(), int) );
   /* ret: int args:  long rva, char* name, int type  */
   return(v);
}
static val_t eic_GetName(void) {
   val_t v;
   v.ival = GetName(arg(0, getargs(), long),
                    arg(1, getargs(), void * ) );
   /* ret: int args:  long rva, char* buffer  */
   return(v);
}
static val_t eic_GetNameType(void) {
   val_t v;
   v.ival = GetNameType(arg(0, getargs(), long));
   /* ret: int args: long addr */
   return(v);
}
static val_t eic_GetAddrByName(void) {
   val_t v;
   v.lval = GetAddrByName(arg(0, getargs(), void *));
   /* ret: long args:  char *name  */
   return(v);
}
static val_t eic_DefineAddrComment(void) {
   val_t v;
   v.ival = DefineAddrComment(arg(0, getargs(), long),
                              arg(1, getargs(), void *) );
   /* ret: int args:  long rva, char *buf  */
   return(v);
}
static val_t eic_GetAddrComment(void) {
   val_t v;
   v.ival = GetAddrComment(arg(0, getargs(), long));
   /* ret: int args:  long rva  */
   return(v);
}
static val_t eic_SetAddrComment(void) {
   val_t v;
   v.ival = SetAddrComment(arg(0, getargs(), long),
                           arg(1, getargs(), int) );
   /* ret: int args:  long rva, int id  */
   return(v);
}
static val_t eic_GetComment(void) {
   val_t v;
   v.ival = GetComment(arg(0, getargs(), int),
                       arg(1, getargs(), void *) );
   /* ret: int args:  int id, char *buf  */
   return(v);
}
static val_t eic_DefineComment(void) {
   val_t v;
   v.ival = DefineComment(arg(0, getargs(), void *),
                          arg(1, getargs(), int) );
   /* ret: int args:  char *buf, int type  */
   return(v);
}
static val_t eic_SetComment(void) {
   val_t v;
   v.ival = SetComment(arg(0, getargs(), int),
                       arg(1, getargs(), void *) );
   /* ret: int args:  int id, char *buf  */
   return(v);
}
static val_t eic_DefineDataType(void) {
   val_t v;
   v.ival = DefineDataType(arg(0, getargs(), char *),
                       arg(1, getargs(), int) ,
                       arg(2, getargs(), int) );
   /* ret: int args:  int id, char *buf  */
   return(v);
}
static val_t eic_DeleteDataType(void) {
   val_t v;
   v.ival = DeleteDataType(arg(0, getargs(), char *));
   /* ret: int args:  int id, char *buf  */
   return(v);
}
static val_t eic_GetDataType(void) {
   val_t v;
   v.ival = GetDataType(arg(0, getargs(), char *));
   /* ret: int args:  int id, char *buf  */
   return(v);
}
static val_t eic_DefineStruct(void) {
   val_t v;
   v.ival = DefineStruct(arg(0, getargs(), char *),
                       arg(1, getargs(), short) );
   /* ret: int args:  int id, char *buf  */
   return(v);
}
static val_t eic_DefineStructMember(void) {
   val_t v;
   v.ival = DefineStructMember(arg(0, getargs(), int),
                       arg(1, getargs(), long),
                       arg(2, getargs(), int),
                       arg(3, getargs(), int),
                       arg(4, getargs(), char *) );
   /* ret: int args:  int id, char *buf  */
   return(v);
}
static val_t eic_GetStruct(void) {
   val_t v;
   v.ival = GetStruct(arg(0, getargs(), long),
                       arg(1, getargs(), void *) );
   /* ret: int args:  int id, char *buf  */
   return(v);
}
static val_t eic_GetStructID(void) {
   val_t v;
   v.ival = GetStructID(arg(0, getargs(), char *));
   /* ret: int args:  int id, char *buf  */
   return(v);
}
static val_t eic_GetStructMember(void) {
   val_t v;
   v.ival = GetStructMember(arg(0, getargs(), int),
                            arg(1, getargs(), int),
                            arg(2, getargs(), void *));
   /* ret: int args:  int id, char *buf  */
   return(v);
}
static val_t eic_ApplyStructure(void) {
   val_t v;
   v.ival = ApplyStructure(arg(0, getargs(), long),
                       arg(1, getargs(), unsigned long) );
   /* ret: int args:  int id, char *buf  */
   return(v);
}
static val_t eic_DelStruct(void) {
   val_t v;
   v.ival = DelStruct(arg(0, getargs(), int));
   /* ret: int args:  int id, char *buf  */
   return(v);
}
static val_t eic_DelStructMember(void) {
   val_t v;
   v.ival = DelStructMember(arg(0, getargs(), int));
   /* ret: int args:  int id, char *buf  */
   return(v);
}
static val_t eic_GetAddrConstant(void) {
   val_t v;
   v.ival = GetAddrConstant(arg(0, getargs(), long));
   /* ret: int args:  long rva  */
   return(v);
}
static val_t eic_GetAddrStruct(void) {
   val_t v;
   v.ival = GetAddrStruct(arg(0, getargs(), long));
   /* ret: int args:  long rva  */
   return(v);
}
static val_t eic_SetAddrConstant(void) {
   val_t v;
   v.ival = SetAddrConstant(arg(0, getargs(), long),
                            arg(1, getargs(), int) );
   /* ret: int args:  long rva, int id  */
   return(v);
}
static val_t eic_SetAddrStruct(void) {
   val_t v;
   v.ival = SetAddrStruct(arg(0, getargs(), long),
                          arg(1, getargs(), int) );
   /* ret: int args:  long rva, int id  */
   return(v);
}
static val_t eic_DefineConstant(void) {
   val_t v;
   v.ival = DefineConstant(arg(0, getargs(), void *),
                           arg(1, getargs(), int) );
   /* ret: int args:  char *name, int value */
   return(v);
}
static val_t eic_GetConstant(void) {
   val_t v;
   v.ival = GetConstant(arg(0, getargs(), int),
                        arg(1, getargs(), void *) );
   /* ret: int args: int value, char buf[32] */
   return(v);
}
static val_t eic_GetConstantNext(void) {
   val_t v;
   v.ival = GetConstantNext(arg(0, getargs(), void *));
   /* ret: int args:  char buf[32] */
   return(v);
}
static val_t eic_GetConstantName(void) {
   val_t v;
   v.ival = GetConstantName(arg(0, getargs(), long), 
                            arg(1, getargs(), void *) );
   /* ret: int args:  unsigned long id, char buf[32] */
   return(v);
}
static val_t eic_GetConstantID(void) {
   val_t v;
   v.lval = GetConstantID(arg(0, getargs(), void *));
   /* ret: unsigned long args:  char *name */
   return(v);
}
static val_t eic_DelConstant(void) {
   val_t v;
   v.ival = DelConstant(arg(0, getargs(), long));
   /* ret: int args:  unsigned long id */
   return(v);
}
static val_t eic_DefineCode(void) {
   val_t v;
   v.ival = DefineCode(arg(0, getargs(), long), 
                       arg(1, getargs(), void *) );
   /* ret: int args: long rva, struct code *c */
   return(v);
}
static val_t eic_UndefineCode(void) {
   val_t v;
   v.ival = UndefineCode(arg(0, getargs(), long));
   /* ret: int args: long rva */
   return(v);
}
static val_t eic_GetNextCode(void) {
   val_t v;
   v.lval = GetNextCode(arg(0, getargs(), long));
   /* ret: long args:  long rva  */
   return(v);
}
static val_t eic_GetNextData(void) {
   val_t v;
   v.lval = GetNextData(arg(0, getargs(), long));
   /* ret: long args:  long rva  */
   return(v);
}
static val_t eic_opcmp(void) {
   val_t v;
   v.ival = opcmp(arg(0, getargs(), long),
                  arg(1, getargs(), int),
                  arg(2, getargs(), long),
                  arg(3, getargs(), int));
   /* ret: int args:  long rva, char *buf  */
   return(v);
}
static val_t eic_DefineCodeEffect(void) {
   val_t v;
   v.ival = DefineCodeEffect(arg(0, getargs(), long),
                  arg(1, getargs(), int),
                  arg(2, getargs(), int));
   /* ret: int args:  long rva, char *buf  */
   return(v);
}
static val_t eic_GetString(void) {
   val_t v;
   v.ival = GetString(arg(0, getargs(), long),
                      arg(1, getargs(), void *) ,
                      arg(2, getargs(), int) );
   /* ret: int args:  long rva, char *buf, int len  */
   return(v);
}
static val_t eic_GetEntireString(void) {
   val_t v;
   v.ival = GetEntireString(arg(0, getargs(), long),
                            arg(1, getargs(), void *) );
   /* ret: int args: long rva, char **buf */
   return(v);
}
static val_t eic_DefineString(void) {
   val_t v;
   v.ival = DefineString(arg(0, getargs(), long));
   /* ret: int args:  long rva  */
   return(v);
}
static val_t eic_DumpStrings(void) {
   val_t v;
   v.ival = DumpStrings();
   /* ret: int args:   */
   return(v);
}
static val_t eic_FindStringsInRange(void) {
   val_t v;
   v.ival = FindStringsInRange(arg(0, getargs(), long),
                               arg(1, getargs(), int),
                               arg(2, getargs(), int) );
   /* ret: int args: long rva, int size, int type */
   return(v);
}
static val_t eic_DefineImport(void) {
   val_t v;
   v.ival = DefineImport(arg(0, getargs(), long),
                         arg(1, getargs(), void *),
                         arg(2, getargs(), void *),
                         arg(3, getargs(), int) );
   /* ret: int args:  long rva, char *lib, char* name, int type  */
   return(v);
}
static val_t eic_GetImportName(void) {
   val_t v;
   v.ival = GetImportName(arg(0, getargs(), long),
                          arg(1, getargs(), void *) );
   /* ret: int args:  long rva, char *buf  */
   return(v);
}
static val_t eic_GetImportLib(void) {
   val_t v;
   v.ival = GetImportLib(arg(0, getargs(), long),
                          arg(1, getargs(), void *) );
   /* ret: int args:  long rva, char *buf  */
   return(v);
}
static val_t eic_GetImportType(void) {
   val_t v;
   v.ival = GetImportType(arg(0, getargs(), long));
   /* ret: int args:  long rva  */
   return(v);
}
static val_t eic_DumpImports(void) {
   val_t v;
   v.ival = DumpImports();
   /* ret: int args:   */
   return(v);
}
static val_t eic_DefineLibrary(void) {
   val_t v;
   v.ival = DefineLibrary(arg(0, getargs(), void *),
                          arg(1, getargs(), int),
                          arg(2, getargs(), int) );
   /* ret: int args:  char *name, int v_hi, int v_lo  */
   return(v);
}
static val_t eic_DumpLibs(void) {
   val_t v;
   v.ival = DumpLibs();
   /* ret: int args:   */
   return(v);
}
static val_t eic_DefineExport(void) {
   val_t v;
   v.ival = DefineExport(arg(0, getargs(), long),
                         arg(1, getargs(), void *) );
   /* ret: int args:  long rva, char *name  */
   return(v);
}
static val_t eic_GetExport(void) {
   val_t v;
   v.ival = GetExport(arg(0, getargs(), void *));
   /* ret: int args:  char *name  */
   return(v);
}
static val_t eic_DumpExports(void) {
   val_t v;
   v.ival = DumpExports();
   /* ret: int args:   */
   return(v);
}
static val_t eic_DefineRef(void) {
   val_t v;
   v.ival = DefineRef(arg(0, getargs(), long),
                      arg(1, getargs(), long),
                      arg(2, getargs(), int) );
   /* ret: int args:  long from, long to, int type  */
   return(v);
}
static val_t eic_DefineFunc(void) {
   val_t v;
   v.ival = DefineFunc(arg(0, getargs(), long),
                       arg(1, getargs(), void *),
                       arg(2, getargs(), int) ,
                       arg(3, getargs(), int) );
   /* ret: int args:  long rva, char * name, int size  */
   return(v);
}
static val_t eic_GetFuncName(void) {
   val_t v;
   v.ival = GetFuncName(arg(0, getargs(), long),
                        arg(1, getargs(), void *) );
   /* ret: int args:  long rva, char *buf  */
   return(v);
}
static val_t eic_GetFuncStart(void) {
   val_t v;
   v.ival = GetFuncStart(arg(0, getargs(), long));
   /* ret: int args:  long rva  */
   return(v);
}
static val_t eic_GetFuncEnd(void) {
   val_t v;
   v.ival = GetFuncEnd(arg(0, getargs(), long));
   /* ret: int args:  long rva  */
   return(v);
}
static val_t eic_GetFuncByName(void) {
   val_t v;
   v.ival = GetFuncByName(arg(0, getargs(), void *));
   /* ret: int args:  char *name  */
   return(v);
}
static val_t eic_SetFuncName(void) {
   val_t v;
   v.ival = SetFuncName(arg(0, getargs(), long),
                        arg(1, getargs(), void *) );
   /* ret: int args:  long rva, char *name  */
   return(v);
}
static val_t eic_SetFuncSize(void) {
   val_t v;
   v.ival = SetFuncSize(arg(0, getargs(), long),
                        arg(1, getargs(), int) );
   /* ret: int args:  long rva, int size  */
   return(v);
}
static val_t eic_RunScript(void) {
   val_t v;
   v.ival = RunScript(arg(0, getargs(), void *));
   /* ret: int args:  char *name  */
   return(v);
}
static val_t eic_RunScriptText(void) {
   val_t v;
   v.ival = RunScriptText(arg(0, getargs(), void *));
   /* ret: int args:  char *script  */
   return(v);
}
static val_t eic_RunCompiledScript(void) {
   val_t v;
   v.ival = RunCompiledScript(arg(0, getargs(), void *));
   /* ret: int args: char *name */
   return(v);
}
static val_t eic_CompileScript(void) {
   val_t v;
   v.ival = CompileScript(arg(0, getargs(), void *));
   /* ret: int args: char *name */
   return(v);
}
static val_t eic_DefineMacro(void) {
   val_t v;
   v.ival = DefineMacro(arg(0, getargs(), void *),
                        arg(1, getargs(), void *) );
   /* ret: int args:  char *name, char *macro  */
   return(v);
}
static val_t eic_UndefineMacro(void) {
   val_t v;
   v.ival = UndefineMacro(arg(0, getargs(), void *));
   /* ret: int args:  char *name  */
   return(v);
}
static val_t eic_RunMacro(void) {
   val_t v;
   v.ival = RunMacro(arg(0, getargs(), void *));
   /* ret: int args:  char *name  */
   return(v);
}
static val_t eic_RecordMacro(void) {
   val_t v;
   v.ival = RecordMacro(arg(0, getargs(), void *));
   /* ret: int args:  char *name  */
   return(v);
}
static val_t eic_FindBytes(void) {
   val_t v;
   v.ival = FindBytes(arg(0, getargs(), void *),
                      arg(1, getargs(), int),
                      arg(2, getargs(), void *) );
   /* ret: int args:  unsigned char *bytes, int len, int **search */
   return(v);
}
static val_t eic_FindOperand(void) {
   val_t v;
   v.ival = FindOperand(arg(0, getargs(), void *),
                        arg(1, getargs(), void *) );
   /* ret: int args:  char *str, int **search */
   return(v);
}
static val_t eic_FindMnemonic(void) {
   val_t v;
   v.ival = FindMnemonic(arg(0, getargs(), void *),
                         arg(1, getargs(), void *) );
   /* ret: int args:  char *str, int **search */
   return(v);
}
static val_t eic_FindConstant(void) {
   val_t v;
   v.ival = FindConstant(arg(0, getargs(), long),
                         arg(1, getargs(), void *) );
   /* ret: int args:  long value, int **search */
   return(v);
}
static val_t eic_FreeSearchHandle(void) {
   val_t v;
   v.ival = FreeSearchHandle(arg(0, getargs(), void *));
   /* ret: int args:  int **search  */
   return(v);
}
static val_t eic_FindNextOpRead(void) {
   val_t v;
   v.lval = FindNextOpRead(arg(0, getargs(), void *),
                           arg(1, getargs(), long),
                           arg(2, getargs(), int) );
   /* ret: long args:  char *operand, long rva, int ttl  */
   return(v);
}
static val_t eic_FindPrevOpRead(void) {
   val_t v;
   v.lval = FindPrevOpRead(arg(0, getargs(), void *),
                           arg(1, getargs(), long),
                           arg(2, getargs(), int));
   /* ret: long args:  char *operand, long rva, int ttl  */
   return(v);
}
static val_t eic_FindNextOpWrite(void) {
   val_t v;
   v.lval = FindNextOpWrite(arg(0, getargs(), void *),
                           arg(1, getargs(), long),
                           arg(2, getargs(), int));
   /* ret: long args:  char *operand, long rva, int ttl  */
   return(v);
}
static val_t eic_FindPrevOpWrite(void) {
   val_t v;
   v.lval = FindPrevOpWrite(arg(0, getargs(), void *),
                           arg(1, getargs(), long),
                           arg(2, getargs(), int));
   /* ret: long args:  char *operand, long rva, int ttl  */
   return(v);
}
static val_t eic_FindNextOpExec(void) {
   val_t v;
   v.lval = FindNextOpExec(arg(0, getargs(), void *),
                           arg(1, getargs(), long),
                           arg(2, getargs(), int));
   /* ret: long args:  char *operand, long rva, int ttl  */
   return(v);
}
static val_t eic_FindPrevOpExec(void) {
   val_t v;
   v.lval = FindPrevOpExec(arg(0, getargs(), void *),
                           arg(1, getargs(), long),
                           arg(2, getargs(), int));
   /* ret: long args:  char *operand, long rva, int ttl  */
   return(v);
}
static val_t eic_SetPager(void) {
   val_t v;
   v.ival = SetPager(arg(0, getargs(), void *));
   /* ret: int args: char *name */
   return(v);
}
static val_t eic_SetEditor(void) {
   val_t v;
   v.ival = SetEditor(arg(0, getargs(), void *));
   /* ret: int args: char *name */
   return(v);
}
static val_t eic_SetDebugger(void) {
   val_t v;
   v.ival = SetDebugger(arg(0, getargs(), void *));
   /* ret: int args: char *name */
   return(v);
}
static val_t eic_GetEnvFlag(void) {
   val_t v;
   v.ival = GetEnvFlag(arg(0, getargs(), int));
   /* ret: int args:  int flag  */
   return(v);
}
static val_t eic_SetEnvFlag(void) {
   val_t v;
   v.ival = SetEnvFlag(arg(0, getargs(), int));
   /* ret: int args:  int flag  */
   return(v);
}
static val_t eic_ClearEnvFlag(void) {
   val_t v;
   v.ival = ClearEnvFlag(arg(0, getargs(), int));
   /* ret: int args:  int flag  */
   return(v);
}
static val_t eic_SetTtyAsmFmt(void) {
   val_t v;
   SetTtyAsmFmt(arg(0, getargs(), void *));
   /* ret: void args:  char *fmt  */
   return(v);
}
static val_t eic_SetTtyDataFmt(void) {
   val_t v;
   SetTtyDataFmt(arg(0, getargs(), void *));
   /* ret: void args:  char *fmt  */
   return(v);
}
static val_t eic_SetFileAsmFmt(void) {
   val_t v;
   SetFileAsmFmt(arg(0, getargs(), void *));
   /* ret: void args:  char *fmt  */
   return(v);
}
static val_t eic_SetFileDataFmt(void) {
   val_t v;
   SetFileDataFmt(arg(0, getargs(), void *));
   /* ret: void args:  char *fmt  */
   return(v);
}
static val_t eic_SetLprAsmFmt(void) {
   val_t v;
   SetLprAsmFmt(arg(0, getargs(), void *));
   /* ret: void args:  char *fmt  */
   return(v);
}
static val_t eic_SetLprDataFmt(void) {
   val_t v;
   SetLprDataFmt(arg(0, getargs(), void *));
   /* ret: void args:  char *fmt  */
   return(v);
}
static val_t eic_Exec(void) {
   val_t v;
   v.ival = Exec(arg(0, getargs(), void *));
   /* ret: int args:  char *args  */
   return(v);
}
static val_t eic_Debug(void) {
   val_t v;
   v.ival = Debug();
   /* ret: int args:   */
   return(v);
}
static val_t eic_SetLastError(void) {
   val_t v;
   v.ival = SetLastError(arg(0, getargs(), int));
   /* ret: int args:  int errnum  */
   return(v);
}
static val_t eic_GetLastError(void) {
   val_t v;
   v.ival = GetLastError();
   /* ret: int args:   */
   return(v);
}
static val_t eic_GetLastErrorString(void) {
   val_t v;
   v.up = GetLastErrorString(arg(0, getargs(), void *));
   /* ret: char* args:   */
   return(v);
}
static val_t eic_PrintErrorMsg(void) {
   val_t v;
   PrintErrorMsg(arg(0, getargs(), int));
   /* ret: void args: int errnum */
   return(v);
}
static val_t eic_SprintErrorMsg(void) {
   val_t v;
   SprintErrorMsg(arg(0, getargs(), void *),
                           arg(1, getargs(), int) );
   /* ret: void args: char *buf, int errnum */
   return(v);
}



/* oops-es and additions -- i.e. out of order with bastard.h */
static val_t eic_ClearEnv(void) {
   val_t v;
   v.ival = ClearEnv();
   /* ret: int args:  */
   return(v);
}
static val_t eic_ClearTarget(void) {
   val_t v;
   v.ival = ClearTarget();
   /* ret: int args:  */
   return(v);
}
static val_t eic_DelComment(void) {
   val_t v;
   v.ival = DelComment(arg(0, getargs(), int));
   /* ret: int args:  int id  */
   return(v);
}
static val_t eic_DisAddrSize(void) {
   val_t v;
   v.ival = DisAddrSize();
   /* ret: int args:  */
   return(v);
}
static val_t eic_DisByteOrder(void) {
   val_t v;
   v.ival = DisByteOrder();
   /* ret: int args:  */
   return(v);
}
static val_t eic_DisByteSize(void) {
   val_t v;
   v.ival = DisByteSize();
   /* ret: int args:  */
   return(v);
}
static val_t eic_DisDwordSize(void) {
   val_t v;
   v.ival = DisDwordSize();
   /* ret: int args:  */
   return(v);
}
static val_t eic_DisGetIP(void) {
   val_t v;
   v.ival = DisGetIP();
   /* ret: char* args:  */
   return(v);
}
static val_t eic_DisGetSP(void) {
   val_t v;
   v.ival = DisGetSP();
   /* ret: char* args:  */
   return(v);
}
static val_t eic_DisWordSize(void) {
   val_t v;
   v.ival = DisWordSize();
   /* ret: int args:  */
   return(v);
}
static val_t eic_DisassembleAllPasses(void) {
   val_t v;
   v.ival = DisassembleAllPasses();
   /* ret: int args:  */
   return(v);
}
static val_t eic_ErrorMsg(void) {
   val_t v;
   ErrorMsg(arg(0, getargs(), int),
            arg(1, getargs(), void *) );
   /* ret: void args:  int num, const char *str  */
   return(v);
}
static val_t eic_GetCodeRep(void) {
   val_t v;
   v.ival = GetCodeRep(arg(0, getargs(), void *),
                       arg(1, getargs(), void *),
                       arg(2, getargs(), long));
   /* ret: int args:  char *buf, char *fmt, long rva  */
   return(v);
}
static val_t eic_GetDebugger(void) {
   val_t v;
   v.up = GetDebugger();
   /* ret: char * args:  */
   return(v);
}
static val_t eic_GetBastardEnv(void) {
   val_t v;
   v.up = GetBastardEnv();
   /* ret: struct DISASM_ENV * args:  */
   return(v);
}
static val_t eic_GetBastardHome(void) {
   val_t v;
   v.up = GetBastardHome();
   /* ret: char * args:  */
   return(v);
}
static val_t eic_GetBastardPrefs(void) {
   val_t v;
   v.up = GetBastardPrefs();
   /* ret: struct DISASM_PREFS * args:  */
   return(v);
}
static val_t eic_GetBastardTgt(void) {
   val_t v;
   v.up = GetBastardTgt();
   /* ret: struct DISASM_TGT   * args:  */
   return(v);
}
static val_t eic_GetEditor(void) {
   val_t v;
   v.up = GetEditor();
   /* ret: char * args:  */
   return(v);
}
static val_t eic_GetNextRefFrom(void) {
   val_t v;
   v.lval = GetNextRefFrom(arg(0, getargs(), int));
   /* ret: long args:  int type  */
   return(v);
}
static val_t eic_GetNextRefTo(void) {
   val_t v;
   v.lval = GetNextRefTo(arg(0, getargs(), int));
   /* ret: long args:  int type  */
   return(v);
}
static val_t eic_GetPager(void) {
   val_t v;
   v.up = GetPager();
   /* ret: char * args:  */
   return(v);
}
static val_t eic_GetRefFrom(void) {
   val_t v;
   v.lval = GetRefFrom(arg(0, getargs(), long),
                       arg(1, getargs(), int) );
   /* ret: long args:  long rva, int type  */
   return(v);
}
static val_t eic_GetRefTo(void) {
   val_t v;
   v.lval = GetRefTo(arg(0, getargs(), long),
                     arg(1, getargs(), int) );
   /* ret: long args:  long rva, int type  */
   return(v);
}
static val_t eic_GetTargetFD(void) {
   val_t v;
   v.ival = GetTargetFD();
   /* ret: int args:  */
   return(v);
}
static val_t eic_GetTargetImage(void) {
   val_t v;
   v.up = GetTargetImage();
   /* ret: char * args:  */
   return(v);
}
static val_t eic_GetTargetSize(void) {
   val_t v;
   v.ival = GetTargetSize();
   /* ret: int args:  */
   return(v);
}
static val_t eic_Message(void) {
   val_t v;
   Message(arg(0, getargs(), void *));
   /* ret: void args:  const char *str  */
   return(v);
}
static val_t eic_Quit(void) {
   val_t v;
   Quit();
   /* ret: void args:   */
   return(v);
}
static val_t eic_SetEnvDefaults(void) {
   val_t v;
   v.ival = SetEnvDefaults();
   /* ret: int args:  */
   return(v);
}
static val_t eic_SetPrefDefaults(void) {
   val_t v;
   v.ival = SetPrefDefaults();
   /* ret: int args:  */
   return(v);
}
static val_t eic_SetTargetDefaults(void) {
   val_t v;
   v.ival = SetTargetDefaults();
   /* ret: int args:  */
   return(v);
}
/*
note : add
#pragma push_unsafeptr
to EiC init

val{
char cval, ucval;
short sval, usval;
int ival, uival;
long lval, ulval, llval;
float fval;
double dval;
ptr_t p;
void *up;
(*func)();
(*vfunc)();
pid, szval, sszval, 
      */

      
struct EIC_WRAPPER_TBL {
   char *name;
   void *func;
} eic_wrappers[] = {
{"DBSaveState", eic_DBSaveState }, 
{"DBRestoreState", eic_DBRestoreState }, 
{"DBIndexFirst", eic_DBIndexFirst }, 
{"DBIndexNext", eic_DBIndexNext }, 
{"DBIndexPrev", eic_DBIndexPrev }, 
{"DBIndexLast", eic_DBIndexLast }, 
{"DBIndexFind", eic_DBIndexFind }, 
{"DBTableFirst", eic_DBTableFirst }, 
{"DBTableNext", eic_DBTableNext }, 
{"DBTablePrev", eic_DBTablePrev }, 
{"DBTableLast", eic_DBTableLast }, 
{"DBRecordInsert", eic_DBRecordInsert }, 
{"DBRecordUpdate", eic_DBRecordUpdate }, 
{"DBRecordDelete", eic_DBRecordDelete }, 
{"DBFindClosestPrev", eic_DBFindClosestPrev }, 
{"DBFindClosestNext", eic_DBFindClosestNext }, 
{"GetAddressObject", eic_GetAddressObject }, 
{"GetCodeObject", eic_GetCodeObject }, 
{"GetAddrExpObject", eic_GetAddrExpObject }, 
{"GetCodeEffectObject", eic_GetCodeEffectObject }, 
{"GetSectionObject", eic_GetSectionObject }, 
{"GetXrefObject", eic_GetXrefObject }, 
{"GetIntCodeObject", eic_GetIntCodeObject }, 
{"GetFinCodeObject", eic_GetFinCodeObject }, 
{"GetExportObject", eic_GetExportObject }, 
{"GetImportObject", eic_GetImportObject }, 
{"GetStringObject", eic_GetStringObject }, 
{"GetNameObject", eic_GetNameObject }, 
{"GetCommentObject", eic_GetCommentObject }, 
{"GetFunctionObject", eic_GetFunctionObject }, 
{"GetFuncParamObject", eic_GetFuncParamObject }, 
{"GetFuncLocalObject", eic_GetFuncLocalObject }, 
{"GetFuncEffectObject", eic_GetFuncEffectObject }, 
{"GetFInlineObject", eic_GetFInlineObject }, 
{"GetStructureObject", eic_GetStructureObject }, 
{"GetStructMemberObject", eic_GetStructMemberObject }, 
{"GetDataTypeObject", eic_GetDataTypeObject }, 
{"GetConstantObject", eic_GetConstantObject }, 
{"GetBCMacroObject", eic_GetBCMacroObject }, 
{"DisPrologue", eic_DisPrologue }, 
{"DisEpilogue", eic_DisEpilogue }, 
{"LoadTarget", eic_LoadTarget }, 
{"LoadBDB", eic_LoadBDB }, 
{"SetTargetFormat", eic_SetTargetFormat }, 
{"ApplyTargetFormat", eic_ApplyTargetFormat }, 
{"SetTargetArch", eic_SetTargetArch }, 
{"SetTargetAssembler", eic_SetTargetAssembler }, 
{"SetTargetLanguage", eic_SetTargetLanguage }, 
{"LoadPlugin", eic_LoadPlugin }, 
{"RunPlugin", eic_RunPlugin }, 
{"UnloadPlugin", eic_UnloadPlugin }, 
{"SaveDB", eic_SaveDB }, 
{"SaveDBBak", eic_SaveDBBak }, 
{"CloseDB", eic_CloseDB }, 
{"SaveDBAs", eic_SaveDBAs }, 
{"SaveAsASM", eic_SaveAsASM }, 
{"SaveAsHLL", eic_SaveAsHLL }, 
{"SaveAsLST", eic_SaveAsLST }, 
{"SaveAsDump", eic_SaveAsDump }, 
{"SaveAsDiff", eic_SaveAsDiff }, 
{"SaveAsBinary", eic_SaveAsBinary }, 
{"CreateSection", eic_CreateSection }, 
{"DeleteSection", eic_DeleteSection }, 
{"GetSection", eic_GetSection }, 
{"GetSectionStart", eic_GetSectionStart }, 
{"GetSectionEnd", eic_GetSectionEnd }, 
{"GetSectionName", eic_GetSectionName }, 
{"GetSectionFlags", eic_GetSectionFlags }, 
{"SetSectionStart", eic_SetSectionStart }, 
{"SetSectionEnd", eic_SetSectionEnd }, 
{"SetSectionName", eic_SetSectionName }, 
{"SetSectionFlags", eic_SetSectionFlags }, 
{"CreateHeader", eic_CreateHeader }, 
{"PrintHeader", eic_PrintHeader }, 
{"DisassembleTarget", eic_DisassembleTarget }, 
{"DisassembleSection", eic_DisassembleSection }, 
{"DisassembleRange", eic_DisassembleRange }, 
{"DisassembleForward", eic_DisassembleForward }, 
{"DisassemblePass", eic_DisassemblePass }, 
{"IsValidAddr", eic_IsValidAddr }, 
{"IsValidCodeAddr", eic_IsValidCodeAddr }, 
{"AddrExists", eic_AddrExists }, 
{"FindClosestAddr", eic_FindClosestAddr }, 
{"DefineAddr", eic_DefineAddr }, 
{"UndefineAddr", eic_UndefineAddr }, 
{"asmsprintf", eic_asmsprintf }, 
{"PrintAddress", eic_PrintAddress }, 
{"MakeCode", eic_MakeCode }, 
{"MakeData", eic_MakeData }, 
{"GetPA", eic_GetPA }, 
{"GetRVA", eic_GetRVA }, 
{"GetAddrType", eic_GetAddrType }, 
{"GetAddrSize", eic_GetAddrSize }, 
{"GetFlags", eic_GetFlags }, 
{"GetAddrBytes", eic_GetAddrBytes }, 
{"GetNextAddr", eic_GetNextAddr }, 
{"GetPrevAddr", eic_GetPrevAddr }, 
{"SetFlags", eic_SetFlags }, 
{"SetName", eic_SetName }, 
{"GetName", eic_GetName }, 
{"GetNameType", eic_GetNameType }, 
{"GetAddrByName", eic_GetAddrByName }, 
{"DefineAddrComment", eic_DefineAddrComment }, 
{"GetAddrComment", eic_GetAddrComment }, 
{"SetAddrComment", eic_SetAddrComment }, 
{"GetComment", eic_GetComment }, 
{"DefineComment", eic_DefineComment }, 
{"SetComment", eic_SetComment }, 
{"GetAddrConstant", eic_GetAddrConstant }, 
{"GetAddrStruct", eic_GetAddrStruct }, 
{"SetAddrConstant", eic_SetAddrConstant }, 
{"SetAddrStruct", eic_SetAddrStruct }, 
{"DefineDataType", eic_DefineDataType},
{"DeleteDataType", eic_DeleteDataType},
{"GetDataType", eic_GetDataType},
{"DefineStruct", eic_DefineStruct},
{"DefineStructMember", eic_DefineStructMember},
{"GetStruct", eic_GetStruct},
{"GetStructID", eic_GetStructID},
{"GetStructMember", eic_GetStructMember},
{"ApplyStructure", eic_ApplyStructure},
{"DelStruct", eic_DelStruct},
{"DelStructMember", eic_DelStructMember},
{"DefineConstant", eic_DefineConstant }, 
{"GetConstant", eic_GetConstant }, 
{"GetConstantNext", eic_GetConstantNext }, 
{"GetConstantName", eic_GetConstantName }, 
{"GetConstantID", eic_GetConstantID }, 
{"DelConstant", eic_DelConstant }, 
{"DefineCode", eic_DefineCode }, 
{"UndefineCode", eic_UndefineCode }, 
{"GetNextCode", eic_GetNextCode }, 
{"GetNextData", eic_GetNextData }, 
{"opcmp", eic_opcmp }, 
{"DefineCodeEffect", eic_DefineCodeEffect }, 
{"GetString", eic_GetString }, 
{"GetEntireString", eic_GetEntireString }, 
{"DefineString", eic_DefineString }, 
{"DumpStrings", eic_DumpStrings }, 
{"FindStringsInRange", eic_FindStringsInRange }, 
{"DefineImport", eic_DefineImport }, 
{"GetImportName", eic_GetImportName }, 
{"GetImportLib", eic_GetImportLib }, 
{"GetImportType", eic_GetImportType }, 
{"DumpImports", eic_DumpImports }, 
{"DefineLibrary", eic_DefineLibrary }, 
{"DumpLibs", eic_DumpLibs }, 
{"DefineExport", eic_DefineExport }, 
{"GetExport", eic_GetExport }, 
{"DumpExports", eic_DumpExports }, 
{"DefineRef", eic_DefineRef }, 
{"DefineFunc", eic_DefineFunc }, 
{"GetFuncName", eic_GetFuncName }, 
{"GetFuncStart", eic_GetFuncStart }, 
{"GetFuncEnd", eic_GetFuncEnd }, 
{"GetFuncByName", eic_GetFuncByName }, 
{"SetFuncName", eic_SetFuncName }, 
{"SetFuncSize", eic_SetFuncSize }, 
{"RunScript", eic_RunScript }, 
{"RunScriptText", eic_RunScriptText }, 
{"RunCompiledScript", eic_RunCompiledScript }, 
{"CompileScript", eic_CompileScript }, 
{"DefineMacro", eic_DefineMacro }, 
{"UndefineMacro", eic_UndefineMacro }, 
{"RunMacro", eic_RunMacro }, 
{"RecordMacro", eic_RecordMacro }, 
{"FindBytes", eic_FindBytes }, 
{"FindOperand", eic_FindOperand }, 
{"FindMnemonic", eic_FindMnemonic }, 
{"FindConstant", eic_FindConstant }, 
{"FreeSearchHandle", eic_FreeSearchHandle }, 
{"FindNextOpRead", eic_FindNextOpRead }, 
{"FindPrevOpRead", eic_FindPrevOpRead }, 
{"FindNextOpWrite", eic_FindNextOpWrite }, 
{"FindPrevOpWrite", eic_FindPrevOpWrite }, 
{"FindNextOpExec", eic_FindNextOpExec }, 
{"FindPrevOpExec", eic_FindPrevOpExec }, 
{"SetPager", eic_SetPager }, 
{"SetEditor", eic_SetEditor }, 
{"SetDebugger", eic_SetDebugger }, 
{"GetEnvFlag", eic_GetEnvFlag }, 
{"SetEnvFlag", eic_SetEnvFlag }, 
{"ClearEnvFlag", eic_ClearEnvFlag }, 
{"SetTtyAsmFmt", eic_SetTtyAsmFmt }, 
{"SetTtyDataFmt", eic_SetTtyDataFmt }, 
{"SetFileAsmFmt", eic_SetFileAsmFmt }, 
{"SetFileDataFmt", eic_SetFileDataFmt }, 
{"SetLprAsmFmt", eic_SetLprAsmFmt }, 
{"SetLprDataFmt", eic_SetLprDataFmt }, 
{"Exec", eic_Exec }, 
{"Debug", eic_Debug }, 
{"SetLastError", eic_SetLastError }, 
{"GetLastError", eic_GetLastError }, 
{"GetLastErrorString", eic_GetLastErrorString }, 
{"PrintErrorMsg", eic_PrintErrorMsg }, 
{"SprintErrorMsg", eic_SprintErrorMsg }, 
{"ClearTarget", eic_ClearTarget }, 
{"DelComment", eic_DelComment }, 
{"DisAddrSize", eic_DisAddrSize }, 
{"DisByteOrder", eic_DisByteOrder }, 
{"DisByteSize", eic_DisByteSize }, 
{"DisDwordSize", eic_DisDwordSize }, 
{"DisGetIP", eic_DisGetIP }, 
{"DisGetSP", eic_DisGetSP }, 
{"DisWordSize", eic_DisWordSize }, 
{"DisassembleAllPasses", eic_DisassembleAllPasses }, 
{"ErrorMsg", eic_ErrorMsg }, 
{"GetCodeRep", eic_GetCodeRep }, 
{"GetDebugger", eic_GetDebugger }, 
{"GetBastardEnv", eic_GetBastardEnv }, 
{"GetBastardHome", eic_GetBastardHome }, 
{"GetBastardPrefs", eic_GetBastardPrefs }, 
{"GetBastardTgt", eic_GetBastardTgt }, 
{"GetEditor", eic_GetEditor }, 
{"GetNextRefFrom", eic_GetNextRefFrom }, 
{"GetNextRefTo", eic_GetNextRefTo }, 
{"GetPager", eic_GetPager }, 
{"GetRefFrom", eic_GetRefFrom }, 
{"GetRefTo      ", eic_GetRefTo       }, 
{"GetTargetFD", eic_GetTargetFD }, 
{"GetTargetImage", eic_GetTargetImage }, 
{"GetTargetSize", eic_GetTargetSize }, 
{"Message", eic_Message }, 
{"Quit", eic_Quit }, 
{"SetEnvDefaults", eic_SetEnvDefaults }, 
{"SetPrefDefaults", eic_SetPrefDefaults }, 
{"SetTargetDefaults", eic_SetTargetDefaults }, 
{NULL, NULL} };


int EicLoadApi(){
   int x;
   
   for (x = 0; eic_wrappers[x].name != NULL; x++){
      EiC_add_builtinfunc(eic_wrappers[x].name, eic_wrappers[x].func);
   }
   return(x);
}
