{-# LANGUAGE CPP #-}
{-# LANGUAGE PatternSynonyms #-}

module Foreign.C.Error.Pattern
  ( pattern EOK
  , pattern E2BIG
  , pattern EACCES
  , pattern EADDRINUSE
  , pattern EADDRNOTAVAIL
  , pattern EADV
  , pattern EAFNOSUPPORT
  , pattern EAGAIN
  , pattern EALREADY
  , pattern EBADF
  , pattern EBADMSG
  , pattern EBADRPC
  , pattern EBUSY
  , pattern ECHILD
  , pattern ECOMM
  , pattern ECONNABORTED
  , pattern ECONNREFUSED
  , pattern ECONNRESET
  , pattern EDEADLK
  , pattern EDESTADDRREQ
  , pattern EDIRTY
  , pattern EDOM
  , pattern EDQUOT
  , pattern EEXIST
  , pattern EFAULT
  , pattern EFBIG
  , pattern EFTYPE
  , pattern EHOSTDOWN
  , pattern EHOSTUNREACH
  , pattern EIDRM
  , pattern EILSEQ
  , pattern EINPROGRESS
  , pattern EINTR
  , pattern EINVAL
  , pattern EIO
  , pattern EISCONN
  , pattern EISDIR
  , pattern ELOOP
  , pattern EMFILE
  , pattern EMLINK
  , pattern EMSGSIZE
  , pattern EMULTIHOP
  , pattern ENAMETOOLONG
  , pattern ENETDOWN
  , pattern ENETRESET
  , pattern ENETUNREACH
  , pattern ENFILE
  , pattern ENOBUFS
  , pattern ENODATA
  , pattern ENODEV
  , pattern ENOENT
  , pattern ENOEXEC
  , pattern ENOLCK
  , pattern ENOLINK
  , pattern ENOMEM
  , pattern ENOMSG
  , pattern ENONET
  , pattern ENOPROTOOPT
  , pattern ENOSPC
  , pattern ENOSR
  , pattern ENOSTR
  , pattern ENOSYS
  , pattern ENOTBLK
  , pattern ENOTCONN
  , pattern ENOTDIR
  , pattern ENOTEMPTY
  , pattern ENOTSOCK
  , pattern ENOTSUP
  , pattern ENOTTY
  , pattern ENXIO
  , pattern EOPNOTSUPP
  , pattern EPERM
  , pattern EPFNOSUPPORT
  , pattern EPIPE
  , pattern EPROCLIM
  , pattern EPROCUNAVAIL
  , pattern EPROGMISMATCH
  , pattern EPROGUNAVAIL
  , pattern EPROTO
  , pattern EPROTONOSUPPORT
  , pattern EPROTOTYPE
  , pattern ERANGE
  , pattern EREMCHG
  , pattern EREMOTE
  , pattern EROFS
  , pattern ERPCMISMATCH
  , pattern ERREMOTE
  , pattern ESHUTDOWN
  , pattern ESOCKTNOSUPPORT
  , pattern ESPIPE
  , pattern ESRCH
  , pattern ESRMNT
  , pattern ESTALE
  , pattern ETIME
  , pattern ETIMEDOUT
  , pattern ETOOMANYREFS
  , pattern ETXTBSY
  , pattern EUSERS
  , pattern EWOULDBLOCK
  , pattern EXDEV

    -- * Non-Linux error code
  , pattern EEOI
  ) where

import Foreign.C.Error (Errno (Errno))

#include "HsBaseConfig.h"

pattern EOK :: Errno
pattern $mEOK :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEOK :: Errno
EOK = Errno 0
pattern E2BIG :: Errno
pattern $mE2BIG :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bE2BIG :: Errno
E2BIG = Errno (CONST_E2BIG)
pattern EACCES :: Errno
pattern $mEACCES :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEACCES :: Errno
EACCES = Errno (CONST_EACCES)
pattern EADDRINUSE :: Errno
pattern $mEADDRINUSE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEADDRINUSE :: Errno
EADDRINUSE = Errno (CONST_EADDRINUSE)
pattern EADDRNOTAVAIL :: Errno
pattern $mEADDRNOTAVAIL :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEADDRNOTAVAIL :: Errno
EADDRNOTAVAIL = Errno (CONST_EADDRNOTAVAIL)
pattern EADV :: Errno
pattern $mEADV :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEADV :: Errno
EADV = Errno (CONST_EADV)
pattern EAFNOSUPPORT :: Errno
pattern $mEAFNOSUPPORT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEAFNOSUPPORT :: Errno
EAFNOSUPPORT = Errno (CONST_EAFNOSUPPORT)
pattern EAGAIN :: Errno
pattern $mEAGAIN :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEAGAIN :: Errno
EAGAIN = Errno (CONST_EAGAIN)
pattern EALREADY :: Errno
pattern $mEALREADY :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEALREADY :: Errno
EALREADY = Errno (CONST_EALREADY)
pattern EBADF :: Errno
pattern $mEBADF :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEBADF :: Errno
EBADF = Errno (CONST_EBADF)
pattern EBADMSG :: Errno
pattern $mEBADMSG :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEBADMSG :: Errno
EBADMSG = Errno (CONST_EBADMSG)
pattern EBADRPC :: Errno
pattern $mEBADRPC :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEBADRPC :: Errno
EBADRPC = Errno (CONST_EBADRPC)
pattern EBUSY :: Errno
pattern $mEBUSY :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEBUSY :: Errno
EBUSY = Errno (CONST_EBUSY)
pattern ECHILD :: Errno
pattern $mECHILD :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bECHILD :: Errno
ECHILD = Errno (CONST_ECHILD)
pattern ECOMM :: Errno
pattern $mECOMM :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bECOMM :: Errno
ECOMM = Errno (CONST_ECOMM)
pattern ECONNABORTED :: Errno
pattern $mECONNABORTED :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bECONNABORTED :: Errno
ECONNABORTED = Errno (CONST_ECONNABORTED)
pattern ECONNREFUSED :: Errno
pattern $mECONNREFUSED :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bECONNREFUSED :: Errno
ECONNREFUSED = Errno (CONST_ECONNREFUSED)
pattern ECONNRESET :: Errno
pattern $mECONNRESET :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bECONNRESET :: Errno
ECONNRESET = Errno (CONST_ECONNRESET)
pattern EDEADLK :: Errno
pattern $mEDEADLK :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEDEADLK :: Errno
EDEADLK = Errno (CONST_EDEADLK)
pattern EDESTADDRREQ :: Errno
pattern $mEDESTADDRREQ :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEDESTADDRREQ :: Errno
EDESTADDRREQ = Errno (CONST_EDESTADDRREQ)
pattern EDIRTY :: Errno
pattern $mEDIRTY :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEDIRTY :: Errno
EDIRTY = Errno (CONST_EDIRTY)
pattern EDOM :: Errno
pattern $mEDOM :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEDOM :: Errno
EDOM = Errno (CONST_EDOM)
pattern EDQUOT :: Errno
pattern $mEDQUOT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEDQUOT :: Errno
EDQUOT = Errno (CONST_EDQUOT)
pattern EEXIST :: Errno
pattern $mEEXIST :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEEXIST :: Errno
EEXIST = Errno (CONST_EEXIST)
pattern EFAULT :: Errno
pattern $mEFAULT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEFAULT :: Errno
EFAULT = Errno (CONST_EFAULT)
pattern EFBIG :: Errno
pattern $mEFBIG :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEFBIG :: Errno
EFBIG = Errno (CONST_EFBIG)
pattern EFTYPE :: Errno
pattern $mEFTYPE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEFTYPE :: Errno
EFTYPE = Errno (CONST_EFTYPE)
pattern EHOSTDOWN :: Errno
pattern $mEHOSTDOWN :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEHOSTDOWN :: Errno
EHOSTDOWN = Errno (CONST_EHOSTDOWN)
pattern EHOSTUNREACH :: Errno
pattern $mEHOSTUNREACH :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEHOSTUNREACH :: Errno
EHOSTUNREACH = Errno (CONST_EHOSTUNREACH)
pattern EIDRM :: Errno
pattern $mEIDRM :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEIDRM :: Errno
EIDRM = Errno (CONST_EIDRM)
pattern EILSEQ :: Errno
pattern $mEILSEQ :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEILSEQ :: Errno
EILSEQ = Errno (CONST_EILSEQ)
pattern EINPROGRESS :: Errno
pattern $mEINPROGRESS :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEINPROGRESS :: Errno
EINPROGRESS = Errno (CONST_EINPROGRESS)
pattern EINTR :: Errno
pattern $mEINTR :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEINTR :: Errno
EINTR = Errno (CONST_EINTR)
pattern EINVAL :: Errno
pattern $mEINVAL :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEINVAL :: Errno
EINVAL = Errno (CONST_EINVAL)
pattern EIO :: Errno
pattern $mEIO :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEIO :: Errno
EIO = Errno (CONST_EIO)
pattern EISCONN :: Errno
pattern $mEISCONN :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEISCONN :: Errno
EISCONN = Errno (CONST_EISCONN)
pattern EISDIR :: Errno
pattern $mEISDIR :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEISDIR :: Errno
EISDIR = Errno (CONST_EISDIR)
pattern ELOOP :: Errno
pattern $mELOOP :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bELOOP :: Errno
ELOOP = Errno (CONST_ELOOP)
pattern EMFILE :: Errno
pattern $mEMFILE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEMFILE :: Errno
EMFILE = Errno (CONST_EMFILE)
pattern EMLINK :: Errno
pattern $mEMLINK :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEMLINK :: Errno
EMLINK = Errno (CONST_EMLINK)
pattern EMSGSIZE :: Errno
pattern $mEMSGSIZE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEMSGSIZE :: Errno
EMSGSIZE = Errno (CONST_EMSGSIZE)
pattern EMULTIHOP :: Errno
pattern $mEMULTIHOP :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEMULTIHOP :: Errno
EMULTIHOP = Errno (CONST_EMULTIHOP)
pattern ENAMETOOLONG :: Errno
pattern $mENAMETOOLONG :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENAMETOOLONG :: Errno
ENAMETOOLONG = Errno (CONST_ENAMETOOLONG)
pattern ENETDOWN :: Errno
pattern $mENETDOWN :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENETDOWN :: Errno
ENETDOWN = Errno (CONST_ENETDOWN)
pattern ENETRESET :: Errno
pattern $mENETRESET :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENETRESET :: Errno
ENETRESET = Errno (CONST_ENETRESET)
pattern ENETUNREACH :: Errno
pattern $mENETUNREACH :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENETUNREACH :: Errno
ENETUNREACH = Errno (CONST_ENETUNREACH)
pattern ENFILE :: Errno
pattern $mENFILE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENFILE :: Errno
ENFILE = Errno (CONST_ENFILE)
pattern ENOBUFS :: Errno
pattern $mENOBUFS :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENOBUFS :: Errno
ENOBUFS = Errno (CONST_ENOBUFS)
pattern ENODATA :: Errno
pattern $mENODATA :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENODATA :: Errno
ENODATA = Errno (CONST_ENODATA)
pattern ENODEV :: Errno
pattern $mENODEV :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENODEV :: Errno
ENODEV = Errno (CONST_ENODEV)
pattern ENOENT :: Errno
pattern $mENOENT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENOENT :: Errno
ENOENT = Errno (CONST_ENOENT)
pattern ENOEXEC :: Errno
pattern $mENOEXEC :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENOEXEC :: Errno
ENOEXEC = Errno (CONST_ENOEXEC)
pattern ENOLCK :: Errno
pattern $mENOLCK :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENOLCK :: Errno
ENOLCK = Errno (CONST_ENOLCK)
pattern ENOLINK :: Errno
pattern $mENOLINK :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENOLINK :: Errno
ENOLINK = Errno (CONST_ENOLINK)
pattern ENOMEM :: Errno
pattern $mENOMEM :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENOMEM :: Errno
ENOMEM = Errno (CONST_ENOMEM)
pattern ENOMSG :: Errno
pattern $mENOMSG :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENOMSG :: Errno
ENOMSG = Errno (CONST_ENOMSG)
pattern ENONET :: Errno
pattern $mENONET :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENONET :: Errno
ENONET = Errno (CONST_ENONET)
pattern ENOPROTOOPT :: Errno
pattern $mENOPROTOOPT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENOPROTOOPT :: Errno
ENOPROTOOPT = Errno (CONST_ENOPROTOOPT)
pattern ENOSPC :: Errno
pattern $mENOSPC :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENOSPC :: Errno
ENOSPC = Errno (CONST_ENOSPC)
pattern ENOSR :: Errno
pattern $mENOSR :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENOSR :: Errno
ENOSR = Errno (CONST_ENOSR)
pattern ENOSTR :: Errno
pattern $mENOSTR :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENOSTR :: Errno
ENOSTR = Errno (CONST_ENOSTR)
pattern ENOSYS :: Errno
pattern $mENOSYS :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENOSYS :: Errno
ENOSYS = Errno (CONST_ENOSYS)
pattern ENOTBLK :: Errno
pattern $mENOTBLK :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENOTBLK :: Errno
ENOTBLK = Errno (CONST_ENOTBLK)
pattern ENOTCONN :: Errno
pattern $mENOTCONN :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENOTCONN :: Errno
ENOTCONN = Errno (CONST_ENOTCONN)
pattern ENOTDIR :: Errno
pattern $mENOTDIR :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENOTDIR :: Errno
ENOTDIR = Errno (CONST_ENOTDIR)
pattern ENOTEMPTY :: Errno
pattern $mENOTEMPTY :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENOTEMPTY :: Errno
ENOTEMPTY = Errno (CONST_ENOTEMPTY)
pattern ENOTSOCK :: Errno
pattern $mENOTSOCK :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENOTSOCK :: Errno
ENOTSOCK = Errno (CONST_ENOTSOCK)
pattern ENOTSUP :: Errno
pattern $mENOTSUP :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENOTSUP :: Errno
ENOTSUP = Errno (CONST_ENOTSUP)
pattern ENOTTY :: Errno
pattern $mENOTTY :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENOTTY :: Errno
ENOTTY = Errno (CONST_ENOTTY)
pattern ENXIO :: Errno
pattern $mENXIO :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bENXIO :: Errno
ENXIO = Errno (CONST_ENXIO)
pattern EOPNOTSUPP :: Errno
pattern $mEOPNOTSUPP :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEOPNOTSUPP :: Errno
EOPNOTSUPP = Errno (CONST_EOPNOTSUPP)
pattern EPERM :: Errno
pattern $mEPERM :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEPERM :: Errno
EPERM = Errno (CONST_EPERM)
pattern EPFNOSUPPORT :: Errno
pattern $mEPFNOSUPPORT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEPFNOSUPPORT :: Errno
EPFNOSUPPORT = Errno (CONST_EPFNOSUPPORT)
pattern EPIPE :: Errno
pattern $mEPIPE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEPIPE :: Errno
EPIPE = Errno (CONST_EPIPE)
pattern EPROCLIM :: Errno
pattern $mEPROCLIM :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEPROCLIM :: Errno
EPROCLIM = Errno (CONST_EPROCLIM)
pattern EPROCUNAVAIL :: Errno
pattern $mEPROCUNAVAIL :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEPROCUNAVAIL :: Errno
EPROCUNAVAIL = Errno (CONST_EPROCUNAVAIL)
pattern EPROGMISMATCH :: Errno
pattern $mEPROGMISMATCH :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEPROGMISMATCH :: Errno
EPROGMISMATCH = Errno (CONST_EPROGMISMATCH)
pattern EPROGUNAVAIL :: Errno
pattern $mEPROGUNAVAIL :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEPROGUNAVAIL :: Errno
EPROGUNAVAIL = Errno (CONST_EPROGUNAVAIL)
pattern EPROTO :: Errno
pattern $mEPROTO :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEPROTO :: Errno
EPROTO = Errno (CONST_EPROTO)
pattern EPROTONOSUPPORT :: Errno
pattern $mEPROTONOSUPPORT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEPROTONOSUPPORT :: Errno
EPROTONOSUPPORT = Errno (CONST_EPROTONOSUPPORT)
pattern EPROTOTYPE :: Errno
pattern $mEPROTOTYPE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEPROTOTYPE :: Errno
EPROTOTYPE = Errno (CONST_EPROTOTYPE)
pattern ERANGE :: Errno
pattern $mERANGE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bERANGE :: Errno
ERANGE = Errno (CONST_ERANGE)
pattern EREMCHG :: Errno
pattern $mEREMCHG :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEREMCHG :: Errno
EREMCHG = Errno (CONST_EREMCHG)
pattern EREMOTE :: Errno
pattern $mEREMOTE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEREMOTE :: Errno
EREMOTE = Errno (CONST_EREMOTE)
pattern EROFS :: Errno
pattern $mEROFS :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEROFS :: Errno
EROFS = Errno (CONST_EROFS)
pattern ERPCMISMATCH :: Errno
pattern $mERPCMISMATCH :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bERPCMISMATCH :: Errno
ERPCMISMATCH = Errno (CONST_ERPCMISMATCH)
pattern ERREMOTE :: Errno
pattern $mERREMOTE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bERREMOTE :: Errno
ERREMOTE = Errno (CONST_ERREMOTE)
pattern ESHUTDOWN :: Errno
pattern $mESHUTDOWN :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bESHUTDOWN :: Errno
ESHUTDOWN = Errno (CONST_ESHUTDOWN)
pattern ESOCKTNOSUPPORT :: Errno
pattern $mESOCKTNOSUPPORT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bESOCKTNOSUPPORT :: Errno
ESOCKTNOSUPPORT = Errno (CONST_ESOCKTNOSUPPORT)
pattern ESPIPE :: Errno
pattern $mESPIPE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bESPIPE :: Errno
ESPIPE = Errno (CONST_ESPIPE)
pattern ESRCH :: Errno
pattern $mESRCH :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bESRCH :: Errno
ESRCH = Errno (CONST_ESRCH)
pattern ESRMNT :: Errno
pattern $mESRMNT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bESRMNT :: Errno
ESRMNT = Errno (CONST_ESRMNT)
pattern ESTALE :: Errno
pattern $mESTALE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bESTALE :: Errno
ESTALE = Errno (CONST_ESTALE)
pattern ETIME :: Errno
pattern $mETIME :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bETIME :: Errno
ETIME = Errno (CONST_ETIME)
pattern ETIMEDOUT :: Errno
pattern $mETIMEDOUT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bETIMEDOUT :: Errno
ETIMEDOUT = Errno (CONST_ETIMEDOUT)
pattern ETOOMANYREFS :: Errno
pattern $mETOOMANYREFS :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bETOOMANYREFS :: Errno
ETOOMANYREFS = Errno (CONST_ETOOMANYREFS)
pattern ETXTBSY :: Errno
pattern $mETXTBSY :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bETXTBSY :: Errno
ETXTBSY = Errno (CONST_ETXTBSY)
pattern EUSERS :: Errno
pattern $mEUSERS :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEUSERS :: Errno
EUSERS = Errno (CONST_EUSERS)
pattern EWOULDBLOCK :: Errno
pattern $mEWOULDBLOCK :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEWOULDBLOCK :: Errno
EWOULDBLOCK = Errno (CONST_EWOULDBLOCK)
pattern EXDEV :: Errno
pattern $mEXDEV :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEXDEV :: Errno
EXDEV = Errno (CONST_EXDEV)

-- Non-Linux error code
pattern EEOI :: Errno
pattern $mEEOI :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
$bEEOI :: Errno
EEOI = Errno 254