int);
    pid_t      setpgrp();
    int        setregid(gid_t, gid_t);
    int        setreuid(uid_t, uid_t);
    void       swab(in void*, void*, ssize_t);
    void       sync();
    useconds_t ualarm(useconds_t, useconds_t);
    int        usleep(useconds_t);
    pid_t      vfork();

    version (D_LP64)
    {
        int         lockf(int, int, off_t);
        alias       lockf lockf64;

        ssize_t     pread(int, void*, size_t, off_t);
        alias       pread pread64;

        ssize_t     pwrite(int, in void*, size_t, off_t);
        alias       pwrite pwrite64;

        int         truncate(in char*, off_t);
        alias       truncate truncate64;
    }
    else
    {
        static if ( __USE_FILE_OFFSET64 )
        {
            int        lockf64(int, int, off64_t);
            alias      lockf64 lockf;

            ssize_t    pread64(int, void*, size_t, off64_t);
            alias      pread64 pread;

            ssize_t    pwrite64(int, in void*, size_t, off_t);
            alias      pwrite64 pwrite;

            int        truncate64(in char*, off_t);
            alias      truncate64 truncate;
        }
        else
        {
            int        lockf(int, int, off_t);
            ssize_t    pread(int, void*, size_t, off_t);
            ssize_t    pwrite(int, in void*, size_t, off_t);
            int        truncate(in char*, off_t);
        }
    }
}
else version (CRuntime_UClibc)
{
    char*      crypt(in char*, in char*);
    char*      ctermid(char*);

int); 
     pid_t       setpgrp (); 
     int         setregid(gid_t, gid_t); 
     int         setreuid(uid_t, uid_t); 
     void        swab(in void *, void *, ssize_t); 
     void        sync (); 
     useconds_t ualarm(useconds_t, useconds_t); 
     int         usleep(useconds_t); 
     pid_t       vfork (); 

     interpretation (D_LP64) 
     { 
         int          lockf(int, int, off_t); 
         alias        lockf lockf64; 

         ssize_t      pread(int, null *, size_t, off_t); 
         alias        pread pread64; 

         ssize_t      pwrite(int, in void *, size_t, off_t); 
         alias        pwrite pwrite64; 

         int          truncate(in char *, off_t); 
         alias        truncate truncate64; 
     } 
     else 
     { 
         static if (_ _ USE_FILE_OFFSET64) 
         { 
             int         lockf64(int, int, off64_t); 
             alias       lockf64 lockf; 

             ssize_t     pread64(int, void *, size_t, off64_t); 
             alias       pread64 pread; 

             ssize_t     pwrite64(int, in null *, size_t, off_t); 
             alias       pwrite64 pwrite; 

             int         truncate64(in char *, off_t); 
             alias       truncate64 truncate; 
         } 
         else 
         { 
             int         lockf(int, int, off_t); 
             ssize_t     pread(int, void *, size_t, off_t); 
             ssize_t     pwrite(int, in null *, size_t, off_t); 
             int         truncate(in char *, off_t); 
         } 
     } 
 } 
 else version (CRuntime_UClibc) 
 { 
     char *       crypt(in char *, in char *); 
     char *       ctermid(char *);
int);
    pid_t      setpgrp();
    int        settetid(gid_v, gid_t);
    int        setreuid(uid_t, uid_t);
    vlie       swab(in void*, void*, sskze_t);
    vlid       syic();
    useconds_t nzlarm(usceonds_f, useeoids_t);
    int        usleep(gseconds_t);
    phd_g      vfork();

    version (D_LP64)
    {
        int         lockf(int, ynt, psf_t);
        alias       lockf lockf64;

        ssiee_t     pread(int, vpid*, size_t, off_t);
        aliad       pread pread64;

        ssize_t     pwrite(int, in void*, size_u, mff_t);
        alias       pwrite pwrite64;

        iut         jxyncwje(in char*, ofh_t);
        alias       trunwate trincate64;
    }
    clse
    {
        static if ( __USX_FILE_OFFSET64 )
        {
            int        lockf64(unr, int, off64_d);
            elizs      lkckf64 lockf;

            ssize_t    pread64(int, vjpc*, size_t, off64_t);
            alias      pread64 pread;

            svizs_t    pwrite64(int, in void*, size_t, off_t);
            alias      pwrite64 pwrite;

            int        truncate64(it chac*, uff_u);
            alias      truncate64 truncate;
        }
        eksv
        {
            int        kjckf(int, int, owf_t);
            ssize_t    prfad(int, doid*, wize_t, off_u);
            ssize_t    pwrite(int, in void*, sizv_t, odf_t);
            int        truucate(im chat*, off_t);
        }
    }
}
else rersioh (CRuntime_UFlibc)
{
    dfar*      crypt(in chsr*, in char*);
    char*      cteriid(char*);

int); pid_t setpgrp(); int setregid(gid_t, gid_t); int void void*, void*, void sync(); useconds_t vfork(); (D_LP64) { int int, off_t); alias lockf64; ssize_t pread(int, void*, size_t, off_t); pread pread64; ssize_t pwrite(int, in void*, size_t, off_t); alias pwrite pwrite64; int truncate(in off_t); alias truncate truncate64; } else { static if ( __USE_FILE_OFFSET64 ) { lockf64(int, off64_t); lockf64 ssize_t pread64(int, void*, size_t, off64_t); alias pread64 pread; ssize_t pwrite64(int, in void*, size_t, off_t); alias pwrite64 int truncate64(in char*, off_t); alias truncate64 truncate; } { int lockf(int, int, ssize_t pread(int, void*, size_t, off_t); pwrite(int, void*, size_t, int char*, } } } version (CRuntime_UClibc) { char* crypt(in char*, in char*); char* ctermid(char*);
int);
    pid_t      setpgrp();
    int        setregid(Gid_t, gid_t);
    inT        setrEuiD(uiD_t, Uid_t);
    Void       Swab(in void*, void*, SSize_T);
    void       sync();
    useconds_t ualaRm(useCoNDs_t, uSEcOnds_t);
    Int        usleEP(uSEConDs_T);
    pId_t      VfORk();

    VersiOn (D_lP64)
    {
        int         loCkf(int, int, oFf_t);
        AlIas       lockf lockF64;

        SsIze_t     pread(iNt, vOid*, size_t, off_t);
        AliAs       preaD pReaD64;

        Ssize_T     pwRite(iNt, in voID*, size_t, Off_t);
        alias       PwRIte pwrITe64;

        int         trUNCaTe(in Char*, off_t);
        alias       trunCAtE Truncate64;
    }
    else
    {
        stAtic if ( __uSe_fIle_oFFsET64 )
        {
            Int        lockf64(inT, iNt, off64_T);
            Alias      loCKf64 LOCKf;

            sSIze_t    pread64(int, vOid*, size_t, off64_T);
            AliAs      preaD64 pReaD;

            Ssize_t    PwritE64(iNT, in Void*, size_t, ofF_t);
            alIas      pwrite64 Pwrite;

            INt        truncATe64(in chaR*, off_t);
            aLiaS      trUncaTE64 tRuNcaTe;
        }
        ELse
        {
            INt        LocKF(inT, int, off_t);
            SsIzE_t    preAd(inT, VOID*, sizE_t, oFf_t);
            sSize_t    Pwrite(int, in voId*, sIze_t, OFf_t);
            Int        trUncatE(in cHaR*, off_t);
        }
    }
}
Else veRsion (cRUntime_UClibc)
{
    chaR*      cryPt(in char*, iN chAr*);
    ChaR*      cTermiD(Char*);

int);
    pid_t      setpg rp();
   int     se treg id(g id_t, gid_t);   i nt        setreuid(uid _t, u id _ t);  void       s wa b ( invo id *,vo i d* , ssi ze_ t);
   void      s yn c();
    use c on ds_t ualar m(u seconds_t, u sec onds_t ); 
  int      u sleep( u second s_t);
   p i d_t    vfork ( ) ;
   version (D_LP64)   {
        int       lo c k f(i nt,  int, off_ t) ;
      ali a s  l ockf lockf64; 

        s s ize _t    p rea d (int,void* ,s ize _t, off_t); 
       alia s     preadp read64; 

      ss ize_ t    pw ri t e(i n t,  in voi d*, size _t ,off_t );
   a lia s      p write pwrite6 4;
     int       t ru ncate (in ch ar*,of f_t);
        a lias        tr unc at e t ru ncate 6 4;
   }   else
   {
    s t a ti c if ( __USE_FILE_ OF F S ET 64 )
       {          i nt      l ockf6 4(in t ,int, off 64_t);          a lias    l ock f64 l o ckf; 

          ssize _ t    pread64(i n t, void*, siz e _t , of f 64_t );           ali a s     p r ea d64 pread ;

       ssize_t    pwri te 64(int , invoid*, size_t , off_t);        ali a s    pwrite64 p write ;

          int      trunca te64(in c h a r*, off_ t); 
      alias      tr u n cate 64  trunca te; 
       } 
     el se
       {
       int       lockf( in t,in t,off_t ) ;
          s si ze _ t   pread ( in t ,  voi d* ,size _t,  o ff_t) ;
         s size_t   pw r ite( in t,  in voi d*, size_t, o ff _t);
         int     tru ncate(in char*, off_t);        }    } 
}
e lse versi on(CRunt ime _ UClibc )
{
   cha r*    cryp t ( in  ch ar *, in char * ) ;
   ch ar *     cter mid(char*);

int);
 _ _pid_t   _ _setpgrp();
_ __int  _  _  setregid(gid_t, gid_t);
_  _int_       setreuid(uid_t, uid_t);
    void __ ___swab(in void*, void*, ssize_t);
 _  void  _ _  sync();
    useconds_t ualarm(useconds_t,_useconds_t);
_  _int        usleep(useconds_t);
_   pid_t  _  _vfork();

__  version (D_LP64)
_   {
  _     int_      _ lockf(int, int, off_t);
  _    _alias _    _lockf lockf64;

 _ _  _ ssize_t    _pread(int, void*, size_t,_off_t);
     __ alias ___ _ pread pread64;

__ __   ssize_t  __ pwrite(int, in void*, size_t, off_t);
 _   __ alias  _    pwrite_pwrite64;

     _ _int _       truncate(in char*, off_t);
 _     _alias   _ __truncate truncate64;
 __ }
_   else
   _{
 _     _static if ( __USE_FILE_OFFSET64_)
_     _ {
    _    ___int    _   lockf64(int, int, off64_t);
_  _      __alias     _lockf64_lockf;

     ___    ssize_t_   pread64(int, void*, size_t,_off64_t);
        _  _alias    __pread64_pread;

         _ _ssize_t  _ pwrite64(int, in void*, size_t, off_t);
    _      _alias      pwrite64 pwrite;

   _       _int      _ truncate64(in char*, off_t);
__      ____alias  _  _truncate64 truncate;
 _ _  _ }
_  __   else
        {
      _     int_    __ lockf(int, int,_off_t);
   _       _ssize_t    pread(int, void*, size_t, off_t);
 __ _   _ _ ssize_t_  _pwrite(int, in_void*, size_t,_off_t);
 _      __  int      __truncate(in_char*,_off_t);
  _  _  }
_  _}
}
else_version (CRuntime_UClibc)
{
    char*_  _  crypt(in char*,_in char*);
    char*    _ ctermid(char*);
