#line 1 "funcs.c"
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:CHECKCOLORSINGAMUT, hdc pvoid pvoid0 dword)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  void* pvoid;
  void* pvoid0;
  DWORD dword;
  arg = popSTACK();
  check_uint(arg);
  dword = I_to_uint32(arg);
  arg = popSTACK();
  if(!simple_bit_vector_p(Atype_8Bit,arg))argumentum_inritum(arg);
  pvoid0 = &(TheSbvector(arg)->data);
  arg = popSTACK();
  if(!simple_bit_vector_p(Atype_8Bit,arg))argumentum_inritum(arg);
  pvoid = &(TheSbvector(arg)->data);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  bool0 = CheckColorsInGamut(hdc,pvoid,pvoid0,dword);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:COMBINETRANSFORM, lpxform xform_p xform_p0)
{
  object arg0;
  BOOL bool0;
  XFORM lpxform;
  XFORM xform_p;
  XFORM xform_p0;
  arg0 = popSTACK();
  processXFORM(&xform_p0,arg0);
  arg0 = popSTACK();
  processXFORM(&xform_p,arg0);
  arg0 = popSTACK();
  begin_system_call();
  bool0 = CombineTransform(&lpxform,&xform_p,&xform_p0);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    outputXFORM(&lpxform,arg0);
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:CREATEDIBSECTION, hdc bitmapinfo_p uint handle dword)
{
  object arg;
  HBITMAP hbitmap;
  HDC hdc;
  BITMAPINFO* bitmapinfo_p = alloca(sizeof(BITMAPINFO));
  UINT uint;
  void *voidp;
  HANDLE handle;
  DWORD dword;
  arg = popSTACK();
  check_uint(arg);
  dword = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  handle = (nullp(arg))?0:(TheFpointer(arg)->fp_pointer);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  processBITMAPINFO(bitmapinfo_p,arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  hbitmap = CreateDIBSection(hdc,bitmapinfo_p,uint,&voidp,handle,dword);
  end_system_call();
  if(NULL ==hbitmap){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = allocate_fpointer(hbitmap);
    value3 = allocate_fpointer(voidp);
    mv_count=3;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:ENUMENHMETAFILE, hdc henhmetafile enhmfenumproc pvoid lpcrect)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  HENHMETAFILE henhmetafile;
  ENHMFENUMPROC enhmfenumproc;
  void* pvoid;
  RECT* lpcrect = alloca(sizeof(RECT));
  object arg0;
  arg0 = popSTACK();
  processRECT(lpcrect,arg0);
  arg = popSTACK();
  if(!simple_bit_vector_p(Atype_8Bit,arg))argumentum_inritum(arg);
  pvoid = &(TheSbvector(arg)->data);
  arg0 = popSTACK();
  processENHMFENUMPROC(enhmfenumproc,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  henhmetafile = TheFpointer(arg)->fp_pointer;
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processRECT(lpcrect,arg0);
  begin_system_call();
  bool0 = EnumEnhMetaFile(hdc,henhmetafile,enhmfenumproc,pvoid,lpcrect);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
/*
DEFUN( GDI:ENUMFONTFAMILIESA, hdc lpcstr fontenumproca lparam)
{
  object arg;
  int int0;
  HDC hdc;
  LPCSTR lpcstr;
  FONTENUMPROCA fontenumproca;
  ARAM* lparam = alloca(sizeof(ARAM));
  object arg0;
  arg = popSTACK();
  check_sint(arg);
  lparam = I_to_sint32(arg);
  arg0 = popSTACK();
  processFONTENUMPROCA(fontenumproca,arg0);
  arg = popSTACK();
  if(!stringp(arg))argumentum_inritum(arg);
  lpcstr = TheAsciz(string_to_asciz(arg,encoding));
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processARAM(lparam,arg0);
  begin_system_call();
  int0 = EnumFontFamiliesA(hdc,lpcstr,fontenumproca,lparam);
  end_system_call();
  if(0 <=int0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(int0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:ENUMFONTFAMILIESEXA, hdc plogfonta fontenumproca lparam dword)
{
  object arg;
  int int0;
  HDC hdc;
  PLOGFONTA plogfonta;
  FONTENUMPROCA fontenumproca;
  ARAM* lparam = alloca(sizeof(ARAM));
  object arg0;
  DWORD dword;
  arg = popSTACK();
  check_uint(arg);
  dword = I_to_uint32(arg);
  arg = popSTACK();
  check_sint(arg);
  lparam = I_to_sint32(arg);
  arg0 = popSTACK();
  processFONTENUMPROCA(fontenumproca,arg0);
  arg0 = popSTACK();
  processPLOGFONTA(plogfonta,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processARAM(lparam,arg0);
  begin_system_call();
  int0 = EnumFontFamiliesExA(hdc,plogfonta,fontenumproca,lparam,dword);
  end_system_call();
  if(0 <=int0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(int0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:ENUMFONTFAMILIESEXW, hdc plogfontw fontenumprocw lparam dword)
{
  object arg;
  int int0;
  HDC hdc;
  PLOGFONTW plogfontw;
  FONTENUMPROCW fontenumprocw;
  ARAM* lparam = alloca(sizeof(ARAM));
  object arg0;
  DWORD dword;
  arg = popSTACK();
  check_uint(arg);
  dword = I_to_uint32(arg);
  arg = popSTACK();
  check_sint(arg);
  lparam = I_to_sint32(arg);
  arg0 = popSTACK();
  processFONTENUMPROCW(fontenumprocw,arg0);
  arg0 = popSTACK();
  processPLOGFONTW(plogfontw,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processARAM(lparam,arg0);
  begin_system_call();
  int0 = EnumFontFamiliesExW(hdc,plogfontw,fontenumprocw,lparam,dword);
  end_system_call();
  if(0 <=int0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(int0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:ENUMFONTFAMILIESW, hdc lpcwstr fontenumprocw lparam)
{
  object arg;
  int int0;
  HDC hdc;
  LPCWSTR lpcwstr;
  FONTENUMPROCW fontenumprocw;
  ARAM* lparam = alloca(sizeof(ARAM));
  object arg0;
  arg = popSTACK();
  check_sint(arg);
  lparam = I_to_sint32(arg);
  arg0 = popSTACK();
  processFONTENUMPROCW(fontenumprocw,arg0);
  arg = popSTACK();
  if(!stringp(arg))argumentum_inritum(arg);
  lpcwstr = WIDECHAR(arg,encoding);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processARAM(lparam,arg0);
  begin_system_call();
  int0 = EnumFontFamiliesW(hdc,lpcwstr,fontenumprocw,lparam);
  end_system_call();
  if(0 <=int0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(int0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:ENUMFONTSA, hdc lpcstr fontenumproca lparam)
{
  object arg;
  int int0;
  HDC hdc;
  LPCSTR lpcstr;
  FONTENUMPROCA fontenumproca;
  ARAM* lparam = alloca(sizeof(ARAM));
  object arg0;
  arg = popSTACK();
  check_sint(arg);
  lparam = I_to_sint32(arg);
  arg0 = popSTACK();
  processFONTENUMPROCA(fontenumproca,arg0);
  arg = popSTACK();
  if(!stringp(arg))argumentum_inritum(arg);
  lpcstr = TheAsciz(string_to_asciz(arg,encoding));
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processARAM(lparam,arg0);
  begin_system_call();
  int0 = EnumFontsA(hdc,lpcstr,fontenumproca,lparam);
  end_system_call();
  if(0 <=int0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(int0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:ENUMFONTSW, hdc lpcwstr fontenumproca lparam)
{
  object arg;
  int int0;
  HDC hdc;
  LPCWSTR lpcwstr;
  FONTENUMPROCA fontenumproca;
  ARAM* lparam = alloca(sizeof(ARAM));
  object arg0;
  arg = popSTACK();
  check_sint(arg);
  lparam = I_to_sint32(arg);
  arg0 = popSTACK();
  processFONTENUMPROCA(fontenumproca,arg0);
  arg = popSTACK();
  if(!stringp(arg))argumentum_inritum(arg);
  lpcwstr = WIDECHAR(arg,encoding);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processARAM(lparam,arg0);
  begin_system_call();
  int0 = EnumFontsW(hdc,lpcwstr,fontenumproca,lparam);
  end_system_call();
  if(0 <=int0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(int0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:ENUMICMPROFILESA, hdc icmenumproca lparam)
{
  object arg;
  int int0;
  HDC hdc;
  ICMENUMPROCA icmenumproca;
  ARAM* lparam = alloca(sizeof(ARAM));
  object arg0;
  arg = popSTACK();
  check_sint(arg);
  lparam = I_to_sint32(arg);
  arg0 = popSTACK();
  processICMENUMPROCA(icmenumproca,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processARAM(lparam,arg0);
  begin_system_call();
  int0 = EnumICMProfilesA(hdc,icmenumproca,lparam);
  end_system_call();
  if(0 <=int0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(int0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:ENUMICMPROFILESW, hdc icmenumprocw lparam)
{
  object arg;
  int int0;
  HDC hdc;
  ICMENUMPROCW icmenumprocw;
  ARAM* lparam = alloca(sizeof(ARAM));
  object arg0;
  arg = popSTACK();
  check_sint(arg);
  lparam = I_to_sint32(arg);
  arg0 = popSTACK();
  processICMENUMPROCW(icmenumprocw,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processARAM(lparam,arg0);
  begin_system_call();
  int0 = EnumICMProfilesW(hdc,icmenumprocw,lparam);
  end_system_call();
  if(0 <=int0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(int0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:ENUMMETAFILE, hdc hmetafile mfenumproc lparam)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  HMETAFILE hmetafile;
  MFENUMPROC mfenumproc;
  ARAM* lparam = alloca(sizeof(ARAM));
  object arg0;
  arg = popSTACK();
  check_sint(arg);
  lparam = I_to_sint32(arg);
  arg0 = popSTACK();
  processMFENUMPROC(mfenumproc,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hmetafile = TheFpointer(arg)->fp_pointer;
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processARAM(lparam,arg0);
  begin_system_call();
  bool0 = EnumMetaFile(hdc,hmetafile,mfenumproc,lparam);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:ENUMOBJECTS, hdc int0 gobjenumproc lparam)
{
  object arg;
  int int1;
  HDC hdc;
  int int0;
  GOBJENUMPROC gobjenumproc;
  ARAM* lparam = alloca(sizeof(ARAM));
  object arg0;
  arg = popSTACK();
  check_sint(arg);
  lparam = I_to_sint32(arg);
  arg0 = popSTACK();
  processGOBJENUMPROC(gobjenumproc,arg0);
  arg = popSTACK();
  check_sint(arg);
  int0 = I_to_sint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processARAM(lparam,arg0);
  begin_system_call();
  int1 = EnumObjects(hdc,int0,gobjenumproc,lparam);
  end_system_call();
  if(0 <=int1){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(int1);
    mv_count=2;
  }
  return;
}
*/
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETASPECTRATIOFILTEREX, hdc lpsize)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  SIZE* lpsize = alloca(sizeof(SIZE));
  object arg0;
  arg0 = popSTACK();
  processSIZE(lpsize,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processSIZE(lpsize,arg0);
  begin_system_call();
  bool0 = GetAspectRatioFilterEx(hdc,lpsize);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETBITMAPBITS, hbitmap long0 pvoid)
{
  object arg;
  LONG long1;
  HBITMAP hbitmap;
  LONG long0;
  void* pvoid;
  arg = popSTACK();
  if(!simple_bit_vector_p(Atype_8Bit,arg))argumentum_inritum(arg);
  pvoid = &(TheSbvector(arg)->data);
  arg = popSTACK();
  check_sint(arg);
  long0 = I_to_sint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hbitmap = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  long1 = GetBitmapBits(hbitmap,long0,pvoid);
  end_system_call();
  if(0 <=long1){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(long1);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETBITMAPDIMENSIONEX, hbitmap)
{
  object arg;
  BOOL bool0;
  HBITMAP hbitmap;
  SIZE lpsize;
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hbitmap = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  bool0 = GetBitmapDimensionEx(hbitmap,&lpsize);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    pushSTACK( uint32_to_I(lpsize.cy));
    value2 = uint32_to_I(lpsize.cx);
    value3 = popSTACK();
    value1 = T;
    mv_count=3;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETBOUNDSRECT, hdc lprect uint)
{
  object arg;
  UINT uint0;
  HDC hdc;
  RECT* lprect = alloca(sizeof(RECT));
  object arg0;
  UINT uint;
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg0 = popSTACK();
  processRECT(lprect,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processRECT(lprect,arg0);
  begin_system_call();
  uint0 = GetBoundsRect(hdc,lprect,uint);
  end_system_call();
  if(0 <=uint0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = uint32_to_I(uint0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETBRUSHORGEX, hdc lppoint)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  POINT* lppoint = alloca(sizeof(POINT));
  object arg0;
  arg0 = popSTACK();
  processPOINT(lppoint,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processPOINT(lppoint,arg0);
  begin_system_call();
  bool0 = GetBrushOrgEx(hdc,lppoint);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETCHARABCWIDTHSA, hdc uint uint0 lpabc)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  UINT uint;
  UINT uint0;
  ABC* lpabc = alloca(sizeof(ABC));
  object arg0;
  arg0 = popSTACK();
  processABC(lpabc,arg0);
  arg = popSTACK();
  check_uint(arg);
  uint0 = I_to_uint32(arg);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processABC(lpabc,arg0);
  begin_system_call();
  bool0 = GetCharABCWidthsA(hdc,uint,uint0,lpabc);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETCHARABCWIDTHSFLOATA, hdc uint uint0 lpabcfloat)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  UINT uint;
  UINT uint0;
  ABCFLOAT* lpabcfloat = alloca(sizeof(ABCFLOAT));
  object arg0;
  arg0 = popSTACK();
  processABCFLOAT(lpabcfloat,arg0);
  arg = popSTACK();
  check_uint(arg);
  uint0 = I_to_uint32(arg);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processABCFLOAT(lpabcfloat,arg0);
  begin_system_call();
  bool0 = GetCharABCWidthsFloatA(hdc,uint,uint0,lpabcfloat);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETCHARABCWIDTHSFLOATW, hdc uint uint0 lpabcfloat)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  UINT uint;
  UINT uint0;
  ABCFLOAT* lpabcfloat = alloca(sizeof(ABCFLOAT));
  object arg0;
  arg0 = popSTACK();
  processABCFLOAT(lpabcfloat,arg0);
  arg = popSTACK();
  check_uint(arg);
  uint0 = I_to_uint32(arg);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processABCFLOAT(lpabcfloat,arg0);
  begin_system_call();
  bool0 = GetCharABCWidthsFloatW(hdc,uint,uint0,lpabcfloat);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETCHARABCWIDTHSW, hdc uint uint0 lpabc)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  UINT uint;
  UINT uint0;
  ABC* lpabc = alloca(sizeof(ABC));
  object arg0;
  arg0 = popSTACK();
  processABC(lpabc,arg0);
  arg = popSTACK();
  check_uint(arg);
  uint0 = I_to_uint32(arg);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processABC(lpabc,arg0);
  begin_system_call();
  bool0 = GetCharABCWidthsW(hdc,uint,uint0,lpabc);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETCHARWIDTH32A, hdc uint uint0 lpint)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  UINT uint;
  UINT uint0;
  int* lpint;
  arg = popSTACK();
  if(!simple_bit_vector_p(Atype_32Bit,arg))argumentum_inritum(arg);
  lpint = &(TheSbvector(arg)->data);
  arg = popSTACK();
  check_uint(arg);
  uint0 = I_to_uint32(arg);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  bool0 = GetCharWidth32A(hdc,uint,uint0,lpint);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETCHARWIDTH32W, hdc uint uint0 lpint)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  UINT uint;
  UINT uint0;
  int* lpint;
  arg = popSTACK();
  if(!simple_bit_vector_p(Atype_32Bit,arg))argumentum_inritum(arg);
  lpint = &(TheSbvector(arg)->data);
  arg = popSTACK();
  check_uint(arg);
  uint0 = I_to_uint32(arg);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  bool0 = GetCharWidth32W(hdc,uint,uint0,lpint);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETCHARWIDTHA, hdc uint uint0 lpint)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  UINT uint;
  UINT uint0;
  int* lpint;
  arg = popSTACK();
  if(!simple_bit_vector_p(Atype_32Bit,arg))argumentum_inritum(arg);
  lpint = &(TheSbvector(arg)->data);
  arg = popSTACK();
  check_uint(arg);
  uint0 = I_to_uint32(arg);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  bool0 = GetCharWidthA(hdc,uint,uint0,lpint);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETCHARWIDTHW, hdc uint uint0 lpint)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  UINT uint;
  UINT uint0;
  int* lpint;
  arg = popSTACK();
  if(!simple_bit_vector_p(Atype_32Bit,arg))argumentum_inritum(arg);
  lpint = &(TheSbvector(arg)->data);
  arg = popSTACK();
  check_uint(arg);
  uint0 = I_to_uint32(arg);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  bool0 = GetCharWidthW(hdc,uint,uint0,lpint);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETCLIPBOX, hdc lprect)
{
  object arg;
  int int0;
  HDC hdc;
  RECT* lprect = alloca(sizeof(RECT));
  object arg0;
  arg0 = popSTACK();
  processRECT(lprect,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processRECT(lprect,arg0);
  begin_system_call();
  int0 = GetClipBox(hdc,lprect);
  end_system_call();
  if(0 <=int0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(int0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETCOLORADJUSTMENT, hdc lpcoloradjustment)
{
  BOOL bool0;
  HDC hdc;
  COLORADJUSTMENT lpcoloradjustment;
  object arg0 = popSTACK();
  object arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  bool0 = GetColorAdjustment(hdc,&lpcoloradjustment);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    outputCOLORADJUSTMENT(&lpcoloradjustment,arg0);
    value2 = arg0;
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETCURRENTPOSITIONEX, hdc lppoint)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  POINT* lppoint = alloca(sizeof(POINT));
  object arg0;
  arg0 = popSTACK();
  processPOINT(lppoint,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processPOINT(lppoint,arg0);
  begin_system_call();
  bool0 = GetCurrentPositionEx(hdc,lppoint);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETDCORGEX, hdc lppoint)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  POINT* lppoint = alloca(sizeof(POINT));
  object arg0;
  arg0 = popSTACK();
  processPOINT(lppoint,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processPOINT(lppoint,arg0);
  begin_system_call();
  bool0 = GetDCOrgEx(hdc,lppoint);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETDIBCOLORTABLE, hdc uint uint0 rgbquad_p)
{
  object arg;
  UINT uint1;
  HDC hdc;
  UINT uint;
  UINT uint0;
  RGBQUAD* rgbquad_p = alloca(sizeof(RGBQUAD));
  object arg0;
  arg0 = popSTACK();
  processRGBQUAD(rgbquad_p,arg0);
  arg = popSTACK();
  check_uint(arg);
  uint0 = I_to_uint32(arg);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processRGBQUAD(rgbquad_p,arg0);
  begin_system_call();
  uint1 = GetDIBColorTable(hdc,uint,uint0,rgbquad_p);
  end_system_call();
  if(0 <=uint1){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = uint32_to_I(uint1);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETDEVICEGAMMARAMP, hdc pvoid)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  void* pvoid;
  arg = popSTACK();
  if(!simple_bit_vector_p(Atype_8Bit,arg))argumentum_inritum(arg);
  pvoid = &(TheSbvector(arg)->data);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  bool0 = GetDeviceGammaRamp(hdc,pvoid);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETENHMETAFILEA, lpcstr)
{
  object arg;
  HENHMETAFILE henhmetafile;
  LPCSTR lpcstr;
  arg = popSTACK();
  if(!stringp(arg))argumentum_inritum(arg);
  lpcstr = TheAsciz(string_to_asciz(arg,encoding));
  begin_system_call();
  henhmetafile = GetEnhMetaFileA(lpcstr);
  end_system_call();
  if(NULL ==henhmetafile){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = allocate_fpointer(henhmetafile);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETENHMETAFILEDESCRIPTIONA, henhmetafile uint lpstr)
{
  object arg;
  UINT uint0;
  HENHMETAFILE henhmetafile;
  UINT uint;
  LPSTR lpstr;
  arg = popSTACK();
  if(!stringp(arg))argumentum_inritum(arg);
  lpstr = TheAsciz(string_to_asciz(arg,encoding));
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  henhmetafile = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  uint0 = GetEnhMetaFileDescriptionA(henhmetafile,uint,lpstr);
  end_system_call();
  if(0 <=uint0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = uint32_to_I(uint0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETENHMETAFILEDESCRIPTIONW, henhmetafile uint lpwstr)
{
  object arg;
  UINT uint0;
  HENHMETAFILE henhmetafile;
  UINT uint;
  LPWSTR lpwstr;
  arg = popSTACK();
  if(!stringp(arg))argumentum_inritum(arg);
  lpwstr = WIDECHAR(arg,encoding);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  henhmetafile = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  uint0 = GetEnhMetaFileDescriptionW(henhmetafile,uint,lpwstr);
  end_system_call();
  if(0 <=uint0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = uint32_to_I(uint0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETENHMETAFILEHEADER, henhmetafile uint lpenhmetaheader)
{
  object arg;
  UINT uint0;
  HENHMETAFILE henhmetafile;
  UINT uint;
  ENHMETAHEADER* lpenhmetaheader = alloca(sizeof(ENHMETAHEADER));
  object arg0;
  arg0 = popSTACK();
  processENHMETAHEADER(lpenhmetaheader,arg0);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  henhmetafile = TheFpointer(arg)->fp_pointer;
  processENHMETAHEADER(lpenhmetaheader,arg0);
  begin_system_call();
  uint0 = GetEnhMetaFileHeader(henhmetafile,uint,lpenhmetaheader);
  end_system_call();
  if(0 <=uint0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = uint32_to_I(uint0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETENHMETAFILEPALETTEENTRIES, henhmetafile uint lppaletteentry)
{
  object arg;
  UINT uint0;
  HENHMETAFILE henhmetafile;
  UINT uint;
  PALETTEENTRY* lppaletteentry = alloca(sizeof(PALETTEENTRY));
  object arg0;
  arg0 = popSTACK();
  processPALETTEENTRY(lppaletteentry,arg0);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  henhmetafile = TheFpointer(arg)->fp_pointer;
  processPALETTEENTRY(lppaletteentry,arg0);
  begin_system_call();
  uint0 = GetEnhMetaFilePaletteEntries(henhmetafile,uint,lppaletteentry);
  end_system_call();
  if(0 <=uint0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = uint32_to_I(uint0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETENHMETAFILEPIXELFORMAT, henhmetafile dword pixelformatdescriptor_p)
{
  object arg;
  UINT uint;
  HENHMETAFILE henhmetafile;
  DWORD dword;
  PIXELFORMATDESCRIPTOR* pixelformatdescriptor_p = alloca(sizeof(PIXELFORMATDESCRIPTOR));
  object arg0;
  arg0 = popSTACK();
  processPIXELFORMATDESCRIPTOR(pixelformatdescriptor_p,arg0);
  arg = popSTACK();
  check_uint(arg);
  dword = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  henhmetafile = TheFpointer(arg)->fp_pointer;
  processPIXELFORMATDESCRIPTOR(pixelformatdescriptor_p,arg0);
  begin_system_call();
  uint = GetEnhMetaFilePixelFormat(henhmetafile,dword,pixelformatdescriptor_p);
  end_system_call();
  if(0 <=uint){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = uint32_to_I(uint);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETENHMETAFILEW, lpcwstr)
{
  object arg;
  HENHMETAFILE henhmetafile;
  LPCWSTR lpcwstr;
  arg = popSTACK();
  if(!stringp(arg))argumentum_inritum(arg);
  lpcwstr = WIDECHAR(arg,encoding);
  begin_system_call();
  henhmetafile = GetEnhMetaFileW(lpcwstr);
  end_system_call();
  if(NULL ==henhmetafile){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = allocate_fpointer(henhmetafile);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETFONTDATA, hdc dword dword0 pvoid dword1)
{
  object arg;
  DWORD dword2;
  HDC hdc;
  DWORD dword;
  DWORD dword0;
  void* pvoid;
  DWORD dword1;
  arg = popSTACK();
  check_uint(arg);
  dword1 = I_to_uint32(arg);
  arg = popSTACK();
  if(!simple_bit_vector_p(Atype_8Bit,arg))argumentum_inritum(arg);
  pvoid = &(TheSbvector(arg)->data);
  arg = popSTACK();
  check_uint(arg);
  dword0 = I_to_uint32(arg);
  arg = popSTACK();
  check_uint(arg);
  dword = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  dword2 = GetFontData(hdc,dword,dword0,pvoid,dword1);
  end_system_call();
  if(0 <=dword2){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = uint32_to_I(dword2);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETICMPROFILEA, hdc dword lpstr)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  DWORD dword;
  LPSTR lpstr;
  arg = popSTACK();
  if(!stringp(arg))argumentum_inritum(arg);
  lpstr = TheAsciz(string_to_asciz(arg,encoding));
  arg = popSTACK();
  check_uint(arg);
  dword = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  bool0 = GetICMProfileA(hdc,dword,lpstr);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETICMPROFILEW, hdc dword lpwstr)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  DWORD dword;
  LPWSTR lpwstr;
  arg = popSTACK();
  if(!stringp(arg))argumentum_inritum(arg);
  lpwstr = WIDECHAR(arg,encoding);
  arg = popSTACK();
  check_uint(arg);
  dword = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  bool0 = GetICMProfileW(hdc,dword,lpwstr);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETKERNINGPAIRSA, hdc dword lpkerningpair)
{
  object arg;
  DWORD dword0;
  HDC hdc;
  DWORD dword;
  KERNINGPAIR* lpkerningpair = alloca(sizeof(KERNINGPAIR));
  object arg0;
  arg0 = popSTACK();
  processKERNINGPAIR(lpkerningpair,arg0);
  arg = popSTACK();
  check_uint(arg);
  dword = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processKERNINGPAIR(lpkerningpair,arg0);
  begin_system_call();
  dword0 = GetKerningPairsA(hdc,dword,lpkerningpair);
  end_system_call();
  if(0 <=dword0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = uint32_to_I(dword0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETKERNINGPAIRSW, hdc dword lpkerningpair)
{
  object arg;
  DWORD dword0;
  HDC hdc;
  DWORD dword;
  KERNINGPAIR* lpkerningpair = alloca(sizeof(KERNINGPAIR));
  object arg0;
  arg0 = popSTACK();
  processKERNINGPAIR(lpkerningpair,arg0);
  arg = popSTACK();
  check_uint(arg);
  dword = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processKERNINGPAIR(lpkerningpair,arg0);
  begin_system_call();
  dword0 = GetKerningPairsW(hdc,dword,lpkerningpair);
  end_system_call();
  if(0 <=dword0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = uint32_to_I(dword0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETLOGCOLORSPACEA, hcolorspace lplogcolorspacea dword)
{
  object arg;
  BOOL bool0;
  HCOLORSPACE hcolorspace;
  LOGCOLORSPACEA* lplogcolorspacea = alloca(sizeof(LOGCOLORSPACEA));
  object arg0;
  DWORD dword;
  arg = popSTACK();
  check_uint(arg);
  dword = I_to_uint32(arg);
  arg0 = popSTACK();
  processLOGCOLORSPACEA(lplogcolorspacea,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hcolorspace = TheFpointer(arg)->fp_pointer;
  processLOGCOLORSPACEA(lplogcolorspacea,arg0);
  begin_system_call();
  bool0 = GetLogColorSpaceA(hcolorspace,lplogcolorspacea,dword);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETLOGCOLORSPACEW, hcolorspace lplogcolorspacew dword)
{
  object arg;
  BOOL bool0;
  HCOLORSPACE hcolorspace;
  LOGCOLORSPACEW* lplogcolorspacew = alloca(sizeof(LOGCOLORSPACEW));
  object arg0;
  DWORD dword;
  arg = popSTACK();
  check_uint(arg);
  dword = I_to_uint32(arg);
  arg0 = popSTACK();
  processLOGCOLORSPACEW(lplogcolorspacew,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hcolorspace = TheFpointer(arg)->fp_pointer;
  processLOGCOLORSPACEW(lplogcolorspacew,arg0);
  begin_system_call();
  bool0 = GetLogColorSpaceW(hcolorspace,lplogcolorspacew,dword);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETMETAFILEA, lpcstr)
{
  object arg;
  HMETAFILE hmetafile;
  LPCSTR lpcstr;
  arg = popSTACK();
  if(!stringp(arg))argumentum_inritum(arg);
  lpcstr = TheAsciz(string_to_asciz(arg,encoding));
  begin_system_call();
  hmetafile = GetMetaFileA(lpcstr);
  end_system_call();
  if(NULL ==hmetafile){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = allocate_fpointer(hmetafile);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETMETAFILEBITSEX, hmetafile uint pvoid)
{
  object arg;
  UINT uint0;
  HMETAFILE hmetafile;
  UINT uint;
  void* pvoid;
  arg = popSTACK();
  if(!simple_bit_vector_p(Atype_8Bit,arg))argumentum_inritum(arg);
  pvoid = &(TheSbvector(arg)->data);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hmetafile = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  uint0 = GetMetaFileBitsEx(hmetafile,uint,pvoid);
  end_system_call();
  if(0 <=uint0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = uint32_to_I(uint0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETMETAFILEW, lpcwstr)
{
  object arg;
  HMETAFILE hmetafile;
  LPCWSTR lpcwstr;
  arg = popSTACK();
  if(!stringp(arg))argumentum_inritum(arg);
  lpcwstr = WIDECHAR(arg,encoding);
  begin_system_call();
  hmetafile = GetMetaFileW(lpcwstr);
  end_system_call();
  if(NULL ==hmetafile){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = allocate_fpointer(hmetafile);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETOBJECTA, hgdiobj int0 pvoid)
{
  object arg;
  int int1;
  HGDIOBJ hgdiobj;
  int int0;
  void* pvoid;
  arg = popSTACK();
  if(!simple_bit_vector_p(Atype_8Bit,arg))argumentum_inritum(arg);
  pvoid = &(TheSbvector(arg)->data);
  arg = popSTACK();
  check_sint(arg);
  int0 = I_to_sint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hgdiobj = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  int1 = GetObjectA(hgdiobj,int0,pvoid);
  end_system_call();
  if(0 <=int1){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(int1);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETOBJECTW, hgdiobj int0 pvoid)
{
  object arg;
  int int1;
  HGDIOBJ hgdiobj;
  int int0;
  void* pvoid;
  arg = popSTACK();
  if(!simple_bit_vector_p(Atype_8Bit,arg))argumentum_inritum(arg);
  pvoid = &(TheSbvector(arg)->data);
  arg = popSTACK();
  check_sint(arg);
  int0 = I_to_sint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hgdiobj = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  int1 = GetObjectW(hgdiobj,int0,pvoid);
  end_system_call();
  if(0 <=int1){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(int1);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETOUTLINETEXTMETRICSA, hdc uint lpoutlinetextmetrica)
{
  object arg;
  UINT uint0;
  HDC hdc;
  UINT uint;
  OUTLINETEXTMETRICA* lpoutlinetextmetrica = alloca(sizeof(OUTLINETEXTMETRICA));
  object arg0;
  arg0 = popSTACK();
  processOUTLINETEXTMETRICA(lpoutlinetextmetrica,arg0);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processOUTLINETEXTMETRICA(lpoutlinetextmetrica,arg0);
  begin_system_call();
  uint0 = GetOutlineTextMetricsA(hdc,uint,lpoutlinetextmetrica);
  end_system_call();
  if(0 <=uint0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = uint32_to_I(uint0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETOUTLINETEXTMETRICSW, hdc uint lpoutlinetextmetricw)
{
  object arg;
  UINT uint0;
  HDC hdc;
  UINT uint;
  OUTLINETEXTMETRICW* lpoutlinetextmetricw = alloca(sizeof(OUTLINETEXTMETRICW));
  object arg0;
  arg0 = popSTACK();
  processOUTLINETEXTMETRICW(lpoutlinetextmetricw,arg0);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processOUTLINETEXTMETRICW(lpoutlinetextmetricw,arg0);
  begin_system_call();
  uint0 = GetOutlineTextMetricsW(hdc,uint,lpoutlinetextmetricw);
  end_system_call();
  if(0 <=uint0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = uint32_to_I(uint0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETPALETTEENTRIES, hpalette uint uint0 lppaletteentry)
{
  object arg;
  UINT uint1;
  HPALETTE hpalette;
  UINT uint;
  UINT uint0;
  PALETTEENTRY* lppaletteentry = alloca(sizeof(PALETTEENTRY));
  object arg0;
  arg0 = popSTACK();
  processPALETTEENTRY(lppaletteentry,arg0);
  arg = popSTACK();
  check_uint(arg);
  uint0 = I_to_uint32(arg);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hpalette = TheFpointer(arg)->fp_pointer;
  processPALETTEENTRY(lppaletteentry,arg0);
  begin_system_call();
  uint1 = GetPaletteEntries(hpalette,uint,uint0,lppaletteentry);
  end_system_call();
  if(0 <=uint1){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = uint32_to_I(uint1);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETPATH, hdc lppoint pbyte int0)
{
  object arg;
  int int1;
  HDC hdc;
  POINT* lppoint = alloca(sizeof(POINT));
  object arg0;
  PBYTE pbyte;
  int int0;
  arg = popSTACK();
  check_sint(arg);
  int0 = I_to_sint32(arg);
  arg0 = popSTACK();
  processPBYTE(pbyte,arg0);
  arg0 = popSTACK();
  processPOINT(lppoint,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processPOINT(lppoint,arg0);
  begin_system_call();
  int1 = GetPath(hdc,lppoint,pbyte,int0);
  end_system_call();
  if(0 <=int1){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(int1);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETRASTERIZERCAPS, lprasterizer_status uint)
{
  object arg;
  BOOL bool0;
  RASTERIZER_STATUS* lprasterizer_status = alloca(sizeof(RASTERIZER_STATUS));
  object arg0;
  UINT uint;
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg0 = popSTACK();
  processRASTERIZER_STATUS(lprasterizer_status,arg0);
  processRASTERIZER_STATUS(lprasterizer_status,arg0);
  begin_system_call();
  bool0 = GetRasterizerCaps(lprasterizer_status,uint);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETREGIONDATA, hrgn dword lprgndata)
{
  object arg;
  DWORD dword0;
  HRGN hrgn;
  DWORD dword;
  RGNDATA* lprgndata = alloca(sizeof(RGNDATA));
  object arg0;
  arg0 = popSTACK();
  processRGNDATA(lprgndata,arg0);
  arg = popSTACK();
  check_uint(arg);
  dword = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hrgn = TheFpointer(arg)->fp_pointer;
  processRGNDATA(lprgndata,arg0);
  begin_system_call();
  dword0 = GetRegionData(hrgn,dword,lprgndata);
  end_system_call();
  if(0 <=dword0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = uint32_to_I(dword0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETRGNBOX, hrgn lprect)
{
  object arg;
  int int0;
  HRGN hrgn;
  RECT* lprect = alloca(sizeof(RECT));
  object arg0;
  arg0 = popSTACK();
  processRECT(lprect,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hrgn = TheFpointer(arg)->fp_pointer;
  processRECT(lprect,arg0);
  begin_system_call();
  int0 = GetRgnBox(hrgn,lprect);
  end_system_call();
  if(0 <=int0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(int0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETSYSTEMPALETTEENTRIES, hdc uint uint0 lppaletteentry)
{
  object arg;
  UINT uint1;
  HDC hdc;
  UINT uint;
  UINT uint0;
  PALETTEENTRY* lppaletteentry = alloca(sizeof(PALETTEENTRY));
  object arg0;
  arg0 = popSTACK();
  processPALETTEENTRY(lppaletteentry,arg0);
  arg = popSTACK();
  check_uint(arg);
  uint0 = I_to_uint32(arg);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processPALETTEENTRY(lppaletteentry,arg0);
  begin_system_call();
  uint1 = GetSystemPaletteEntries(hdc,uint,uint0,lppaletteentry);
  end_system_call();
  if(0 <=uint1){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = uint32_to_I(uint1);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETTEXTCHARSETINFO, hdc lpfontsignature dword)
{
  object arg;
  int int0;
  HDC hdc;
  FONTSIGNATURE* lpfontsignature = alloca(sizeof(FONTSIGNATURE));
  object arg0;
  DWORD dword;
  arg = popSTACK();
  check_uint(arg);
  dword = I_to_uint32(arg);
  arg0 = popSTACK();
  processFONTSIGNATURE(lpfontsignature,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processFONTSIGNATURE(lpfontsignature,arg0);
  begin_system_call();
  int0 = GetTextCharsetInfo(hdc,lpfontsignature,dword);
  end_system_call();
  if(0 <=int0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(int0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETTEXTEXTENTPOINT32A, hdc lpcstr int0)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  LPCSTR lpcstr;
  int int0;
  SIZE lpsize;
  arg = popSTACK();
  check_sint(arg);
  int0 = I_to_sint32(arg); // fixme remove this argument, and get string length
  arg = popSTACK();
  if(!stringp(arg))argumentum_inritum(arg);
  lpcstr = TheAsciz(string_to_asciz(arg,encoding));
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  bool0 = GetTextExtentPoint32A(hdc,lpcstr,int0,&lpsize);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    pushSTACK( uint32_to_I(lpsize.cy));
    value2 = uint32_to_I(lpsize.cx);
    value3 = popSTACK();
    value1 = T;
    mv_count=3;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETTEXTEXTENTPOINT32W, hdc lpcwstr int0 lpsize)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  LPCWSTR lpcwstr;
  int int0;
  SIZE* lpsize = alloca(sizeof(SIZE));
  object arg0;
  arg0 = popSTACK();
  processSIZE(lpsize,arg0);
  arg = popSTACK();
  check_sint(arg);
  int0 = I_to_sint32(arg);
  arg = popSTACK();
  if(!stringp(arg))argumentum_inritum(arg);
  lpcwstr = WIDECHAR(arg,encoding);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processSIZE(lpsize,arg0);
  begin_system_call();
  bool0 = GetTextExtentPoint32W(hdc,lpcwstr,int0,lpsize);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETTEXTEXTENTPOINTA, hdc lpcstr int0 lpsize)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  LPCSTR lpcstr;
  int int0;
  SIZE* lpsize = alloca(sizeof(SIZE));
  object arg0;
  arg0 = popSTACK();
  processSIZE(lpsize,arg0);
  arg = popSTACK();
  check_sint(arg);
  int0 = I_to_sint32(arg);
  arg = popSTACK();
  if(!stringp(arg))argumentum_inritum(arg);
  lpcstr = TheAsciz(string_to_asciz(arg,encoding));
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processSIZE(lpsize,arg0);
  begin_system_call();
  bool0 = GetTextExtentPointA(hdc,lpcstr,int0,lpsize);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETTEXTEXTENTPOINTW, hdc lpcwstr int0 lpsize)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  LPCWSTR lpcwstr;
  int int0;
  SIZE* lpsize = alloca(sizeof(SIZE));
  object arg0;
  arg0 = popSTACK();
  processSIZE(lpsize,arg0);
  arg = popSTACK();
  check_sint(arg);
  int0 = I_to_sint32(arg);
  arg = popSTACK();
  if(!stringp(arg))argumentum_inritum(arg);
  lpcwstr = WIDECHAR(arg,encoding);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processSIZE(lpsize,arg0);
  begin_system_call();
  bool0 = GetTextExtentPointW(hdc,lpcwstr,int0,lpsize);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETTEXTFACEA, hdc int0 lpstr)
{
  object arg;
  int int1;
  HDC hdc;
  int int0;
  LPSTR lpstr;
  arg = popSTACK();
  if(!stringp(arg))argumentum_inritum(arg);
  lpstr = TheAsciz(string_to_asciz(arg,encoding));
  arg = popSTACK();
  check_sint(arg);
  int0 = I_to_sint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  int1 = GetTextFaceA(hdc,int0,lpstr);
  end_system_call();
  if(0 <=int1){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(int1);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETTEXTFACEW, hdc int0 lpwstr)
{
  object arg;
  int int1;
  HDC hdc;
  int int0;
  LPWSTR lpwstr;
  arg = popSTACK();
  if(!stringp(arg))argumentum_inritum(arg);
  lpwstr = WIDECHAR(arg,encoding);
  arg = popSTACK();
  check_sint(arg);
  int0 = I_to_sint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  int1 = GetTextFaceW(hdc,int0,lpwstr);
  end_system_call();
  if(0 <=int1){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(int1);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETTEXTMETRICSA, hdc lptextmetrica)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  TEXTMETRICA lptextmetrica;
  object arg0 = popSTACK();
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  bool0 = GetTextMetricsA(hdc,&lptextmetrica);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    outputTEXTMETRICA(&lptextmetrica,arg0);
    value2 = arg0;
    value1 = T;
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETTEXTMETRICSW, hdc lptextmetricw)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  TEXTMETRICW* lptextmetricw = alloca(sizeof(TEXTMETRICW));
  object arg0;
  arg0 = popSTACK();
  processTEXTMETRICW(lptextmetricw,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processTEXTMETRICW(lptextmetricw,arg0);
  begin_system_call();
  bool0 = GetTextMetricsW(hdc,lptextmetricw);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETVIEWPORTEXTEX, hdc lpsize)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  SIZE* lpsize = alloca(sizeof(SIZE));
  object arg0;
  arg0 = popSTACK();
  processSIZE(lpsize,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processSIZE(lpsize,arg0);
  begin_system_call();
  bool0 = GetViewportExtEx(hdc,lpsize);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETVIEWPORTORGEX, hdc lppoint)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  POINT* lppoint = alloca(sizeof(POINT));
  object arg0;
  arg0 = popSTACK();
  processPOINT(lppoint,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processPOINT(lppoint,arg0);
  begin_system_call();
  bool0 = GetViewportOrgEx(hdc,lppoint);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETWINMETAFILEBITS, henhmetafile uint lpbyte int0 hdc)
{
  object arg;
  UINT uint0;
  HENHMETAFILE henhmetafile;
  UINT uint;
  BYTE* lpbyte = alloca(sizeof(BYTE));
  object arg0;
  INT int0;
  HDC hdc;
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  arg = popSTACK();
  check_sint(arg);
  int0 = I_to_sint32(arg);
  arg0 = popSTACK();
  processBYTE(lpbyte,arg0);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  henhmetafile = TheFpointer(arg)->fp_pointer;
  processBYTE(lpbyte,arg0);
  begin_system_call();
  uint0 = GetWinMetaFileBits(henhmetafile,uint,lpbyte,int0,hdc);
  end_system_call();
  if(0 <=uint0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = uint32_to_I(uint0);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETWINDOWEXTEX, hdc lpsize)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  SIZE* lpsize = alloca(sizeof(SIZE));
  object arg0;
  arg0 = popSTACK();
  processSIZE(lpsize,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processSIZE(lpsize,arg0);
  begin_system_call();
  bool0 = GetWindowExtEx(hdc,lpsize);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETWINDOWORGEX, hdc lppoint)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  POINT* lppoint = alloca(sizeof(POINT));
  object arg0;
  arg0 = popSTACK();
  processPOINT(lppoint,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processPOINT(lppoint,arg0);
  begin_system_call();
  bool0 = GetWindowOrgEx(hdc,lppoint);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETWORLDTRANSFORM, hdc lpxform)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  XFORM* lpxform = alloca(sizeof(XFORM));
  object arg0;
  arg0 = popSTACK();
  processXFORM(lpxform,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  processXFORM(lpxform,arg0);
  begin_system_call();
  bool0 = GetWorldTransform(hdc,lpxform);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:ESCAPE, hdc int0 int1 lpcstr pvoid)
{
  object arg;
  int int2;
  HDC hdc;
  int int0;
  int int1;
  LPCSTR lpcstr;
  void* pvoid;
  arg = popSTACK();
  if(!simple_bit_vector_p(Atype_8Bit,arg))argumentum_inritum(arg);
  pvoid = &(TheSbvector(arg)->data);
  arg = popSTACK();
  if(!stringp(arg))argumentum_inritum(arg);
  lpcstr = TheAsciz(string_to_asciz(arg,encoding));
  arg = popSTACK();
  check_sint(arg);
  int1 = I_to_sint32(arg);
  arg = popSTACK();
  check_sint(arg);
  int0 = I_to_sint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  int2 = Escape(hdc,int0,int1,lpcstr,pvoid);
  end_system_call();
  if(0 <=int2){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(int2);
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
/*
DEFUN( GDI:SETABORTPROC, hdc abortproc)
{
  object arg;
  int int0;
  HDC hdc;
  ABORTPROC abortproc;
  arg0 = popSTACK();
  processABORTPROC(abortproc,arg0);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  int0 = SetAbortProc(hdc,abortproc);
  end_system_call();
  if(0 <=int0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    value2 = sint32_to_I(int0);
    mv_count=2;
  }
  return;
}
*/
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETCHARWIDTHFLOATA, hdc uint uint0)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  UINT uint;
  UINT uint0;
  UINT length;
  FLOAT* pfloat;
  arg = popSTACK();
  check_uint(arg);
  uint0 = I_to_uint32(arg);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  length = uint0 - uint + 1;
  pfloat = alloca(sizeof(FLOAT)*length);
  begin_system_call();
  bool0 = GetCharWidthFloatA(hdc,uint,uint0,pfloat);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value2 = outputFLOATS(pfloat,length);
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETCHARWIDTHFLOATW, hdc uint uint0 pfloat)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  UINT uint;
  UINT uint0;
  FLOAT* pfloat;
  arg = popSTACK();
  check_uint(arg);
  uint0 = I_to_uint32(arg);
  arg = popSTACK();
  check_uint(arg);
  uint = I_to_uint32(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  pfloat = alloca(sizeof(FLOAT)*(uint0 - uint + 1));
  begin_system_call();
  bool0 = GetCharWidthFloatW(hdc,uint,uint0,pfloat);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value2 = outputFLOATS(pfloat,0);
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:GETMITERLIMIT, hdc pfloat)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  FLOAT pfloat;
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  bool0 = GetMiterLimit(hdc,&pfloat);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value2 = allocate_ffloat(pfloat);
    value1 = T;
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:SETMITERLIMIT, hdc float0)
{
  object arg;
  BOOL bool0;
  HDC hdc;
  FLOAT float0;
  FLOAT pfloat;
  arg = popSTACK();
  check_ffloat(arg);
  float0 = ffloat_value(arg);
  arg = popSTACK();
  if(!fpointerp(arg))argumentum_inritum(arg);
  hdc = TheFpointer(arg)->fp_pointer;
  begin_system_call();
  bool0 = SetMiterLimit(hdc,float0,&pfloat);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value2 = allocate_ffloat(pfloat);
    value1 = T;
    mv_count=2;
  }
  return;
}
// untested - was never called
// uninspected - compiles but code was not checked
DEFUN( GDI:LINEDDA, lppoint lppoint0 lineddaproc lparam)
{
  object arg;
  BOOL bool0;
  POINT lppoint;
  POINT lppoint0;
  LINEDDAPROC lineddaproc;
  void* lparam;
  arg = popSTACK();
  check_sint(arg);
  lparam = I_to_sint32(arg);
  arg = popSTACK();
  processLINEDDAPROC(lineddaproc,arg);
  arg = popSTACK();
  processPOINT(&lppoint0,arg);
  arg = popSTACK();
  processPOINT(&lppoint,arg);
  begin_system_call();
  bool0 = LineDDA(lppoint.x,lppoint.y,lppoint0.x,lppoint0.y,lineddaproc,lparam);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
// untested - was never called
// Not implemented in Windows NT
/*
DEFUN( GDI:TRANSLATECHARSETINFO, dword_p lpcharsetinfo dword)
{
  object arg;
  BOOL bool0;
  DWORD* dword_p;
  HARSETINFO* lpcharsetinfo = alloca(sizeof(CHARSETINFO));
  object arg0;
  DWORD dword;
  arg = popSTACK();
  check_uint(arg);
  dword = I_to_uint32(arg);
  arg0 = popSTACK();
  processCHARSETINFO(lpcharsetinfo,arg0);
  arg = popSTACK();
  if(!simple_bit_vector_p(Atype_32Bit,arg))argumentum_inritum(arg);
  dword_p = &(TheSbvector(arg)->data);
  processHARSETINFO(lpcharsetinfo,arg0);
  begin_system_call();
  bool0 = TranslateCharsetInfo(dword_p,lpcharsetinfo,dword);
  end_system_call();
  if(!bool0){
    DWORD e;
    begin_system_call();
    e = GetLastError();
    end_system_call();
    value1 = NIL;
    value2 = uint32_to_I(e);
    mv_count=2;
  }
  else
  {
    value1 = T;
    mv_count=1;
  }
  return;
}
*/
