//! PSP C type definitions
//!
//! These type declarations are not enough, as they must be ultimately resolved
//! by the linker. Crates that use these definitions must, somewhere in the
//! crate graph, include a stub provider crate such as the `psp` crate.

pub type c_schar = i8;
pub type c_uchar = u8;
pub type c_short = i16;
pub type c_ushort = u16;
pub type c_int = i32;
pub type c_uint = u32;
pub type c_float = f32;
pub type c_double = f64;
pub type c_longlong = i64;
pub type c_ulonglong = u64;
pub type intmax_t = i64;
pub type uintmax_t = u64;

pub type size_t = usize;
pub type ptrdiff_t = isize;
pub type intptr_t = isize;
pub type uintptr_t = usize;
pub type ssize_t = isize;

pub type c_char = u8;
pub type c_long = i64;
pub type c_ulong = u64;

cfg_if! {
    if #[cfg(libc_core_cvoid)] {
        pub use ::ffi::c_void;
    } else {
        // Use repr(u8) as LLVM expects `void*` to be the same as `i8*` to help
        // enable more optimization opportunities around it recognizing things
        // like malloc/free.
        #[repr(u8)]
        #[allow(missing_copy_implementations)]
        #[allow(missing_debug_implementations)]
        pub enum c_void {
            // Two dummy variants so the #[repr] attribute can be used.
            #[doc(hidden)]
            __variant1,
            #[doc(hidden)]
            __variant2,
        }
    }
}

pub type SceKernelVTimerHandler = unsafe extern "C" fn(
    uid: SceUid,
    arg1: *mut SceKernelSysClock,
    arg2: *mut SceKernelSysClock,
    arg3: *mut c_void,
) -> u32;

pub type SceKernelVTimerHandlerWide = unsafe extern "C" fn(
    uid: SceUid,
    arg1: i64,
    arg2: i64,
    arg3: *mut c_void,
) -> u32;

pub type SceKernelThreadEventHandler =
    unsafe extern "C" fn(mask: i32, thid: SceUid, common: *mut c_void) -> i32;

pub type SceKernelAlarmHandler =
    unsafe extern "C" fn(common: *mut c_void) -> u32;

pub type SceKernelCallbackFunction =
    unsafe extern "C" fn(arg1: i32, arg2: i32, arg: *mut c_void) -> i32;

pub type SceKernelThreadEntry =
    unsafe extern "C" fn(args: usize, argp: *mut c_void) -> i32;

pub type PowerCallback = extern "C" fn(unknown: i32, power_info: i32);

pub type IoPermissions = i32;

pub type UmdCallback = fn(unknown: i32, event: i32) -> i32;

pub type SceMpegRingbufferCb = Option<
    unsafe extern "C" fn(
        data: *mut c_void,
        num_packets: i32,
        param: *mut c_void,
    ) -> i32,
>;

pub type GuCallback = Option<extern "C" fn(id: i32, arg: *mut c_void)>;
pub type GuSwapBuffersCallback =
    Option<extern "C" fn(display: *mut *mut c_void, render: *mut *mut c_void)>;

pub type SceNetAdhocctlHandler =
    Option<unsafe extern "C" fn(flag: i32, error: i32, unknown: *mut c_void)>;

pub type AdhocMatchingCallback = Option<
    unsafe extern "C" fn(
        matching_id: i32,
        event: i32,
        mac: *mut u8,
        opt_len: i32,
        opt_data: *mut c_void,
    ),
>;

pub type SceNetApctlHandler = Option<
    unsafe extern "C" fn(
        oldState: i32,
        newState: i32,
        event: i32,
        error: i32,
        pArg: *mut c_void,
    ),
>;

pub type HttpMallocFunction =
    Option<unsafe extern "C" fn(size: usize) -> *mut c_void>;
pub type HttpReallocFunction =
    Option<unsafe extern "C" fn(p: *mut c_void, size: usize) -> *mut c_void>;
pub type HttpFreeFunction = Option<unsafe extern "C" fn(p: *mut c_void)>;
pub type HttpPasswordCB = Option<
    unsafe extern "C" fn(
        request: i32,
        auth_type: HttpAuthType,
        realm: *const u8,
        username: *mut u8,
        password: *mut u8,
        need_entity: i32,
        entity_body: *mut *mut u8,
        entity_size: *mut usize,
        save: *mut i32,
    ) -> i32,
>;

pub type socklen_t = u32;

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum AudioFormat {
    Stereo = 0,
    Mono = 0x10,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum DisplayMode {
    Lcd = 0,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum DisplayPixelFormat {
    Psm5650 = 0,
    Psm5551 = 1,
    Psm4444 = 2,
    Psm8888 = 3,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum DisplaySetBufSync {
    Immediate = 0,
    NextFrame = 1,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(i32)]
pub enum AudioOutputFrequency {
    Khz48 = 48000,
    Khz44_1 = 44100,
    Khz32 = 32000,
    Khz24 = 24000,
    Khz22_05 = 22050,
    Khz16 = 16000,
    Khz12 = 12000,
    Khz11_025 = 11025,
    Khz8 = 8000,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(i32)]
pub enum AudioInputFrequency {
    Khz44_1 = 44100,
    Khz22_05 = 22050,
    Khz11_025 = 11025,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum CtrlMode {
    Digital = 0,
    Analog,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(i32)]
pub enum GeMatrixType {
    Bone0 = 0,
    Bone1,
    Bone2,
    Bone3,
    Bone4,
    Bone5,
    Bone6,
    Bone7,
    World,
    View,
    Projection,
    TexGen,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(i32)]
pub enum GeListState {
    Done = 0,
    Queued,
    DrawingDone,
    StallReached,
    CancelDone,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[repr(u8)]
#[derive(Copy, Clone)]
pub enum GeCommand {
    Nop = 0,
    Vaddr = 0x1,
    Iaddr = 0x2,
    Prim = 0x4,
    Bezier = 0x5,
    Spline = 0x6,
    BoundingBox = 0x7,
    Jump = 0x8,
    BJump = 0x9,
    Call = 0xa,
    Ret = 0xb,
    End = 0xc,
    Signal = 0xe,
    Finish = 0xf,
    Base = 0x10,
    VertexType = 0x12,
    OffsetAddr = 0x13,
    Origin = 0x14,
    Region1 = 0x15,
    Region2 = 0x16,
    LightingEnable = 0x17,
    LightEnable0 = 0x18,
    LightEnable1 = 0x19,
    LightEnable2 = 0x1a,
    LightEnable3 = 0x1b,
    DepthClampEnable = 0x1c,
    CullFaceEnable = 0x1d,
    TextureMapEnable = 0x1e,
    FogEnable = 0x1f,
    DitherEnable = 0x20,
    AlphaBlendEnable = 0x21,
    AlphaTestEnable = 0x22,
    ZTestEnable = 0x23,
    StencilTestEnable = 0x24,
    AntiAliasEnable = 0x25,
    PatchCullEnable = 0x26,
    ColorTestEnable = 0x27,
    LogicOpEnable = 0x28,
    BoneMatrixNumber = 0x2a,
    BoneMatrixData = 0x2b,
    MorphWeight0 = 0x2c,
    MorphWeight1 = 0x2d,
    MorphWeight2 = 0x2e,
    MorphWeight3 = 0x2f,
    MorphWeight4 = 0x30,
    MorphWeight5 = 0x31,
    MorphWeight6 = 0x32,
    MorphWeight7 = 0x33,
    PatchDivision = 0x36,
    PatchPrimitive = 0x37,
    PatchFacing = 0x38,
    WorldMatrixNumber = 0x3a,
    WorldMatrixData = 0x3b,
    ViewMatrixNumber = 0x3c,
    ViewMatrixData = 0x3d,
    ProjMatrixNumber = 0x3e,
    ProjMatrixData = 0x3f,
    TGenMatrixNumber = 0x40,
    TGenMatrixData = 0x41,
    ViewportXScale = 0x42,
    ViewportYScale = 0x43,
    ViewportZScale = 0x44,
    ViewportXCenter = 0x45,
    ViewportYCenter = 0x46,
    ViewportZCenter = 0x47,
    TexScaleU = 0x48,
    TexScaleV = 0x49,
    TexOffsetU = 0x4a,
    TexOffsetV = 0x4b,
    OffsetX = 0x4c,
    OffsetY = 0x4d,
    ShadeMode = 0x50,
    ReverseNormal = 0x51,
    MaterialUpdate = 0x53,
    MaterialEmissive = 0x54,
    MaterialAmbient = 0x55,
    MaterialDiffuse = 0x56,
    MaterialSpecular = 0x57,
    MaterialAlpha = 0x58,
    MaterialSpecularCoef = 0x5b,
    AmbientColor = 0x5c,
    AmbientAlpha = 0x5d,
    LightMode = 0x5e,
    LightType0 = 0x5f,
    LightType1 = 0x60,
    LightType2 = 0x61,
    LightType3 = 0x62,
    Light0X = 0x63,
    Light0Y,
    Light0Z,
    Light1X,
    Light1Y,
    Light1Z,
    Light2X,
    Light2Y,
    Light2Z,
    Light3X,
    Light3Y,
    Light3Z,
    Light0DirectionX = 0x6f,
    Light0DirectionY,
    Light0DirectionZ,
    Light1DirectionX,
    Light1DirectionY,
    Light1DirectionZ,
    Light2DirectionX,
    Light2DirectionY,
    Light2DirectionZ,
    Light3DirectionX,
    Light3DirectionY,
    Light3DirectionZ,
    Light0ConstantAtten = 0x7b,
    Light0LinearAtten,
    Light0QuadtraticAtten,
    Light1ConstantAtten,
    Light1LinearAtten,
    Light1QuadtraticAtten,
    Light2ConstantAtten,
    Light2LinearAtten,
    Light2QuadtraticAtten,
    Light3ConstantAtten,
    Light3LinearAtten,
    Light3QuadtraticAtten,
    Light0ExponentAtten = 0x87,
    Light1ExponentAtten,
    Light2ExponentAtten,
    Light3ExponentAtten,
    Light0CutoffAtten = 0x8b,
    Light1CutoffAtten,
    Light2CutoffAtten,
    Light3CutoffAtten,
    Light0Ambient = 0x8f,
    Light0Diffuse,
    Light0Specular,
    Light1Ambient,
    Light1Diffuse,
    Light1Specular,
    Light2Ambient,
    Light2Diffuse,
    Light2Specular,
    Light3Ambient,
    Light3Diffuse,
    Light3Specular,
    Cull = 0x9b,
    FrameBufPtr = 0x9c,
    FrameBufWidth = 0x9d,
    ZBufPtr = 0x9e,
    ZBufWidth = 0x9f,
    TexAddr0 = 0xa0,
    TexAddr1,
    TexAddr2,
    TexAddr3,
    TexAddr4,
    TexAddr5,
    TexAddr6,
    TexAddr7,
    TexBufWidth0 = 0xa8,
    TexBufWidth1,
    TexBufWidth2,
    TexBufWidth3,
    TexBufWidth4,
    TexBufWidth5,
    TexBufWidth6,
    TexBufWidth7,
    ClutAddr = 0xb0,
    ClutAddrUpper = 0xb1,
    TransferSrc,
    TransferSrcW,
    TransferDst,
    TransferDstW,
    TexSize0 = 0xb8,
    TexSize1,
    TexSize2,
    TexSize3,
    TexSize4,
    TexSize5,
    TexSize6,
    TexSize7,
    TexMapMode = 0xc0,
    TexShadeLs = 0xc1,
    TexMode = 0xc2,
    TexFormat = 0xc3,
    LoadClut = 0xc4,
    ClutFormat = 0xc5,
    TexFilter = 0xc6,
    TexWrap = 0xc7,
    TexLevel = 0xc8,
    TexFunc = 0xc9,
    TexEnvColor = 0xca,
    TexFlush = 0xcb,
    TexSync = 0xcc,
    Fog1 = 0xcd,
    Fog2 = 0xce,
    FogColor = 0xcf,
    TexLodSlope = 0xd0,
    FramebufPixFormat = 0xd2,
    ClearMode = 0xd3,
    Scissor1 = 0xd4,
    Scissor2 = 0xd5,
    MinZ = 0xd6,
    MaxZ = 0xd7,
    ColorTest = 0xd8,
    ColorRef = 0xd9,
    ColorTestmask = 0xda,
    AlphaTest = 0xdb,
    StencilTest = 0xdc,
    StencilOp = 0xdd,
    ZTest = 0xde,
    BlendMode = 0xdf,
    BlendFixedA = 0xe0,
    BlendFixedB = 0xe1,
    Dith0 = 0xe2,
    Dith1,
    Dith2,
    Dith3,
    LogicOp = 0xe6,
    ZWriteDisable = 0xe7,
    MaskRgb = 0xe8,
    MaskAlpha = 0xe9,
    TransferStart = 0xea,
    TransferSrcPos = 0xeb,
    TransferDstPos = 0xec,
    TransferSize = 0xee,
    Vscx = 0xf0,
    Vscy = 0xf1,
    Vscz = 0xf2,
    Vtcs = 0xf3,
    Vtct = 0xf4,
    Vtcq = 0xf5,
    Vcv = 0xf6,
    Vap = 0xf7,
    Vfc = 0xf8,
    Vscv = 0xf9,

    Unknown03 = 0x03,
    Unknown0D = 0x0d,
    Unknown11 = 0x11,
    Unknown29 = 0x29,
    Unknown34 = 0x34,
    Unknown35 = 0x35,
    Unknown39 = 0x39,
    Unknown4E = 0x4e,
    Unknown4F = 0x4f,
    Unknown52 = 0x52,
    Unknown59 = 0x59,
    Unknown5A = 0x5a,
    UnknownB6 = 0xb6,
    UnknownB7 = 0xb7,
    UnknownD1 = 0xd1,
    UnknownED = 0xed,
    UnknownEF = 0xef,
    UnknownFA = 0xfa,
    UnknownFB = 0xfb,
    UnknownFC = 0xfc,
    UnknownFD = 0xfd,
    UnknownFE = 0xfe,
    NopFF = 0xff,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(i32)]
pub enum SceSysMemPartitionId {
    SceKernelUnknownPartition = 0,
    SceKernelPrimaryKernelPartition = 1,
    SceKernelPrimaryUserPartition = 2,
    SceKernelOtherKernelPartition1 = 3,
    SceKernelOtherKernelPartition2 = 4,
    SceKernelVshellPARTITION = 5,
    SceKernelScUserPartition = 6,
    SceKernelMeUserPartition = 7,
    SceKernelExtendedScKernelPartition = 8,
    SceKernelExtendedSc2KernelPartition = 9,
    SceKernelExtendedMeKernelPartition = 10,
    SceKernelVshellKernelPartition = 11,
    SceKernelExtendedKernelPartition = 12,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(i32)]
pub enum SceSysMemBlockTypes {
    Low = 0,
    High,
    Addr,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum Interrupt {
    Gpio = 4,
    Ata = 5,
    Umd = 6,
    Mscm0 = 7,
    Wlan = 8,
    Audio = 10,
    I2c = 12,
    Sircs = 14,
    Systimer0 = 15,
    Systimer1 = 16,
    Systimer2 = 17,
    Systimer3 = 18,
    Thread0 = 19,
    Nand = 20,
    Dmacplus = 21,
    Dma0 = 22,
    Dma1 = 23,
    Memlmd = 24,
    Ge = 25,
    Vblank = 30,
    Mecodec = 31,
    Hpremote = 36,
    Mscm1 = 60,
    Mscm2 = 61,
    Thread1 = 65,
    Interrupt = 66,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum SubInterrupt {
    Gpio = Interrupt::Gpio as u32,
    Ata = Interrupt::Ata as u32,
    Umd = Interrupt::Umd as u32,
    Dmacplus = Interrupt::Dmacplus as u32,
    Ge = Interrupt::Ge as u32,
    Display = Interrupt::Vblank as u32,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum SceKernelIdListType {
    Thread = 1,
    Semaphore = 2,
    EventFlag = 3,
    Mbox = 4,
    Vpl = 5,
    Fpl = 6,
    Mpipe = 7,
    Callback = 8,
    ThreadEventHandler = 9,
    Alarm = 10,
    VTimer = 11,
    SleepThread = 64,
    DelayThread = 65,
    SuspendThread = 66,
    DormantThread = 67,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(i32)]
pub enum UsbCamResolution {
    Px160_120 = 0,
    Px176_144 = 1,
    Px320_240 = 2,
    Px352_288 = 3,
    Px640_480 = 4,
    Px1024_768 = 5,
    Px1280_960 = 6,
    Px480_272 = 7,
    Px360_272 = 8,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(i32)]
pub enum UsbCamResolutionEx {
    Px160_120 = 0,
    Px176_144 = 1,
    Px320_240 = 2,
    Px352_288 = 3,
    Px360_272 = 4,
    Px480_272 = 5,
    Px640_480 = 6,
    Px1024_768 = 7,
    Px1280_960 = 8,
}

#[repr(i32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum UsbCamDelay {
    NoDelay = 0,
    Delay10Sec = 1,
    Delay20Sec = 2,
    Delay30Sec = 3,
}

#[repr(i32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum UsbCamFrameRate {
    Fps3_75 = 0,
    Fps5 = 1,
    Fps7_5 = 2,
    Fps10 = 3,
    Fps15 = 4,
    Fps20 = 5,
    Fps30 = 6,
    Fps60 = 7,
}

#[repr(i32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum UsbCamWb {
    Auto = 0,
    Daylight = 1,
    Fluorescent = 2,
    Incadescent = 3,
}

#[repr(i32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum UsbCamEffectMode {
    Normal = 0,
    Negative = 1,
    Blackwhite = 2,
    Sepia = 3,
    Blue = 4,
    Red = 5,
    Green = 6,
}

#[repr(i32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum UsbCamEvLevel {
    Pos2_0 = 0,
    Pos1_7 = 1,
    Pos1_5 = 2,
    Pos1_3 = 3,
    Pos1_0 = 4,
    Pos0_7 = 5,
    Pos0_5 = 6,
    Pos0_3 = 7,
    Zero = 8,
    Neg0_3,
    Neg0_5,
    Neg0_7,
    Neg1_0,
    Neg1_3,
    Neg1_5,
    Neg1_7,
    Neg2_0,
}

#[repr(i32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum RtcCheckValidError {
    InvalidYear = -1,
    InvalidMonth = -2,
    InvalidDay = -3,
    InvalidHour = -4,
    InvalidMinutes = -5,
    InvalidSeconds = -6,
    InvalidMicroseconds = -7,
}

#[derive(Copy, Clone)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[repr(u32)]
pub enum PowerTick {
    All = 0,
    Suspend = 1,
    Display = 6,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum IoAssignPerms {
    RdWr = 0,
    RdOnly = 1,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum IoWhence {
    Set = 0,
    Cur = 1,
    End = 2,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum UmdType {
    Game = 0x10,
    Video = 0x20,
    Audio = 0x40,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum GuPrimitive {
    Points = 0,
    Lines = 1,
    LineStrip = 2,
    Triangles = 3,
    TriangleStrip = 4,
    TriangleFan = 5,
    Sprites = 6,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum PatchPrimitive {
    Points = 0,
    LineStrip = 2,
    TriangleStrip = 4,
}

#[derive(Clone, Copy)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[repr(u32)]
pub enum GuState {
    AlphaTest = 0,
    DepthTest = 1,
    ScissorTest = 2,
    StencilTest = 3,
    Blend = 4,
    CullFace = 5,
    Dither = 6,
    Fog = 7,
    ClipPlanes = 8,
    Texture2D = 9,
    Lighting = 10,
    Light0 = 11,
    Light1 = 12,
    Light2 = 13,
    Light3 = 14,
    LineSmooth = 15,
    PatchCullFace = 16,
    ColorTest = 17,
    ColorLogicOp = 18,
    FaceNormalReverse = 19,
    PatchFace = 20,
    Fragment2X = 21,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum MatrixMode {
    Projection = 0,
    View = 1,
    Model = 2,
    Texture = 3,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum TexturePixelFormat {
    Psm5650 = 0,
    Psm5551 = 1,
    Psm4444 = 2,
    Psm8888 = 3,
    PsmT4 = 4,
    PsmT8 = 5,
    PsmT16 = 6,
    PsmT32 = 7,
    PsmDxt1 = 8,
    PsmDxt3 = 9,
    PsmDxt5 = 10,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum SplineMode {
    FillFill = 0,
    OpenFill = 1,
    FillOpen = 2,
    OpenOpen = 3,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum ShadingModel {
    Flat = 0,
    Smooth = 1,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum LogicalOperation {
    Clear = 0,
    And = 1,
    AndReverse = 2,
    Copy = 3,
    AndInverted = 4,
    Noop = 5,
    Xor = 6,
    Or = 7,
    Nor = 8,
    Equiv = 9,
    Inverted = 10,
    OrReverse = 11,
    CopyInverted = 12,
    OrInverted = 13,
    Nand = 14,
    Set = 15,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum TextureFilter {
    Nearest = 0,
    Linear = 1,
    NearestMipmapNearest = 4,
    LinearMipmapNearest = 5,
    NearestMipmapLinear = 6,
    LinearMipmapLinear = 7,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum TextureMapMode {
    TextureCoords = 0,
    TextureMatrix = 1,
    EnvironmentMap = 2,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum TextureLevelMode {
    Auto = 0,
    Const = 1,
    Slope = 2,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum TextureProjectionMapMode {
    Position = 0,
    Uv = 1,
    NormalizedNormal = 2,
    Normal = 3,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum GuTexWrapMode {
    Repeat = 0,
    Clamp = 1,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum FrontFaceDirection {
    Clockwise = 0,
    CounterClockwise = 1,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum AlphaFunc {
    Never = 0,
    Always,
    Equal,
    NotEqual,
    Less,
    LessOrEqual,
    Greater,
    GreaterOrEqual,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum StencilFunc {
    Never = 0,
    Always,
    Equal,
    NotEqual,
    Less,
    LessOrEqual,
    Greater,
    GreaterOrEqual,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum ColorFunc {
    Never = 0,
    Always,
    Equal,
    NotEqual,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum DepthFunc {
    Never = 0,
    Always,
    Equal,
    NotEqual,
    Less,
    LessOrEqual,
    Greater,
    GreaterOrEqual,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum TextureEffect {
    Modulate = 0,
    Decal = 1,
    Blend = 2,
    Replace = 3,
    Add = 4,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum TextureColorComponent {
    Rgb = 0,
    Rgba = 1,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum MipmapLevel {
    None = 0,
    Level1,
    Level2,
    Level3,
    Level4,
    Level5,
    Level6,
    Level7,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum BlendOp {
    Add = 0,
    Subtract = 1,
    ReverseSubtract = 2,
    Min = 3,
    Max = 4,
    Abs = 5,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum BlendSrc {
    SrcColor = 0,
    OneMinusSrcColor = 1,
    SrcAlpha = 2,
    OneMinusSrcAlpha = 3,
    Fix = 10,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum BlendDst {
    DstColor = 0,
    OneMinusDstColor = 1,
    DstAlpha = 4,
    OneMinusDstAlpha = 5,
    Fix = 10,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum StencilOperation {
    Keep = 0,
    Zero = 1,
    Replace = 2,
    Invert = 3,
    Incr = 4,
    Decr = 5,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum LightMode {
    SingleColor = 0,
    SeparateSpecularColor = 1,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum LightType {
    Directional = 0,
    Pointlight = 1,
    Spotlight = 2,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[repr(u32)]
#[derive(Copy, Clone)]
pub enum GuContextType {
    Direct = 0,
    Call = 1,
    Send = 2,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum GuQueueMode {
    Tail = 0,
    Head = 1,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum GuSyncMode {
    Finish = 0,
    Signal = 1,
    Done = 2,
    List = 3,
    Send = 4,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum GuSyncBehavior {
    Wait = 0,
    NoWait = 1,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum GuCallbackId {
    Signal = 1,
    Finish = 4,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum SignalBehavior {
    Suspend = 1,
    Continue = 2,
}

#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
#[repr(u32)]
pub enum ClutPixelFormat {
    Psm5650 = 0,
    Psm5551 = 1,
    Psm4444 = 2,
    Psm8888 = 3,
}

#[repr(C)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum KeyType {
    Directory = 1,
    Integer = 2,
    String = 3,
    Bytes = 4,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum UtilityMsgDialogMode {
    Error,
    Text,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum UtilityMsgDialogPressed {
    Unknown1,
    Yes,
    No,
    Back,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum UtilityDialogButtonAccept {
    Circle,
    Cross,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum SceUtilityOskInputLanguage {
    Default,
    Japanese,
    English,
    French,
    Spanish,
    German,
    Italian,
    Dutch,
    Portugese,
    Russian,
    Korean,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum SceUtilityOskInputType {
    All,
    LatinDigit,
    LatinSymbol,
    LatinLowercase = 4,
    LatinUppercase = 8,
    JapaneseDigit = 0x100,
    JapaneseSymbol = 0x200,
    JapaneseLowercase = 0x400,
    JapaneseUppercase = 0x800,
    JapaneseHiragana = 0x1000,
    JapaneseHalfWidthKatakana = 0x2000,
    JapaneseKatakana = 0x4000,
    JapaneseKanji = 0x8000,
    RussianLowercase = 0x10000,
    RussianUppercase = 0x20000,
    Korean = 0x40000,
    Url = 0x80000,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum SceUtilityOskState {
    None,
    Initializing,
    Initialized,
    Visible,
    Quit,
    Finished,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum SceUtilityOskResult {
    Unchanged,
    Cancelled,
    Changed,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum SystemParamLanguage {
    Japanese,
    English,
    French,
    Spanish,
    German,
    Italian,
    Dutch,
    Portugese,
    Russian,
    Korean,
    ChineseTraditional,
    ChineseSimplified,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum SystemParamId {
    StringNickname = 1,
    AdhocChannel,
    WlanPowerSave,
    DateFormat,
    TimeFormat,
    Timezone,
    DaylightSavings,
    Language,
    Unknown,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum SystemParamAdhocChannel {
    ChannelAutomatic = 0,
    Channel1 = 1,
    Channel6 = 6,
    Channel11 = 11,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum SystemParamWlanPowerSaveState {
    Off,
    On,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum SystemParamDateFormat {
    YYYYMMDD,
    MMDDYYYY,
    DDMMYYYY,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum SystemParamTimeFormat {
    Hour24,
    Hour12,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum SystemParamDaylightSavings {
    Std,
    Dst,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum AvModule {
    AvCodec,
    SasCore,
    Atrac3Plus,
    MpegBase,
    Mp3,
    Vaudio,
    Aac,
    G729,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum Module {
    NetCommon = 0x100,
    NetAdhoc,
    NetInet,
    NetParseUri,
    NetHttp,
    NetSsl,

    UsbPspCm = 0x200,
    UsbMic,
    UsbCam,
    UsbGps,

    AvCodec = 0x300,
    AvSascore,
    AvAtrac3Plus,
    AvMpegBase,
    AvMp3,
    AvVaudio,
    AvAac,
    AvG729,

    NpCommon = 0x400,
    NpService,
    NpMatching2,
    NpDrm = 0x500,

    Irda = 0x600,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum NetModule {
    NetCommon = 1,
    NetAdhoc,
    NetInet,
    NetParseUri,
    NetHttp,
    NetSsl,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum UsbModule {
    UsbPspCm = 1,
    UsbAcc,
    UsbMic,
    UsbCam,
    UsbGps,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum NetParam {
    Name,
    Ssid,
    Secure,
    WepKey,
    IsStaticIp,
    Ip,
    NetMask,
    Route,
    ManualDns,
    PrimaryDns,
    SecondaryDns,
    ProxyUser,
    ProxyPass,
    UseProxy,
    ProxyServer,
    ProxyPort,
    Unknown1,
    Unknown2,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum UtilityNetconfAction {
    ConnectAP,
    DisplayStatus,
    ConnectAdhoc,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum UtilitySavedataMode {
    AutoLoad,
    AutoSave,
    Load,
    Save,
    ListLoad,
    ListSave,
    ListDelete,
    Delete,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum UtilitySavedataFocus {
    Unknown1,
    FirstList,
    LastList,
    Latest,
    Oldest,
    Unknown2,
    Unknown3,
    FirstEmpty,
    LastEmpty,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum UtilityGameSharingMode {
    Single = 1,
    Multiple,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum UtilityGameSharingDataType {
    File = 1,
    Memory,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum UtilityHtmlViewerInterfaceMode {
    Full,
    Limited,
    None,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum UtilityHtmlViewerCookieMode {
    Disabled = 0,
    Enabled,
    Confirm,
    Default,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum UtilityHtmlViewerTextSize {
    Large,
    Normal,
    Small,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum UtilityHtmlViewerDisplayMode {
    Normal,
    Fit,
    SmartFit,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum UtilityHtmlViewerConnectMode {
    Last,
    ManualOnce,
    ManualAll,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum UtilityHtmlViewerDisconnectMode {
    Enable,
    Disable,
    Confirm,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum ScePspnetAdhocPtpState {
    Closed,
    Listen,
    SynSent,
    SynReceived,
    Established,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum AdhocMatchingMode {
    Host = 1,
    Client,
    Ptp,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum ApctlState {
    Disconnected,
    Scanning,
    Joining,
    GettingIp,
    GotIp,
    EapAuth,
    KeyExchange,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum ApctlEvent {
    ConnectRequest,
    ScanRequest,
    ScanComplete,
    Established,
    GetIp,
    DisconnectRequest,
    Error,
    Info,
    EapAuth,
    KeyExchange,
    Reconnect,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum ApctlInfo {
    ProfileName,
    Bssid,
    Ssid,
    SsidLength,
    SecurityType,
    Strength,
    Channel,
    PowerSave,
    Ip,
    SubnetMask,
    Gateway,
    PrimaryDns,
    SecondaryDns,
    UseProxy,
    ProxyUrl,
    ProxyPort,
    EapType,
    StartBrowser,
    Wifisp,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Clone, Copy)]
pub enum ApctlInfoSecurityType {
    None,
    Wep,
    Wpa,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum HttpMethod {
    Get,
    Post,
    Head,
}

#[repr(u32)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub enum HttpAuthType {
    Basic,
    Digest,
}

#[repr(transparent)]
#[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq, Hash))]
#[derive(Copy, Clone)]
pub struct SceUid(pub i32);

#[repr(transparent)]
#[cfg_attr(feature = "extra_traits", derive(Debug))]
#[derive(Copy, Clone)]
pub struct SceMpeg(*mut *mut c_void);

#[repr(transparent)]
#[cfg_attr(feature = "extra_traits", derive(Debug))]
#[derive(Copy, Clone)]
pub struct SceMpegStream(*mut c_void);

#[repr(transparent)]
#[cfg_attr(feature = "extra_traits", derive(Debug))]
#[derive(Copy, Clone)]
pub struct Mp3Handle(pub i32);

#[repr(transparent)]
#[cfg_attr(feature = "extra_traits", derive(Debug))]
#[derive(Copy, Clone)]
pub struct RegHandle(u32);

#[cfg_attr(feature = "extra_traits", derive(Debug))]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct sockaddr(pub u32);

#[cfg_attr(feature = "extra_traits", derive(Debug))]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct in_addr(pub u32);

s! {
    pub struct AudioInputParams {
        pub unknown1: i32,
        pub gain: i32,
        pub unknown2: i32,
        pub unknown3: i32,
        pub unknown4: i32,
        pub unknown5: i32,
    }

    pub struct Atrac3BufferInfo {
        pub puc_write_position_first_buf: *mut u8,
        pub ui_writable_byte_first_buf: u32,
        pub ui_min_write_byte_first_buf: u32,
        pub ui_read_position_first_buf: u32,
        pub puc_write_position_second_buf: *mut u8,
        pub ui_writable_byte_second_buf: u32,
        pub ui_min_write_byte_second_buf: u32,
        pub ui_read_position_second_buf: u32,
    }

    pub struct SceCtrlData {
        pub timestamp: u32,
        pub buttons: i32,
        pub lx: u8,
        pub ly: u8,
        pub rsrv: [u8; 6],
    }

    pub struct SceCtrlLatch {
        pub ui_make: u32,
        pub ui_break: u32,
        pub ui_press: u32,
        pub ui_release: u32,
    }

    pub struct GeStack {
        pub stack: [u32; 8],
    }

    pub struct GeCallbackData {
        pub signal_func: Option<extern "C" fn(id: i32, arg: *mut c_void)>,
        pub signal_arg: *mut c_void,
        pub finish_func: Option<extern "C" fn(id: i32, arg: *mut c_void)>,
        pub finish_arg: *mut c_void,
    }

    pub struct GeListArgs {
        pub size: u32,
        pub context: *mut GeContext,
        pub num_stacks: u32,
        pub stacks: *mut GeStack,
    }

    pub struct GeBreakParam {
        pub buf: [u32; 4],
    }

    pub struct SceKernelLoadExecParam {
        pub size: usize,
        pub args: usize,
        pub argp: *mut c_void,
        pub key: *const u8,
    }

    pub struct timeval {
        pub tv_sec: i32,
        pub tv_usec: i32,
    }

    pub struct timezone {
        pub tz_minutes_west: i32,
        pub tz_dst_time: i32,
    }

    pub struct IntrHandlerOptionParam {
        size: i32,
        entry: u32,
        common: u32,
        gp: u32,
        intr_code: u16,
        sub_count: u16,
        intr_level: u16,
        enabled: u16,
        calls: u32,
        field_1c: u32,
        total_clock_lo: u32,
        total_clock_hi: u32,
        min_clock_lo: u32,
        min_clock_hi: u32,
        max_clock_lo: u32,
        max_clock_hi: u32,
    }

    pub struct SceKernelLMOption {
        pub size: usize,
        pub m_pid_text: SceUid,
        pub m_pid_data: SceUid,
        pub flags: u32,
        pub position: u8,
        pub access: u8,
        pub c_reserved: [u8; 2usize],
    }

    pub struct SceKernelSMOption {
        pub size: usize,
        pub m_pid_stack: SceUid,
        pub stack_size: usize,
        pub priority: i32,
        pub attribute: u32,
    }

    pub struct SceKernelModuleInfo {
        pub size: usize,
        pub n_segment: u8,
        pub reserved: [u8; 3usize],
        pub segment_addr: [i32; 4usize],
        pub segment_size: [i32; 4usize],
        pub entry_addr: u32,
        pub gp_value: u32,
        pub text_addr: u32,
        pub text_size: u32,
        pub data_size: u32,
        pub bss_size: u32,
        pub attribute: u16,
        pub version: [u8; 2usize],
        pub name: [u8; 28usize],
    }

    pub struct DebugProfilerRegs {
        pub enable: u32,
        pub systemck: u32,
        pub cpuck: u32,
        pub internal: u32,
        pub memory: u32,
        pub copz: u32,
        pub vfpu: u32,
        pub sleep: u32,
        pub bus_access: u32,
        pub uncached_load: u32,
        pub uncached_store: u32,
        pub cached_load: u32,
        pub cached_store: u32,
        pub i_miss: u32,
        pub d_miss: u32,
        pub d_writeback: u32,
        pub cop0_inst: u32,
        pub fpu_inst: u32,
        pub vfpu_inst: u32,
        pub local_bus: u32,
    }

    pub struct SceKernelSysClock {
        pub low: u32,
        pub hi: u32,
    }

    pub struct SceKernelThreadOptParam {
        pub size: usize,
        pub stack_mpid: SceUid,
    }

    pub struct SceKernelThreadInfo {
        pub size: usize,
        pub name: [u8; 32],
        pub attr: u32,
        pub status: i32,
        pub entry: SceKernelThreadEntry,
        pub stack: *mut c_void,
        pub stack_size: i32,
        pub gp_reg: *mut c_void,
        pub init_priority: i32,
        pub current_priority: i32,
        pub wait_type: i32,
        pub wait_id: SceUid,
        pub wakeup_count: i32,
        pub exit_status: i32,
        pub run_clocks: SceKernelSysClock,
        pub intr_preempt_count: u32,
        pub thread_preempt_count: u32,
        pub release_count: u32,
    }

    pub struct SceKernelThreadRunStatus {
        pub size: usize,
        pub status: i32,
        pub current_priority: i32,
        pub wait_type: i32,
        pub wait_id: i32,
        pub wakeup_count: i32,
        pub run_clocks: SceKernelSysClock,
        pub intr_preempt_count: u32,
        pub thread_preempt_count: u32,
        pub release_count: u32,
    }

    pub struct SceKernelSemaOptParam {
        pub size: usize,
    }

    pub struct SceKernelSemaInfo {
        pub size: usize,
        pub name: [u8; 32],
        pub attr: u32,
        pub init_count: i32,
        pub current_count: i32,
        pub max_count: i32,
        pub num_wait_threads: i32,
    }

    pub struct SceKernelEventFlagInfo {
        pub size: usize,
        pub name: [u8; 32],
        pub attr: u32,
        pub init_pattern: u32,
        pub current_pattern: u32,
        pub num_wait_threads: i32,
    }

    pub struct SceKernelEventFlagOptParam {
        pub size: usize,
    }

    pub struct SceKernelMbxOptParam {
        pub size: usize,
    }

    pub struct SceKernelMbxInfo {
        pub size: usize,
        pub name: [u8; 32usize],
        pub attr: u32,
        pub num_wait_threads: i32,
        pub num_messages: i32,
        pub first_message: *mut c_void,
    }

    pub struct SceKernelVTimerInfo {
        pub size: usize,
        pub name: [u8; 32],
        pub active: i32,
        pub base: SceKernelSysClock,
        pub current: SceKernelSysClock,
        pub schedule: SceKernelSysClock,
        pub handler: SceKernelVTimerHandler,
        pub common: *mut c_void,
    }

    pub struct SceKernelThreadEventHandlerInfo {
        pub size: usize,
        pub name: [u8; 32],
        pub thread_id: SceUid,
        pub mask: i32,
        pub handler: SceKernelThreadEventHandler,
        pub common: *mut c_void,
    }

    pub struct SceKernelAlarmInfo {
        pub size: usize,
        pub schedule: SceKernelSysClock,
        pub handler: SceKernelAlarmHandler,
        pub common: *mut c_void,
    }

    pub struct SceKernelSystemStatus {
        pub size: usize,
        pub status: u32,
        pub idle_clocks: SceKernelSysClock,
        pub comes_out_of_idle_count: u32,
        pub thread_switch_count: u32,
        pub vfpu_switch_count: u32,
    }

    pub struct SceKernelMppInfo {
        pub size: usize,
        pub name: [u8; 32],
        pub attr: u32,
        pub buf_size: i32,
        pub free_size: i32,
        pub num_send_wait_threads: i32,
        pub num_receive_wait_threads: i32,
    }

    pub struct SceKernelVplOptParam {
        pub size: usize,
    }

    pub struct SceKernelVplInfo {
        pub size: usize,
        pub name: [u8; 32],
        pub attr: u32,
        pub pool_size: i32,
        pub free_size: i32,
        pub num_wait_threads: i32,
    }

    pub struct SceKernelFplOptParam {
        pub size: usize,
    }

    pub struct SceKernelFplInfo {
        pub size: usize,
        pub name: [u8; 32usize],
        pub attr: u32,
        pub block_size: i32,
        pub num_blocks: i32,
        pub free_blocks: i32,
        pub num_wait_threads: i32,
    }

    pub struct SceKernelVTimerOptParam {
        pub size: usize,
    }

    pub struct SceKernelCallbackInfo {
        pub size: usize,
        pub name: [u8; 32usize],
        pub thread_id: SceUid,
        pub callback: SceKernelCallbackFunction,
        pub common: *mut c_void,
        pub notify_count: i32,
        pub notify_arg: i32,
    }

    pub struct UsbCamSetupStillParam {
        pub size: i32,
        pub resolution: UsbCamResolution,
        pub jpeg_size: i32,
        pub reverse_flags: i32,
        pub delay: UsbCamDelay,
        pub comp_level: i32,
    }

    pub struct UsbCamSetupStillExParam {
        pub size: i32,
        pub unk: u32,
        pub resolution: UsbCamResolutionEx,
        pub jpeg_size: i32,
        pub comp_level: i32,
        pub unk2: u32,
        pub unk3: u32,
        pub flip: i32,
        pub mirror: i32,
        pub delay: UsbCamDelay,
        pub unk4: [u32; 5usize],
    }

    pub struct UsbCamSetupVideoParam {
        pub size: i32,
        pub resolution: UsbCamResolution,
        pub framerate: UsbCamFrameRate,
        pub white_balance: UsbCamWb,
        pub saturation: i32,
        pub brightness: i32,
        pub contrast: i32,
        pub sharpness: i32,
        pub effect_mode: UsbCamEffectMode,
        pub frame_size: i32,
        pub unk: u32,
        pub evl_evel: UsbCamEvLevel,
    }

    pub struct UsbCamSetupVideoExParam {
        pub size: i32,
        pub unk: u32,
        pub resolution: UsbCamResolutionEx,
        pub framerate: UsbCamFrameRate,
        pub unk2: u32,
        pub unk3: u32,
        pub white_balance: UsbCamWb,
        pub saturation: i32,
        pub brightness: i32,
        pub contrast: i32,
        pub sharpness: i32,
        pub unk4: u32,
        pub unk5: u32,
        pub unk6: [u32; 3usize],
        pub effect_mode: UsbCamEffectMode,
        pub unk7: u32,
        pub unk8: u32,
        pub unk9: u32,
        pub unk10: u32,
        pub unk11: u32,
        pub frame_size: i32,
        pub unk12: u32,
        pub ev_level: UsbCamEvLevel,
    }

    pub struct ScePspDateTime {
        pub year: u16,
        pub month: u16,
        pub day: u16,
        pub hour: u16,
        pub minutes: u16,
        pub seconds: u16,
        pub microseconds: u32,
    }

    pub struct SceIoStat {
        pub st_mode: i32,
        pub st_attr: i32,
        pub st_size: i64,
        pub st_ctime: ScePspDateTime,
        pub st_atime: ScePspDateTime,
        pub st_mtime: ScePspDateTime,
        pub st_private: [u32; 6usize],
    }

    pub struct UmdInfo {
        pub size: u32,
        pub type_: UmdType,
    }

    pub struct SceMpegRingbuffer {
        pub packets: i32,
        pub unk0: u32,
        pub unk1: u32,
        pub unk2: u32,
        pub unk3: u32,
        pub data: *mut c_void,
        pub callback: SceMpegRingbufferCb,
        pub cb_param: *mut c_void,
        pub unk4: u32,
        pub unk5: u32,
        pub sce_mpeg: *mut c_void,
    }

    pub struct SceMpegAu {
        pub pts_msb: u32,
        pub pts: u32,
        pub dts_msb: u32,
        pub dts: u32,
        pub es_buffer: u32,
        pub au_size: u32,
    }

    pub struct SceMpegAvcMode {
        pub unk0: i32,
        pub pixel_format: super::DisplayPixelFormat,
    }

    #[repr(align(64))]
    pub struct SceMpegLLI {
        pub src: *mut c_void,
        pub dst: *mut c_void,
        pub next: *mut c_void,
        pub size: i32,
    }

    #[repr(align(64))]
    pub struct SceMpegYCrCbBuffer {
        pub frame_buffer_height16: i32,
        pub frame_buffer_width16: i32,
        pub unknown: i32,
        pub unknown2: i32,
        pub y_buffer: *mut c_void,
        pub y_buffer2: *mut c_void,
        pub cr_buffer: *mut c_void,
        pub cb_buffer: *mut c_void,
        pub cr_buffer2: *mut c_void,
        pub cb_buffer2: *mut c_void,

        pub frame_height: i32,
        pub frame_width: i32,
        pub frame_buffer_width: i32,
        pub unknown3: [i32; 11usize],
    }

    pub struct ScePspSRect {
        pub x: i16,
        pub y: i16,
        pub w: i16,
        pub h: i16,
    }

    pub struct ScePspIRect {
        pub x: i32,
        pub y: i32,
        pub w: i32,
        pub h: i32,
    }

    pub struct ScePspL64Rect {
        pub x: u64,
        pub y: u64,
        pub w: u64,
        pub h: u64,
    }

    pub struct ScePspSVector2 {
        pub x: i16,
        pub y: i16,
    }

    pub struct ScePspIVector2 {
        pub x: i32,
        pub y: i32,
    }

    pub struct ScePspL64Vector2 {
        pub x: u64,
        pub y: u64,
    }

    pub struct ScePspSVector3 {
        pub x: i16,
        pub y: i16,
        pub z: i16,
    }

    pub struct ScePspIVector3 {
        pub x: i32,
        pub y: i32,
        pub z: i32,
    }

    pub struct ScePspL64Vector3 {
        pub x: u64,
        pub y: u64,
        pub z: u64,
    }

    pub struct ScePspSVector4 {
        pub x: i16,
        pub y: i16,
        pub z: i16,
        pub w: i16,
    }

    pub struct ScePspIVector4 {
        pub x: i32,
        pub y: i32,
        pub z: i32,
        pub w: i32,
    }

    pub struct ScePspL64Vector4 {
        pub x: u64,
        pub y: u64,
        pub z: u64,
        pub w: u64,
    }

    pub struct ScePspIMatrix2 {
        pub x: ScePspIVector2,
        pub y: ScePspIVector2,
    }

    pub struct ScePspIMatrix3 {
        pub x: ScePspIVector3,
        pub y: ScePspIVector3,
        pub z: ScePspIVector3,
    }

    #[repr(align(16))]
    pub struct ScePspIMatrix4 {
        pub x: ScePspIVector4,
        pub y: ScePspIVector4,
        pub z: ScePspIVector4,
        pub w: ScePspIVector4,
    }

    pub struct ScePspIMatrix4Unaligned {
        pub x: ScePspIVector4,
        pub y: ScePspIVector4,
        pub z: ScePspIVector4,
        pub w: ScePspIVector4,
    }

    pub struct SceMp3InitArg {
        pub mp3_stream_start: u32,
        pub unk1: u32,
        pub mp3_stream_end: u32,
        pub unk2: u32,
        pub mp3_buf: *mut c_void,
        pub mp3_buf_size: i32,
        pub pcm_buf: *mut c_void,
        pub pcm_buf_size: i32,
    }

    pub struct OpenPSID {
        pub data: [u8; 16usize],
    }

    pub struct UtilityDialogCommon {
        pub size: u32,
        pub language: SystemParamLanguage,
        pub button_accept: UtilityDialogButtonAccept,
        pub graphics_thread: i32,
        pub access_thread: i32,
        pub font_thread: i32,
        pub sound_thread: i32,
        pub result: i32,
        pub reserved: [i32; 4usize],
    }

    pub struct UtilityNetconfAdhoc {
        pub name: [u8; 8usize],
        pub timeout: u32,
    }

    pub struct UtilityNetconfData {
        pub base: UtilityDialogCommon,
        pub action: UtilityNetconfAction,
        pub adhocparam: *mut UtilityNetconfAdhoc,
        pub hotspot: i32,
        pub hotspot_connected: i32,
        pub wifisp: i32,
    }

    pub struct UtilitySavedataFileData {
        pub buf: *mut c_void,
        pub buf_size: usize,
        pub size: usize,
        pub unknown: i32,
    }

    pub struct UtilitySavedataListSaveNewData {
        pub icon0: UtilitySavedataFileData,
        pub title: *mut u8,
    }

    pub struct UtilityGameSharingParams {
        pub base: UtilityDialogCommon,
        pub unknown1: i32,
        pub unknown2: i32,
        pub name: [u8; 8usize],
        pub unknown3: i32,
        pub unknown4: i32,
        pub unknown5: i32,
        pub result: i32,
        pub filepath: *mut u8,
        pub mode: UtilityGameSharingMode,
        pub datatype: UtilityGameSharingDataType,
        pub data: *mut c_void,
        pub datasize: u32,
    }

    pub struct UtilityHtmlViewerParam {
        pub base: UtilityDialogCommon,
        pub memaddr: *mut c_void,
        pub memsize: u32,
        pub unknown1: i32,
        pub unknown2: i32,
        pub initialurl: *mut u8,
        pub numtabs: u32,
        pub interfacemode: UtilityHtmlViewerInterfaceMode,
        pub options: i32,
        pub dldirname: *mut u8,
        pub dlfilename: *mut u8,
        pub uldirname: *mut u8,
        pub ulfilename: *mut u8,
        pub cookiemode: UtilityHtmlViewerCookieMode,
        pub unknown3: u32,
        pub homeurl: *mut u8,
        pub textsize: UtilityHtmlViewerTextSize,
        pub displaymode: UtilityHtmlViewerDisplayMode,
        pub connectmode: UtilityHtmlViewerConnectMode,
        pub disconnectmode: UtilityHtmlViewerDisconnectMode,
        pub memused: u32,
        pub unknown4: [i32; 10usize],
    }

    pub struct SceUtilityOskData {
        pub unk_00: i32,
        pub unk_04: i32,
        pub language: SceUtilityOskInputLanguage,
        pub unk_12: i32,
        pub inputtype: SceUtilityOskInputType,
        pub lines: i32,
        pub unk_24: i32,
        pub desc: *mut u16,
        pub intext: *mut u16,
        pub outtextlength: i32,
        pub outtext: *mut u16,
        pub result: SceUtilityOskResult,
        pub outtextlimit: i32,
    }

    pub struct SceUtilityOskParams {
        pub base: UtilityDialogCommon,
        pub datacount: i32,
        pub data: *mut SceUtilityOskData,
        pub state: SceUtilityOskState,
        pub unk_60: i32,
    }

    pub struct SceNetMallocStat {
        pub pool: i32,
        pub maximum: i32,
        pub free: i32,
    }

    pub struct SceNetAdhocctlAdhocId {
        pub unknown: i32,
        pub adhoc_id: [u8; 9usize],
        pub unk: [u8; 3usize],
    }

    pub struct SceNetAdhocctlScanInfo {
        pub next: *mut SceNetAdhocctlScanInfo,
        pub channel: i32,
        pub name: [u8; 8usize],
        pub bssid: [u8; 6usize],
        pub unknown: [u8; 2usize],
        pub unknown2: i32,
    }

    pub struct SceNetAdhocctlGameModeInfo {
        pub count: i32,
        pub macs: [[u8; 6usize]; 16usize],
    }

    pub struct SceNetAdhocPtpStat {
        pub next: *mut SceNetAdhocPtpStat,
        pub ptp_id: i32,
        pub mac: [u8; 6usize],
        pub peermac: [u8; 6usize],
        pub port: u16,
        pub peerport: u16,
        pub sent_data: u32,
        pub rcvd_data: u32,
        pub state: ScePspnetAdhocPtpState,
    }

    pub struct SceNetAdhocPdpStat {
        pub next: *mut SceNetAdhocPdpStat,
        pub pdp_id: i32,
        pub mac: [u8; 6usize],
        pub port: u16,
        pub rcvd_data: u32,
    }

    pub struct AdhocPoolStat {
        pub size: i32,
        pub maxsize: i32,
        pub freesize: i32,
    }
}

s_no_extra_traits! {
    #[allow(missing_debug_implementations)]
    pub struct GeContext {
        pub context: [u32; 512],
    }

    #[allow(missing_debug_implementations)]
    pub struct SceKernelUtilsSha1Context {
        pub h: [u32; 5usize],
        pub us_remains: u16,
        pub us_computed: u16,
        pub ull_total_len: u64,
        pub buf: [u8; 64usize],
    }

    #[allow(missing_debug_implementations)]
    pub struct SceKernelUtilsMt19937Context {
        pub count: u32,
        pub state: [u32; 624usize],
    }

    #[allow(missing_debug_implementations)]
    pub struct SceKernelUtilsMd5Context {
        pub h: [u32; 4usize],
        pub pad: u32,
        pub us_remains: u16,
        pub us_computed: u16,
        pub ull_total_len: u64,
        pub buf: [u8; 64usize],
    }

    #[allow(missing_debug_implementations)]
    pub struct SceIoDirent {
        pub d_stat: SceIoStat,
        pub d_name: [u8; 256usize],
        pub d_private: *mut c_void,
        pub dummy: i32,
    }

    #[cfg_attr(feature = "extra_traits", derive(Debug))]
    pub struct ScePspFRect {
        pub x: f32,
        pub y: f32,
        pub w: f32,
        pub h: f32,
    }

    #[repr(align(16))]
    #[cfg_attr(feature = "extra_traits", derive(Debug))]
    pub struct ScePspFVector3 {
        pub x: f32,
        pub y: f32,
        pub z: f32,
    }

    #[repr(align(16))]
    #[cfg_attr(feature = "extra_traits", derive(Debug))]
    pub struct ScePspFVector4 {
        pub x: f32,
        pub y: f32,
        pub z: f32,
        pub w: f32,
    }

    #[cfg_attr(feature = "extra_traits", derive(Debug))]
    pub struct ScePspFVector4Unaligned {
        pub x: f32,
        pub y: f32,
        pub z: f32,
        pub w: f32,
    }

    #[cfg_attr(feature = "extra_traits", derive(Debug))]
    pub struct ScePspFVector2 {
        pub x: f32,
        pub y: f32,
    }

    #[cfg_attr(feature = "extra_traits", derive(Debug))]
    pub struct ScePspFMatrix2 {
        pub x: ScePspFVector2,
        pub y: ScePspFVector2,
    }

    #[cfg_attr(feature = "extra_traits", derive(Debug))]
    pub struct ScePspFMatrix3 {
        pub x: ScePspFVector3,
        pub y: ScePspFVector3,
        pub z: ScePspFVector3,
    }

    #[cfg_attr(feature = "extra_traits", derive(Debug))]
    #[repr(align(16))]
    pub struct ScePspFMatrix4 {
        pub x: ScePspFVector4,
        pub y: ScePspFVector4,
        pub z: ScePspFVector4,
        pub w: ScePspFVector4,
    }

    #[allow(missing_debug_implementations)]
    pub struct ScePspFMatrix4Unaligned {
        pub x: ScePspFVector4,
        pub y: ScePspFVector4,
        pub z: ScePspFVector4,
        pub w: ScePspFVector4,
    }

    #[allow(missing_debug_implementations)]
    pub union ScePspVector3 {
        pub fv: ScePspFVector3,
        pub iv: ScePspIVector3,
        pub f: [f32; 3usize],
        pub i: [i32; 3usize],
    }

    #[allow(missing_debug_implementations)]
    pub union ScePspVector4 {
        pub fv: ScePspFVector4,
        pub iv: ScePspIVector4,
        pub qw: u128,
        pub f: [f32; 4usize],
        pub i: [i32; 4usize],
    }

    #[allow(missing_debug_implementations)]
    pub union ScePspMatrix2 {
        pub fm: ScePspFMatrix2,
        pub im: ScePspIMatrix2,
        pub fv: [ScePspFVector2; 2usize],
        pub iv: [ScePspIVector2; 2usize],
        pub v: [ScePspVector2; 2usize],
        pub f: [[f32; 2usize]; 2usize],
        pub i: [[i32; 2usize]; 2usize],
    }

    #[allow(missing_debug_implementations)]
    pub union ScePspMatrix3 {
        pub fm: ScePspFMatrix3,
        pub im: ScePspIMatrix3,
        pub fv: [ScePspFVector3; 3usize],
        pub iv: [ScePspIVector3; 3usize],
        pub v: [ScePspVector3; 3usize],
        pub f: [[f32; 3usize]; 3usize],
        pub i: [[i32; 3usize]; 3usize],
    }

    #[allow(missing_debug_implementations)]
    pub union ScePspVector2 {
        pub fv: ScePspFVector2,
        pub iv: ScePspIVector2,
        pub f: [f32; 2usize],
        pub i: [i32; 2usize],
    }

    #[allow(missing_debug_implementations)]
    pub union ScePspMatrix4 {
        pub fm: ScePspFMatrix4,
        pub im: ScePspIMatrix4,
        pub fv: [ScePspFVector4; 4usize],
        pub iv: [ScePspIVector4; 4usize],
        pub v: [ScePspVector4; 4usize],
        pub f: [[f32; 4usize]; 4usize],
        pub i: [[i32; 4usize]; 4usize],
    }

    #[allow(missing_debug_implementations)]
    pub struct Key {
        pub key_type: KeyType,
        pub name: [u8; 256usize],
        pub name_len: u32,
        pub unk2: u32,
        pub unk3: u32,
    }

    #[allow(missing_debug_implementations)]
    pub struct UtilityMsgDialogParams {
        pub base: UtilityDialogCommon,
        pub unknown: i32,
        pub mode: UtilityMsgDialogMode,
        pub error_value: u32,
        pub message: [u8; 512usize],
        pub options: i32,
        pub button_pressed: UtilityMsgDialogPressed,
    }

    #[allow(missing_debug_implementations)]
    pub union UtilityNetData {
        pub as_uint: u32,
        pub as_string: [u8; 128usize],
    }

    #[allow(missing_debug_implementations)]
    pub struct UtilitySavedataSFOParam {
        pub title: [u8; 128usize],
        pub savedata_title: [u8; 128usize],
        pub detail: [u8; 1024usize],
        pub parental_level: u8,
        pub unknown: [u8; 3usize],
    }

    #[allow(missing_debug_implementations)]
    pub struct SceUtilitySavedataParam {
        pub base: UtilityDialogCommon,
        pub mode: UtilitySavedataMode,
        pub unknown1: i32,
        pub overwrite: i32,
        pub game_name: [u8; 13usize],
        pub reserved: [u8; 3usize],
        pub save_name: [u8; 20usize],
        pub save_name_list: *mut [u8; 20usize],
        pub file_name: [u8; 13usize],
        pub reserved1: [u8; 3usize],
        pub data_buf: *mut c_void,
        pub data_buf_size: usize,
        pub data_size: usize,
        pub sfo_param: UtilitySavedataSFOParam,
        pub icon0_file_data: UtilitySavedataFileData,
        pub icon1_file_data: UtilitySavedataFileData,
        pub pic1_file_data: UtilitySavedataFileData,
        pub snd0_file_data: UtilitySavedataFileData,
        pub new_data: *mut UtilitySavedataListSaveNewData,
        pub focus: UtilitySavedataFocus,
        pub unknown2: [i32; 4usize],
        pub key: [u8; 16],
        pub unknown3: [u8; 20],
    }

    #[allow(missing_debug_implementations)]
    pub struct SceNetAdhocctlPeerInfo {
        pub next: *mut SceNetAdhocctlPeerInfo,
        pub nickname: [u8; 128usize],
        pub mac: [u8; 6usize],
        pub unknown: [u8; 6usize],
        pub timestamp: u32,
    }

    #[allow(missing_debug_implementations)]
    pub struct SceNetAdhocctlParams {
        pub channel: i32,
        pub name: [u8; 8usize],
        pub bssid: [u8; 6usize],
        pub nickname: [u8; 128usize],
    }

    #[cfg_attr(feature = "extra_traits", allow(missing_debug_implementations))]
    pub union SceNetApctlInfo {
        pub name: [u8; 64usize],
        pub bssid: [u8; 6usize],
        pub ssid: [u8; 32usize],
        pub ssid_length: u32,
        pub security_type: u32,
        pub strength: u8,
        pub channel: u8,
        pub power_save: u8,
        pub ip: [u8; 16usize],
        pub sub_net_mask: [u8; 16usize],
        pub gateway: [u8; 16usize],
        pub primary_dns: [u8; 16usize],
        pub secondary_dns: [u8; 16usize],
        pub use_proxy: u32,
        pub proxy_url: [u8; 128usize],
        pub proxy_port: u16,
        pub eap_type: u32,
        pub start_browser: u32,
        pub wifisp: u32,
    }
}

pub const INT_MIN: c_int = -2147483648;
pub const INT_MAX: c_int = 2147483647;

pub const AUDIO_VOLUME_MAX: u32 = 0x8000;
pub const AUDIO_CHANNEL_MAX: u32 = 8;
pub const AUDIO_NEXT_CHANNEL: i32 = -1;
pub const AUDIO_SAMPLE_MIN: u32 = 64;
pub const AUDIO_SAMPLE_MAX: u32 = 65472;

pub const PSP_CTRL_SELECT: i32 = 0x000001;
pub const PSP_CTRL_START: i32 = 0x000008;
pub const PSP_CTRL_UP: i32 = 0x000010;
pub const PSP_CTRL_RIGHT: i32 = 0x000020;
pub const PSP_CTRL_DOWN: i32 = 0x000040;
pub const PSP_CTRL_LEFT: i32 = 0x000080;
pub const PSP_CTRL_LTRIGGER: i32 = 0x000100;
pub const PSP_CTRL_RTRIGGER: i32 = 0x000200;
pub const PSP_CTRL_TRIANGLE: i32 = 0x001000;
pub const PSP_CTRL_CIRCLE: i32 = 0x002000;
pub const PSP_CTRL_CROSS: i32 = 0x004000;
pub const PSP_CTRL_SQUARE: i32 = 0x008000;
pub const PSP_CTRL_HOME: i32 = 0x010000;
pub const PSP_CTRL_HOLD: i32 = 0x020000;
pub const PSP_CTRL_NOTE: i32 = 0x800000;
pub const PSP_CTRL_SCREEN: i32 = 0x400000;
pub const PSP_CTRL_VOLUP: i32 = 0x100000;
pub const PSP_CTRL_VOLDOWN: i32 = 0x200000;
pub const PSP_CTRL_WLAN_UP: i32 = 0x040000;
pub const PSP_CTRL_REMOTE: i32 = 0x080000;
pub const PSP_CTRL_DISC: i32 = 0x1000000;
pub const PSP_CTRL_MS: i32 = 0x2000000;

pub const USB_CAM_PID: i32 = 0x282;
pub const USB_BUS_DRIVER_NAME: &str = "USBBusDriver";
pub const USB_CAM_DRIVER_NAME: &str = "USBCamDriver";
pub const USB_CAM_MIC_DRIVER_NAME: &str = "USBCamMicDriver";
pub const USB_STOR_DRIVER_NAME: &str = "USBStor_Driver";

pub const ACTIVATED: i32 = 0x200;
pub const CONNECTED: i32 = 0x020;
pub const ESTABLISHED: i32 = 0x002;

pub const USB_CAM_FLIP: i32 = 1;
pub const USB_CAM_MIRROR: i32 = 0x100;

pub const THREAD_ATTR_VFPU: i32 = 0x00004000;
pub const THREAD_ATTR_USER: i32 = 0x80000000;
pub const THREAD_ATTR_USBWLAN: i32 = 0xa0000000;
pub const THREAD_ATTR_VSH: i32 = 0xc0000000;
pub const THREAD_ATTR_SCRATCH_SRAM: i32 = 0x00008000;
pub const THREAD_ATTR_NO_FILLSTACK: i32 = 0x00100000;
pub const THREAD_ATTR_CLEAR_STACK: i32 = 0x00200000;

pub const EVENT_WAIT_MULTIPLE: i32 = 0x200;

pub const EVENT_WAIT_AND: i32 = 0;
pub const EVENT_WAIT_OR: i32 = 1;
pub const EVENT_WAIT_CLEAR: i32 = 0x20;

pub const POWER_INFO_POWER_SWITCH: i32 = 0x80000000;
pub const POWER_INFO_HOLD_SWITCH: i32 = 0x40000000;
pub const POWER_INFO_STANDBY: i32 = 0x00080000;
pub const POWER_INFO_RESUME_COMPLETE: i32 = 0x00040000;
pub const POWER_INFO_RESUMING: i32 = 0x00020000;
pub const POWER_INFO_SUSPENDING: i32 = 0x00010000;
pub const POWER_INFO_AC_POWER: i32 = 0x00001000;
pub const POWER_INFO_BATTERY_LOW: i32 = 0x00000100;
pub const POWER_INFO_BATTERY_EXIST: i32 = 0x00000080;
pub const POWER_INFO_BATTERY_POWER: i32 = 0x0000007;

pub const FIO_S_IFLNK: i32 = 0x4000;
pub const FIO_S_IFDIR: i32 = 0x1000;
pub const FIO_S_IFREG: i32 = 0x2000;
pub const FIO_S_ISUID: i32 = 0x0800;
pub const FIO_S_ISGID: i32 = 0x0400;
pub const FIO_S_ISVTX: i32 = 0x0200;
pub const FIO_S_IRUSR: i32 = 0x0100;
pub const FIO_S_IWUSR: i32 = 0x0080;
pub const FIO_S_IXUSR: i32 = 0x0040;
pub const FIO_S_IRGRP: i32 = 0x0020;
pub const FIO_S_IWGRP: i32 = 0x0010;
pub const FIO_S_IXGRP: i32 = 0x0008;
pub const FIO_S_IROTH: i32 = 0x0004;
pub const FIO_S_IWOTH: i32 = 0x0002;
pub const FIO_S_IXOTH: i32 = 0x0001;

pub const FIO_SO_IFLNK: i32 = 0x0008;
pub const FIO_SO_IFDIR: i32 = 0x0010;
pub const FIO_SO_IFREG: i32 = 0x0020;
pub const FIO_SO_IROTH: i32 = 0x0004;
pub const FIO_SO_IWOTH: i32 = 0x0002;
pub const FIO_SO_IXOTH: i32 = 0x0001;

pub const PSP_O_RD_ONLY: i32 = 0x0001;
pub const PSP_O_WR_ONLY: i32 = 0x0002;
pub const PSP_O_RD_WR: i32 = 0x0003;
pub const PSP_O_NBLOCK: i32 = 0x0004;
pub const PSP_O_DIR: i32 = 0x0008;
pub const PSP_O_APPEND: i32 = 0x0100;
pub const PSP_O_CREAT: i32 = 0x0200;
pub const PSP_O_TRUNC: i32 = 0x0400;
pub const PSP_O_EXCL: i32 = 0x0800;
pub const PSP_O_NO_WAIT: i32 = 0x8000;

pub const UMD_NOT_PRESENT: i32 = 0x01;
pub const UMD_PRESENT: i32 = 0x02;
pub const UMD_CHANGED: i32 = 0x04;
pub const UMD_INITING: i32 = 0x08;
pub const UMD_INITED: i32 = 0x10;
pub const UMD_READY: i32 = 0x20;

pub const PLAY_PAUSE: i32 = 0x1;
pub const FORWARD: i32 = 0x4;
pub const BACK: i32 = 0x8;
pub const VOL_UP: i32 = 0x10;
pub const VOL_DOWN: i32 = 0x20;
pub const HOLD: i32 = 0x80;

pub const GU_PI: f32 = 3.141593;

pub const GU_TEXTURE_8BIT: i32 = 1;
pub const GU_TEXTURE_16BIT: i32 = 2;
pub const GU_TEXTURE_32BITF: i32 = 3;
pub const GU_COLOR_5650: i32 = 4 << 2;
pub const GU_COLOR_5551: i32 = 5 << 2;
pub const GU_COLOR_4444: i32 = 6 << 2;
pub const GU_COLOR_8888: i32 = 7 << 2;
pub const GU_NORMAL_8BIT: i32 = 1 << 5;
pub const GU_NORMAL_16BIT: i32 = 2 << 5;
pub const GU_NORMAL_32BITF: i32 = 3 << 5;
pub const GU_VERTEX_8BIT: i32 = 1 << 7;
pub const GU_VERTEX_16BIT: i32 = 2 << 7;
pub const GU_VERTEX_32BITF: i32 = 3 << 7;
pub const GU_WEIGHT_8BIT: i32 = 1 << 9;
pub const GU_WEIGHT_16BIT: i32 = 2 << 9;
pub const GU_WEIGHT_32BITF: i32 = 3 << 9;
pub const GU_INDEX_8BIT: i32 = 1 << 11;
pub const GU_INDEX_16BIT: i32 = 2 << 11;
pub const GU_WEIGHTS1: i32 = (((1 - 1) & 7) << 14) as i32;
pub const GU_WEIGHTS2: i32 = (((2 - 1) & 7) << 14) as i32;
pub const GU_WEIGHTS3: i32 = (((3 - 1) & 7) << 14) as i32;
pub const GU_WEIGHTS4: i32 = (((4 - 1) & 7) << 14) as i32;
pub const GU_WEIGHTS5: i32 = (((5 - 1) & 7) << 14) as i32;
pub const GU_WEIGHTS6: i32 = (((6 - 1) & 7) << 14) as i32;
pub const GU_WEIGHTS7: i32 = (((7 - 1) & 7) << 14) as i32;
pub const GU_WEIGHTS8: i32 = (((8 - 1) & 7) << 14) as i32;
pub const GU_VERTICES1: i32 = (((1 - 1) & 7) << 18) as i32;
pub const GU_VERTICES2: i32 = (((2 - 1) & 7) << 18) as i32;
pub const GU_VERTICES3: i32 = (((3 - 1) & 7) << 18) as i32;
pub const GU_VERTICES4: i32 = (((4 - 1) & 7) << 18) as i32;
pub const GU_VERTICES5: i32 = (((5 - 1) & 7) << 18) as i32;
pub const GU_VERTICES6: i32 = (((6 - 1) & 7) << 18) as i32;
pub const GU_VERTICES7: i32 = (((7 - 1) & 7) << 18) as i32;
pub const GU_VERTICES8: i32 = (((8 - 1) & 7) << 18) as i32;
pub const GU_TRANSFORM_2D: i32 = 1 << 23;
pub const GU_TRANSFORM_3D: i32 = 0;

pub const GU_COLOR_BUFFER_BIT: i32 = 1;
pub const GU_STENCIL_BUFFER_BIT: i32 = 2;
pub const GU_DEPTH_BUFFER_BIT: i32 = 4;
pub const GU_FAST_CLEAR_BIT: i32 = 16;

pub const GU_AMBIENT: i32 = 1;
pub const GU_DIFFUSE: i32 = 2;
pub const GU_SPECULAR: i32 = 4;
pub const GU_UNKNOWN_LIGHT_COMPONENT: i32 = 8;

pub const SYSTEM_REGISTRY: [u8; 7] = *b"/system";
pub const REG_KEYNAME_SIZE: u32 = 27;

pub const UTILITY_MSGDIALOG_ERROR: i32 = 0;
pub const UTILITY_MSGDIALOG_TEXT: i32 = 1;
pub const UTILITY_MSGDIALOG_YES_NO_BUTTONS: i32 = 0x10;
pub const UTILITY_MSGDIALOG_DEFAULT_NO: i32 = 0x100;

pub const UTILITY_HTMLVIEWER_OPEN_SCE_START_PAGE: i32 = 0x000001;
pub const UTILITY_HTMLVIEWER_DISABLE_STARTUP_LIMITS: i32 = 0x000002;
pub const UTILITY_HTMLVIEWER_DISABLE_EXIT_DIALOG: i32 = 0x000004;
pub const UTILITY_HTMLVIEWER_DISABLE_CURSOR: i32 = 0x000008;
pub const UTILITY_HTMLVIEWER_DISABLE_DOWNLOAD_COMPLETE_DIALOG: i32 = 0x000010;
pub const UTILITY_HTMLVIEWER_DISABLE_DOWNLOAD_START_DIALOG: i32 = 0x000020;
pub const UTILITY_HTMLVIEWER_DISABLE_DOWNLOAD_DESTINATION_DIALOG: i32 =
    0x000040;
pub const UTILITY_HTMLVIEWER_LOCK_DOWNLOAD_DESTINATION_DIALOG: i32 = 0x000080;
pub const UTILITY_HTMLVIEWER_DISABLE_TAB_DISPLAY: i32 = 0x000100;
pub const UTILITY_HTMLVIEWER_ENABLE_ANALOG_HOLD: i32 = 0x000200;
pub const UTILITY_HTMLVIEWER_ENABLE_FLASH: i32 = 0x000400;
pub const UTILITY_HTMLVIEWER_DISABLE_LRTRIGGER: i32 = 0x000800;

extern "C" {
    pub fn sceAudioChReserve(
        channel: i32,
        sample_count: i32,
        format: AudioFormat,
    ) -> i32;
    pub fn sceAudioChRelease(channel: i32) -> i32;
    pub fn sceAudioOutput(channel: i32, vol: i32, buf: *mut c_void) -> i32;
    pub fn sceAudioOutputBlocking(
        channel: i32,
        vol: i32,
        buf: *mut c_void,
    ) -> i32;
    pub fn sceAudioOutputPanned(
        channel: i32,
        left_vol: i32,
        right_vol: i32,
        buf: *mut c_void,
    ) -> i32;
    pub fn sceAudioOutputPannedBlocking(
        channel: i32,
        left_vol: i32,
        right_vol: i32,
        buf: *mut c_void,
    ) -> i32;
    pub fn sceAudioGetChannelRestLen(channel: i32) -> i32;
    pub fn sceAudioGetChannelRestLength(channel: i32) -> i32;
    pub fn sceAudioSetChannelDataLen(channel: i32, sample_count: i32) -> i32;
    pub fn sceAudioChangeChannelConfig(
        channel: i32,
        format: AudioFormat,
    ) -> i32;
    pub fn sceAudioChangeChannelVolume(
        channel: i32,
        left_vol: i32,
        right_vol: i32,
    ) -> i32;
    pub fn sceAudioOutput2Reserve(sample_count: i32) -> i32;
    pub fn sceAudioOutput2Release() -> i32;
    pub fn sceAudioOutput2ChangeLength(sample_count: i32) -> i32;
    pub fn sceAudioOutput2OutputBlocking(vol: i32, buf: *mut c_void) -> i32;
    pub fn sceAudioOutput2GetRestSample() -> i32;
    pub fn sceAudioSRCChReserve(
        sample_count: i32,
        freq: AudioOutputFrequency,
        channels: i32,
    ) -> i32;
    pub fn sceAudioSRCChRelease() -> i32;
    pub fn sceAudioSRCOutputBlocking(vol: i32, buf: *mut c_void) -> i32;
    pub fn sceAudioInputInit(unknown1: i32, gain: i32, unknown2: i32) -> i32;
    pub fn sceAudioInputInitEx(params: *mut AudioInputParams) -> i32;
    pub fn sceAudioInputBlocking(
        sample_count: i32,
        freq: AudioInputFrequency,
        buf: *mut c_void,
    );
    pub fn sceAudioInput(
        sample_count: i32,
        freq: AudioInputFrequency,
        buf: *mut c_void,
    );
    pub fn sceAudioGetInputLength() -> i32;
    pub fn sceAudioWaitInputEnd() -> i32;
    pub fn sceAudioPollInputEnd() -> i32;

    pub fn sceAtracGetAtracID(ui_codec_type: u32) -> i32;
    pub fn sceAtracSetDataAndGetID(buf: *mut c_void, bufsize: usize) -> i32;
    pub fn sceAtracDecodeData(
        atrac_id: i32,
        out_samples: *mut u16,
        out_n: *mut i32,
        out_end: *mut i32,
        out_remain_frame: *mut i32,
    ) -> i32;
    pub fn sceAtracGetRemainFrame(
        atrac_id: i32,
        out_remain_frame: *mut i32,
    ) -> i32;
    pub fn sceAtracGetStreamDataInfo(
        atrac_id: i32,
        write_pointer: *mut *mut u8,
        available_bytes: *mut u32,
        read_offset: *mut u32,
    ) -> i32;
    pub fn sceAtracAddStreamData(atrac_id: i32, bytes_to_add: u32) -> i32;
    pub fn sceAtracGetBitrate(atrac_id: i32, out_bitrate: *mut i32) -> i32;
    pub fn sceAtracSetLoopNum(atrac_id: i32, nloops: i32) -> i32;
    pub fn sceAtracReleaseAtracID(atrac_id: i32) -> i32;
    pub fn sceAtracGetNextSample(atrac_id: i32, out_n: *mut i32) -> i32;
    pub fn sceAtracGetMaxSample(atrac_id: i32, out_max: *mut i32) -> i32;
    pub fn sceAtracGetBufferInfoForReseting(
        atrac_id: i32,
        ui_sample: u32,
        pbuffer_info: *mut Atrac3BufferInfo,
    ) -> i32;
    pub fn sceAtracGetChannel(atrac_id: i32, pui_channel: *mut u32) -> i32;
    pub fn sceAtracGetInternalErrorInfo(
        atrac_id: i32,
        pi_result: *mut i32,
    ) -> i32;
    pub fn sceAtracGetLoopStatus(
        atrac_id: i32,
        pi_loop_num: *mut i32,
        pui_loop_status: *mut u32,
    ) -> i32;
    pub fn sceAtracGetNextDecodePosition(
        atrac_id: i32,
        pui_sample_position: *mut u32,
    ) -> i32;
    pub fn sceAtracGetSecondBufferInfo(
        atrac_id: i32,
        pui_position: *mut u32,
        pui_data_byte: *mut u32,
    ) -> i32;
    pub fn sceAtracGetSoundSample(
        atrac_id: i32,
        pi_end_sample: *mut i32,
        pi_loop_start_sample: *mut i32,
        pi_loop_end_sample: *mut i32,
    ) -> i32;
    pub fn sceAtracResetPlayPosition(
        atrac_id: i32,
        ui_sample: u32,
        ui_write_byte_first_buf: u32,
        ui_write_byte_second_buf: u32,
    ) -> i32;
    pub fn sceAtracSetData(
        atrac_id: i32,
        puc_buffer_addr: *mut u8,
        ui_buffer_byte: u32,
    ) -> i32;
    pub fn sceAtracSetHalfwayBuffer(
        atrac_id: i32,
        puc_buffer_addr: *mut u8,
        ui_read_byte: u32,
        ui_buffer_byte: u32,
    ) -> i32;
    pub fn sceAtracSetHalfwayBufferAndGetID(
        puc_buffer_addr: *mut u8,
        ui_read_byte: u32,
        ui_buffer_byte: u32,
    ) -> i32;
    pub fn sceAtracSetSecondBuffer(
        atrac_id: i32,
        puc_second_buffer_addr: *mut u8,
        ui_second_buffer_byte: u32,
    ) -> i32;

    pub fn sceCtrlSetSamplingCycle(cycle: i32) -> i32;
    pub fn sceCtrlGetSamplingCycle(pcycle: *mut i32) -> i32;
    pub fn sceCtrlSetSamplingMode(mode: CtrlMode) -> i32;
    pub fn sceCtrlGetSamplingMode(pmode: *mut i32) -> i32;
    pub fn sceCtrlPeekBufferPositive(
        pad_data: *mut SceCtrlData,
        count: i32,
    ) -> i32;
    pub fn sceCtrlPeekBufferNegative(
        pad_data: *mut SceCtrlData,
        count: i32,
    ) -> i32;
    pub fn sceCtrlReadBufferPositive(
        pad_data: *mut SceCtrlData,
        count: i32,
    ) -> i32;
    pub fn sceCtrlReadBufferNegative(
        pad_data: *mut SceCtrlData,
        count: i32,
    ) -> i32;
    pub fn sceCtrlPeekLatch(latch_data: *mut SceCtrlLatch) -> i32;
    pub fn sceCtrlReadLatch(latch_data: *mut SceCtrlLatch) -> i32;
    pub fn sceCtrlSetIdleCancelThreshold(idlereset: i32, idleback: i32)
        -> i32;
    pub fn sceCtrlGetIdleCancelThreshold(
        idlereset: *mut i32,
        idleback: *mut i32,
    ) -> i32;

    pub fn sceDisplaySetMode(
        mode: DisplayMode,
        width: usize,
        height: usize,
    ) -> u32;
    pub fn sceDisplayGetMode(
        pmode: *mut i32,
        pwidth: *mut i32,
        pheight: *mut i32,
    ) -> i32;
    pub fn sceDisplaySetFrameBuf(
        top_addr: *const u8,
        buffer_width: usize,
        pixel_format: DisplayPixelFormat,
        sync: DisplaySetBufSync,
    ) -> u32;
    pub fn sceDisplayGetFrameBuf(
        top_addr: *mut *mut c_void,
        buffer_width: *mut usize,
        pixel_format: *mut DisplayPixelFormat,
        sync: DisplaySetBufSync,
    ) -> i32;
    pub fn sceDisplayGetVcount() -> u32;
    pub fn sceDisplayWaitVblank() -> i32;
    pub fn sceDisplayWaitVblankCB() -> i32;
    pub fn sceDisplayWaitVblankStart() -> i32;
    pub fn sceDisplayWaitVblankStartCB() -> i32;
    pub fn sceDisplayGetAccumulatedHcount() -> i32;
    pub fn sceDisplayGetCurrentHcount() -> i32;
    pub fn sceDisplayGetFramePerSec() -> f32;
    pub fn sceDisplayIsForeground() -> i32;
    pub fn sceDisplayIsVblank() -> i32;

    pub fn sceGeEdramGetSize() -> u32;
    pub fn sceGeEdramGetAddr() -> *mut u8;
    pub fn sceGeEdramSetAddrTranslation(width: i32) -> i32;
    pub fn sceGeGetCmd(cmd: i32) -> u32;
    pub fn sceGeGetMtx(type_: GeMatrixType, matrix: *mut c_void) -> i32;
    pub fn sceGeGetStack(stack_id: i32, stack: *mut GeStack) -> i32;
    pub fn sceGeSaveContext(context: *mut GeContext) -> i32;
    pub fn sceGeRestoreContext(context: *const GeContext) -> i32;
    pub fn sceGeListEnQueue(
        list: *const c_void,
        stall: *mut c_void,
        cbid: i32,
        arg: *mut GeListArgs,
    ) -> i32;
    pub fn sceGeListEnQueueHead(
        list: *const c_void,
        stall: *mut c_void,
        cbid: i32,
        arg: *mut GeListArgs,
    ) -> i32;
    pub fn sceGeListDeQueue(qid: i32) -> i32;
    pub fn sceGeListUpdateStallAddr(qid: i32, stall: *mut c_void) -> i32;
    pub fn sceGeListSync(qid: i32, sync_type: i32) -> GeListState;
    pub fn sceGeDrawSync(sync_type: i32) -> GeListState;
    pub fn sceGeBreak(mode: i32, p_param: *mut GeBreakParam) -> i32;
    pub fn sceGeContinue() -> i32;
    pub fn sceGeSetCallback(cb: *mut GeCallbackData) -> i32;
    pub fn sceGeUnsetCallback(cbid: i32) -> i32;

    pub fn sceKernelExitGame();
    pub fn sceKernelRegisterExitCallback(id: SceUid) -> i32;
    pub fn sceKernelLoadExec(
        file: *const u8,
        param: *mut SceKernelLoadExecParam,
    ) -> i32;

    pub fn sceKernelAllocPartitionMemory(
        partition: SceSysMemPartitionId,
        name: *const u8,
        type_: SceSysMemBlockTypes,
        size: u32,
        addr: *mut c_void,
    ) -> SceUid;
    pub fn sceKernelGetBlockHeadAddr(blockid: SceUid) -> *mut c_void;
    pub fn sceKernelFreePartitionMemory(blockid: SceUid) -> i32;
    pub fn sceKernelTotalFreeMemSize() -> usize;
    pub fn sceKernelMaxFreeMemSize() -> usize;
    pub fn sceKernelDevkitVersion() -> u32;
    pub fn sceKernelSetCompiledSdkVersion(version: u32) -> i32;
    pub fn sceKernelGetCompiledSdkVersion() -> u32;

    pub fn sceKernelLibcTime(t: *mut i32) -> i32;
    pub fn sceKernelLibcClock() -> u32;
    pub fn sceKernelLibcGettimeofday(
        tp: *mut timeval,
        tzp: *mut timezone,
    ) -> i32;
    pub fn sceKernelDcacheWritebackAll();
    pub fn sceKernelDcacheWritebackInvalidateAll();
    pub fn sceKernelDcacheWritebackRange(p: *const c_void, size: u32);
    pub fn sceKernelDcacheWritebackInvalidateRange(
        p: *const c_void,
        size: u32,
    );
    pub fn sceKernelDcacheInvalidateRange(p: *const c_void, size: u32);
    pub fn sceKernelIcacheInvalidateAll();
    pub fn sceKernelIcacheInvalidateRange(p: *const c_void, size: u32);
    pub fn sceKernelUtilsMt19937Init(
        ctx: *mut SceKernelUtilsMt19937Context,
        seed: u32,
    ) -> i32;
    pub fn sceKernelUtilsMt19937UInt(
        ctx: *mut SceKernelUtilsMt19937Context,
    ) -> u32;
    pub fn sceKernelUtilsMd5Digest(
        data: *mut u8,
        size: u32,
        digest: *mut u8,
    ) -> i32;
    pub fn sceKernelUtilsMd5BlockInit(
        ctx: *mut SceKernelUtilsMd5Context,
    ) -> i32;
    pub fn sceKernelUtilsMd5BlockUpdate(
        ctx: *mut SceKernelUtilsMd5Context,
        data: *mut u8,
        size: u32,
    ) -> i32;
    pub fn sceKernelUtilsMd5BlockResult(
        ctx: *mut SceKernelUtilsMd5Context,
        digest: *mut u8,
    ) -> i32;
    pub fn sceKernelUtilsSha1Digest(
        data: *mut u8,
        size: u32,
        digest: *mut u8,
    ) -> i32;
    pub fn sceKernelUtilsSha1BlockInit(
        ctx: *mut SceKernelUtilsSha1Context,
    ) -> i32;
    pub fn sceKernelUtilsSha1BlockUpdate(
        ctx: *mut SceKernelUtilsSha1Context,
        data: *mut u8,
        size: u32,
    ) -> i32;
    pub fn sceKernelUtilsSha1BlockResult(
        ctx: *mut SceKernelUtilsSha1Context,
        digest: *mut u8,
    ) -> i32;

    pub fn sceKernelRegisterSubIntrHandler(
        int_no: i32,
        no: i32,
        handler: *mut c_void,
        arg: *mut c_void,
    ) -> i32;
    pub fn sceKernelReleaseSubIntrHandler(int_no: i32, no: i32) -> i32;
    pub fn sceKernelEnableSubIntr(int_no: i32, no: i32) -> i32;
    pub fn sceKernelDisableSubIntr(int_no: i32, no: i32) -> i32;
    pub fn QueryIntrHandlerInfo(
        intr_code: SceUid,
        sub_intr_code: SceUid,
        data: *mut IntrHandlerOptionParam,
    ) -> i32;

    pub fn sceKernelCpuSuspendIntr() -> u32;
    pub fn sceKernelCpuResumeIntr(flags: u32);
    pub fn sceKernelCpuResumeIntrWithSync(flags: u32);
    pub fn sceKernelIsCpuIntrSuspended(flags: u32) -> i32;
    pub fn sceKernelIsCpuIntrEnable() -> i32;

    pub fn sceKernelLoadModule(
        path: *const u8,
        flags: i32,
        option: *mut SceKernelLMOption,
    ) -> SceUid;
    pub fn sceKernelLoadModuleMs(
        path: *const u8,
        flags: i32,
        option: *mut SceKernelLMOption,
    ) -> SceUid;
    pub fn sceKernelLoadModuleByID(
        fid: SceUid,
        flags: i32,
        option: *mut SceKernelLMOption,
    ) -> SceUid;
    pub fn sceKernelLoadModuleBufferUsbWlan(
        buf_size: usize,
        buf: *mut c_void,
        flags: i32,
        option: *mut SceKernelLMOption,
    ) -> SceUid;
    pub fn sceKernelStartModule(
        mod_id: SceUid,
        arg_size: usize,
        argp: *mut c_void,
        status: *mut i32,
        option: *mut SceKernelSMOption,
    ) -> i32;
    pub fn sceKernelStopModule(
        mod_id: SceUid,
        arg_size: usize,
        argp: *mut c_void,
        status: *mut i32,
        option: *mut SceKernelSMOption,
    ) -> i32;
    pub fn sceKernelUnloadModule(mod_id: SceUid) -> i32;
    pub fn sceKernelSelfStopUnloadModule(
        unknown: i32,
        arg_size: usize,
        argp: *mut c_void,
    ) -> i32;
    pub fn sceKernelStopUnloadSelfModule(
        arg_size: usize,
        argp: *mut c_void,
        status: *mut i32,
        option: *mut SceKernelSMOption,
    ) -> i32;
    pub fn sceKernelQueryModuleInfo(
        mod_id: SceUid,
        info: *mut SceKernelModuleInfo,
    ) -> i32;
    pub fn sceKernelGetModuleIdList(
        read_buf: *mut SceUid,
        read_buf_size: i32,
        id_count: *mut i32,
    ) -> i32;

    pub fn sceKernelVolatileMemLock(
        unk: i32,
        ptr: *mut *mut c_void,
        size: *mut i32,
    ) -> i32;
    pub fn sceKernelVolatileMemTryLock(
        unk: i32,
        ptr: *mut *mut c_void,
        size: *mut i32,
    ) -> i32;
    pub fn sceKernelVolatileMemUnlock(unk: i32) -> i32;

    pub fn sceKernelStdin() -> SceUid;
    pub fn sceKernelStdout() -> SceUid;
    pub fn sceKernelStderr() -> SceUid;

    pub fn sceKernelGetThreadmanIdType(uid: SceUid) -> SceKernelIdListType;
    pub fn sceKernelCreateThread(
        name: *const u8,
        entry: SceKernelThreadEntry,
        init_priority: i32,
        stack_size: i32,
        attr: i32,
        option: *mut SceKernelThreadOptParam,
    ) -> SceUid;
    pub fn sceKernelDeleteThread(thid: SceUid) -> i32;
    pub fn sceKernelStartThread(
        id: SceUid,
        arg_len: usize,
        arg_p: *mut c_void,
    ) -> i32;
    pub fn sceKernelExitThread(status: i32) -> i32;
    pub fn sceKernelExitDeleteThread(status: i32) -> i32;
    pub fn sceKernelTerminateThread(thid: SceUid) -> i32;
    pub fn sceKernelTerminateDeleteThread(thid: SceUid) -> i32;
    pub fn sceKernelSuspendDispatchThread() -> i32;
    pub fn sceKernelResumeDispatchThread(state: i32) -> i32;
    pub fn sceKernelSleepThread() -> i32;
    pub fn sceKernelSleepThreadCB() -> i32;
    pub fn sceKernelWakeupThread(thid: SceUid) -> i32;
    pub fn sceKernelCancelWakeupThread(thid: SceUid) -> i32;
    pub fn sceKernelSuspendThread(thid: SceUid) -> i32;
    pub fn sceKernelResumeThread(thid: SceUid) -> i32;
    pub fn sceKernelWaitThreadEnd(thid: SceUid, timeout: *mut u32) -> i32;
    pub fn sceKernelWaitThreadEndCB(thid: SceUid, timeout: *mut u32) -> i32;
    pub fn sceKernelDelayThread(delay: u32) -> i32;
    pub fn sceKernelDelayThreadCB(delay: u32) -> i32;
    pub fn sceKernelDelaySysClockThread(delay: *mut SceKernelSysClock) -> i32;
    pub fn sceKernelDelaySysClockThreadCB(
        delay: *mut SceKernelSysClock,
    ) -> i32;
    pub fn sceKernelChangeCurrentThreadAttr(unknown: i32, attr: i32) -> i32;
    pub fn sceKernelChangeThreadPriority(thid: SceUid, priority: i32) -> i32;
    pub fn sceKernelRotateThreadReadyQueue(priority: i32) -> i32;
    pub fn sceKernelReleaseWaitThread(thid: SceUid) -> i32;
    pub fn sceKernelGetThreadId() -> i32;
    pub fn sceKernelGetThreadCurrentPriority() -> i32;
    pub fn sceKernelGetThreadExitStatus(thid: SceUid) -> i32;
    pub fn sceKernelCheckThreadStack() -> i32;
    pub fn sceKernelGetThreadStackFreeSize(thid: SceUid) -> i32;
    pub fn sceKernelReferThreadStatus(
        thid: SceUid,
        info: *mut SceKernelThreadInfo,
    ) -> i32;
    pub fn sceKernelReferThreadRunStatus(
        thid: SceUid,
        status: *mut SceKernelThreadRunStatus,
    ) -> i32;
    pub fn sceKernelCreateSema(
        name: *const u8,
        attr: u32,
        init_val: i32,
        max_val: i32,
        option: *mut SceKernelSemaOptParam,
    ) -> SceUid;
    pub fn sceKernelDeleteSema(sema_id: SceUid) -> i32;
    pub fn sceKernelSignalSema(sema_id: SceUid, signal: i32) -> i32;
    pub fn sceKernelWaitSema(
        sema_id: SceUid,
        signal: i32,
        timeout: *mut u32,
    ) -> i32;
    pub fn sceKernelWaitSemaCB(
        sema_id: SceUid,
        signal: i32,
        timeout: *mut u32,
    ) -> i32;
    pub fn sceKernelPollSema(sema_id: SceUid, signal: i32) -> i32;
    pub fn sceKernelReferSemaStatus(
        sema_id: SceUid,
        info: *mut SceKernelSemaInfo,
    ) -> i32;
    pub fn sceKernelCreateEventFlag(
        name: *const u8,
        attr: i32,
        bits: i32,
        opt: *mut SceKernelEventFlagOptParam,
    ) -> SceUid;
    pub fn sceKernelSetEventFlag(ev_id: SceUid, bits: u32) -> i32;
    pub fn sceKernelClearEventFlag(ev_id: SceUid, bits: u32) -> i32;
    pub fn sceKernelPollEventFlag(
        ev_id: SceUid,
        bits: u32,
        wait: i32,
        out_bits: *mut u32,
    ) -> i32;
    pub fn sceKernelWaitEventFlag(
        ev_id: SceUid,
        bits: u32,
        wait: i32,
        out_bits: *mut u32,
        timeout: *mut u32,
    ) -> i32;
    pub fn sceKernelWaitEventFlagCB(
        ev_id: SceUid,
        bits: u32,
        wait: i32,
        out_bits: *mut u32,
        timeout: *mut u32,
    ) -> i32;
    pub fn sceKernelDeleteEventFlag(ev_id: SceUid) -> i32;
    pub fn sceKernelReferEventFlagStatus(
        event: SceUid,
        status: *mut SceKernelEventFlagInfo,
    ) -> i32;
    pub fn sceKernelCreateMbx(
        name: *const u8,
        attr: u32,
        option: *mut SceKernelMbxOptParam,
    ) -> SceUid;
    pub fn sceKernelDeleteMbx(mbx_id: SceUid) -> i32;
    pub fn sceKernelSendMbx(mbx_id: SceUid, message: *mut c_void) -> i32;
    pub fn sceKernelReceiveMbx(
        mbx_id: SceUid,
        message: *mut *mut c_void,
        timeout: *mut u32,
    ) -> i32;
    pub fn sceKernelReceiveMbxCB(
        mbx_id: SceUid,
        message: *mut *mut c_void,
        timeout: *mut u32,
    ) -> i32;
    pub fn sceKernelPollMbx(mbx_id: SceUid, pmessage: *mut *mut c_void)
        -> i32;
    pub fn sceKernelCancelReceiveMbx(mbx_id: SceUid, num: *mut i32) -> i32;
    pub fn sceKernelReferMbxStatus(
        mbx_id: SceUid,
        info: *mut SceKernelMbxInfo,
    ) -> i32;
    pub fn sceKernelSetAlarm(
        clock: u32,
        handler: SceKernelAlarmHandler,
        common: *mut c_void,
    ) -> SceUid;
    pub fn sceKernelSetSysClockAlarm(
        clock: *mut SceKernelSysClock,
        handler: *mut SceKernelAlarmHandler,
        common: *mut c_void,
    ) -> SceUid;
    pub fn sceKernelCancelAlarm(alarm_id: SceUid) -> i32;
    pub fn sceKernelReferAlarmStatus(
        alarm_id: SceUid,
        info: *mut SceKernelAlarmInfo,
    ) -> i32;
    pub fn sceKernelCreateCallback(
        name: *const u8,
        func: SceKernelCallbackFunction,
        arg: *mut c_void,
    ) -> SceUid;
    pub fn sceKernelReferCallbackStatus(
        cb: SceUid,
        status: *mut SceKernelCallbackInfo,
    ) -> i32;
    pub fn sceKernelDeleteCallback(cb: SceUid) -> i32;
    pub fn sceKernelNotifyCallback(cb: SceUid, arg2: i32) -> i32;
    pub fn sceKernelCancelCallback(cb: SceUid) -> i32;
    pub fn sceKernelGetCallbackCount(cb: SceUid) -> i32;
    pub fn sceKernelCheckCallback() -> i32;
    pub fn sceKernelGetThreadmanIdList(
        type_: SceKernelIdListType,
        read_buf: *mut SceUid,
        read_buf_size: i32,
        id_count: *mut i32,
    ) -> i32;
    pub fn sceKernelReferSystemStatus(
        status: *mut SceKernelSystemStatus,
    ) -> i32;
    pub fn sceKernelCreateMsgPipe(
        name: *const u8,
        part: i32,
        attr: i32,
        unk1: *mut c_void,
        opt: *mut c_void,
    ) -> SceUid;
    pub fn sceKernelDeleteMsgPipe(uid: SceUid) -> i32;
    pub fn sceKernelSendMsgPipe(
        uid: SceUid,
        message: *mut c_void,
        size: u32,
        unk1: i32,
        unk2: *mut c_void,
        timeout: *mut u32,
    ) -> i32;
    pub fn sceKernelSendMsgPipeCB(
        uid: SceUid,
        message: *mut c_void,
        size: u32,
        unk1: i32,
        unk2: *mut c_void,
        timeout: *mut u32,
    ) -> i32;
    pub fn sceKernelTrySendMsgPipe(
        uid: SceUid,
        message: *mut c_void,
        size: u32,
        unk1: i32,
        unk2: *mut c_void,
    ) -> i32;
    pub fn sceKernelReceiveMsgPipe(
        uid: SceUid,
        message: *mut c_void,
        size: u32,
        unk1: i32,
        unk2: *mut c_void,
        timeout: *mut u32,
    ) -> i32;
    pub fn sceKernelReceiveMsgPipeCB(
        uid: SceUid,
        message: *mut c_void,
        size: u32,
        unk1: i32,
        unk2: *mut c_void,
        timeout: *mut u32,
    ) -> i32;
    pub fn sceKernelTryReceiveMsgPipe(
        uid: SceUid,
        message: *mut c_void,
        size: u32,
        unk1: i32,
        unk2: *mut c_void,
    ) -> i32;
    pub fn sceKernelCancelMsgPipe(
        uid: SceUid,
        send: *mut i32,
        recv: *mut i32,
    ) -> i32;
    pub fn sceKernelReferMsgPipeStatus(
        uid: SceUid,
        info: *mut SceKernelMppInfo,
    ) -> i32;
    pub fn sceKernelCreateVpl(
        name: *const u8,
        part: i32,
        attr: i32,
        size: u32,
        opt: *mut SceKernelVplOptParam,
    ) -> SceUid;
    pub fn sceKernelDeleteVpl(uid: SceUid) -> i32;
    pub fn sceKernelAllocateVpl(
        uid: SceUid,
        size: u32,
        data: *mut *mut c_void,
        timeout: *mut u32,
    ) -> i32;
    pub fn sceKernelAllocateVplCB(
        uid: SceUid,
        size: u32,
        data: *mut *mut c_void,
        timeout: *mut u32,
    ) -> i32;
    pub fn sceKernelTryAllocateVpl(
        uid: SceUid,
        size: u32,
        data: *mut *mut c_void,
    ) -> i32;
    pub fn sceKernelFreeVpl(uid: SceUid, data: *mut c_void) -> i32;
    pub fn sceKernelCancelVpl(uid: SceUid, num: *mut i32) -> i32;
    pub fn sceKernelReferVplStatus(
        uid: SceUid,
        info: *mut SceKernelVplInfo,
    ) -> i32;
    pub fn sceKernelCreateFpl(
        name: *const u8,
        part: i32,
        attr: i32,
        size: u32,
        blocks: u32,
        opt: *mut SceKernelFplOptParam,
    ) -> i32;
    pub fn sceKernelDeleteFpl(uid: SceUid) -> i32;
    pub fn sceKernelAllocateFpl(
        uid: SceUid,
        data: *mut *mut c_void,
        timeout: *mut u32,
    ) -> i32;
    pub fn sceKernelAllocateFplCB(
        uid: SceUid,
        data: *mut *mut c_void,
        timeout: *mut u32,
    ) -> i32;
    pub fn sceKernelTryAllocateFpl(uid: SceUid, data: *mut *mut c_void)
        -> i32;
    pub fn sceKernelFreeFpl(uid: SceUid, data: *mut c_void) -> i32;
    pub fn sceKernelCancelFpl(uid: SceUid, pnum: *mut i32) -> i32;
    pub fn sceKernelReferFplStatus(
        uid: SceUid,
        info: *mut SceKernelFplInfo,
    ) -> i32;
    pub fn sceKernelUSec2SysClock(
        usec: u32,
        clock: *mut SceKernelSysClock,
    ) -> i32;
    pub fn sceKernelUSec2SysClockWide(usec: u32) -> i64;
    pub fn sceKernelSysClock2USec(
        clock: *mut SceKernelSysClock,
        low: *mut u32,
        high: *mut u32,
    ) -> i32;
    pub fn sceKernelSysClock2USecWide(
        clock: i64,
        low: *mut u32,
        high: *mut u32,
    ) -> i32;
    pub fn sceKernelGetSystemTime(time: *mut SceKernelSysClock) -> i32;
    pub fn sceKernelGetSystemTimeWide() -> i64;
    pub fn sceKernelGetSystemTimeLow() -> u32;
    pub fn sceKernelCreateVTimer(
        name: *const u8,
        opt: *mut SceKernelVTimerOptParam,
    ) -> SceUid;
    pub fn sceKernelDeleteVTimer(uid: SceUid) -> i32;
    pub fn sceKernelGetVTimerBase(
        uid: SceUid,
        base: *mut SceKernelSysClock,
    ) -> i32;
    pub fn sceKernelGetVTimerBaseWide(uid: SceUid) -> i64;
    pub fn sceKernelGetVTimerTime(
        uid: SceUid,
        time: *mut SceKernelSysClock,
    ) -> i32;
    pub fn sceKernelGetVTimerTimeWide(uid: SceUid) -> i64;
    pub fn sceKernelSetVTimerTime(
        uid: SceUid,
        time: *mut SceKernelSysClock,
    ) -> i32;
    pub fn sceKernelSetVTimerTimeWide(uid: SceUid, time: i64) -> i64;
    pub fn sceKernelStartVTimer(uid: SceUid) -> i32;
    pub fn sceKernelStopVTimer(uid: SceUid) -> i32;
    pub fn sceKernelSetVTimerHandler(
        uid: SceUid,
        time: *mut SceKernelSysClock,
        handler: SceKernelVTimerHandler,
        common: *mut c_void,
    ) -> i32;
    pub fn sceKernelSetVTimerHandlerWide(
        uid: SceUid,
        time: i64,
        handler: SceKernelVTimerHandlerWide,
        common: *mut c_void,
    ) -> i32;
    pub fn sceKernelCancelVTimerHandler(uid: SceUid) -> i32;
    pub fn sceKernelReferVTimerStatus(
        uid: SceUid,
        info: *mut SceKernelVTimerInfo,
    ) -> i32;
    pub fn sceKernelRegisterThreadEventHandler(
        name: *const u8,
        thread_id: SceUid,
        mask: i32,
        handler: SceKernelThreadEventHandler,
        common: *mut c_void,
    ) -> SceUid;
    pub fn sceKernelReleaseThreadEventHandler(uid: SceUid) -> i32;
    pub fn sceKernelReferThreadEventHandlerStatus(
        uid: SceUid,
        info: *mut SceKernelThreadEventHandlerInfo,
    ) -> i32;
    pub fn sceKernelReferThreadProfiler() -> *mut DebugProfilerRegs;
    pub fn sceKernelReferGlobalProfiler() -> *mut DebugProfilerRegs;

    pub fn sceUsbStart(
        driver_name: *const u8,
        size: i32,
        args: *mut c_void,
    ) -> i32;
    pub fn sceUsbStop(
        driver_name: *const u8,
        size: i32,
        args: *mut c_void,
    ) -> i32;
    pub fn sceUsbActivate(pid: u32) -> i32;
    pub fn sceUsbDeactivate(pid: u32) -> i32;
    pub fn sceUsbGetState() -> i32;
    pub fn sceUsbGetDrvState(driver_name: *const u8) -> i32;
}

extern "C" {
    pub fn sceUsbCamSetupStill(param: *mut UsbCamSetupStillParam) -> i32;
    pub fn sceUsbCamSetupStillEx(param: *mut UsbCamSetupStillExParam) -> i32;
    pub fn sceUsbCamStillInputBlocking(buf: *mut u8, size: usize) -> i32;
    pub fn sceUsbCamStillInput(buf: *mut u8, size: usize) -> i32;
    pub fn sceUsbCamStillWaitInputEnd() -> i32;
    pub fn sceUsbCamStillPollInputEnd() -> i32;
    pub fn sceUsbCamStillCancelInput() -> i32;
    pub fn sceUsbCamStillGetInputLength() -> i32;
    pub fn sceUsbCamSetupVideo(
        param: *mut UsbCamSetupVideoParam,
        work_area: *mut c_void,
        work_area_size: i32,
    ) -> i32;
    pub fn sceUsbCamSetupVideoEx(
        param: *mut UsbCamSetupVideoExParam,
        work_area: *mut c_void,
        work_area_size: i32,
    ) -> i32;
    pub fn sceUsbCamStartVideo() -> i32;
    pub fn sceUsbCamStopVideo() -> i32;
    pub fn sceUsbCamReadVideoFrameBlocking(buf: *mut u8, size: usize) -> i32;
    pub fn sceUsbCamReadVideoFrame(buf: *mut u8, size: usize) -> i32;
    pub fn sceUsbCamWaitReadVideoFrameEnd() -> i32;
    pub fn sceUsbCamPollReadVideoFrameEnd() -> i32;
    pub fn sceUsbCamGetReadVideoFrameSize() -> i32;
    pub fn sceUsbCamSetSaturation(saturation: i32) -> i32;
    pub fn sceUsbCamSetBrightness(brightness: i32) -> i32;
    pub fn sceUsbCamSetContrast(contrast: i32) -> i32;
    pub fn sceUsbCamSetSharpness(sharpness: i32) -> i32;
    pub fn sceUsbCamSetImageEffectMode(effect_mode: UsbCamEffectMode) -> i32;
    pub fn sceUsbCamSetEvLevel(exposure_level: UsbCamEvLevel) -> i32;
    pub fn sceUsbCamSetReverseMode(reverse_flags: i32) -> i32;
    pub fn sceUsbCamSetZoom(zoom: i32) -> i32;
    pub fn sceUsbCamGetSaturation(saturation: *mut i32) -> i32;
    pub fn sceUsbCamGetBrightness(brightness: *mut i32) -> i32;
    pub fn sceUsbCamGetContrast(contrast: *mut i32) -> i32;
    pub fn sceUsbCamGetSharpness(sharpness: *mut i32) -> i32;
    pub fn sceUsbCamGetImageEffectMode(
        effect_mode: *mut UsbCamEffectMode,
    ) -> i32;
    pub fn sceUsbCamGetEvLevel(exposure_level: *mut UsbCamEvLevel) -> i32;
    pub fn sceUsbCamGetReverseMode(reverse_flags: *mut i32) -> i32;
    pub fn sceUsbCamGetZoom(zoom: *mut i32) -> i32;
    pub fn sceUsbCamAutoImageReverseSW(on: i32) -> i32;
    pub fn sceUsbCamGetAutoImageReverseState() -> i32;
    pub fn sceUsbCamGetLensDirection() -> i32;

    pub fn sceUsbstorBootRegisterNotify(event_flag: SceUid) -> i32;
    pub fn sceUsbstorBootUnregisterNotify(event_flag: u32) -> i32;
    pub fn sceUsbstorBootSetCapacity(size: u32) -> i32;

    pub fn scePowerRegisterCallback(slot: i32, cbid: SceUid) -> i32;
    pub fn scePowerUnregisterCallback(slot: i32) -> i32;
    pub fn scePowerIsPowerOnline() -> i32;
    pub fn scePowerIsBatteryExist() -> i32;
    pub fn scePowerIsBatteryCharging() -> i32;
    pub fn scePowerGetBatteryChargingStatus() -> i32;
    pub fn scePowerIsLowBattery() -> i32;
    pub fn scePowerGetBatteryLifePercent() -> i32;
    pub fn scePowerGetBatteryLifeTime() -> i32;
    pub fn scePowerGetBatteryTemp() -> i32;
    pub fn scePowerGetBatteryElec() -> i32;
    pub fn scePowerGetBatteryVolt() -> i32;
    pub fn scePowerSetCpuClockFrequency(cpufreq: i32) -> i32;
    pub fn scePowerSetBusClockFrequency(busfreq: i32) -> i32;
    pub fn scePowerGetCpuClockFrequency() -> i32;
    pub fn scePowerGetCpuClockFrequencyInt() -> i32;
    pub fn scePowerGetCpuClockFrequencyFloat() -> f32;
    pub fn scePowerGetBusClockFrequency() -> i32;
    pub fn scePowerGetBusClockFrequencyInt() -> i32;
    pub fn scePowerGetBusClockFrequencyFloat() -> f32;
    pub fn scePowerSetClockFrequency(
        pllfreq: i32,
        cpufreq: i32,
        busfreq: i32,
    ) -> i32;
    pub fn scePowerLock(unknown: i32) -> i32;
    pub fn scePowerUnlock(unknown: i32) -> i32;
    pub fn scePowerTick(t: PowerTick) -> i32;
    pub fn scePowerGetIdleTimer() -> i32;
    pub fn scePowerIdleTimerEnable(unknown: i32) -> i32;
    pub fn scePowerIdleTimerDisable(unknown: i32) -> i32;
    pub fn scePowerRequestStandby() -> i32;
    pub fn scePowerRequestSuspend() -> i32;

    pub fn sceWlanDevIsPowerOn() -> i32;
    pub fn sceWlanGetSwitchState() -> i32;
    pub fn sceWlanGetEtherAddr(ether_addr: *mut u8) -> i32;

    pub fn sceWlanDevAttach() -> i32;
    pub fn sceWlanDevDetach() -> i32;

    pub fn sceRtcGetTickResolution() -> u32;
    pub fn sceRtcGetCurrentTick(tick: *mut u64) -> i32;
    pub fn sceRtcGetCurrentClock(tm: *mut ScePspDateTime, tz: i32) -> i32;
    pub fn sceRtcGetCurrentClockLocalTime(tm: *mut ScePspDateTime) -> i32;
    pub fn sceRtcConvertUtcToLocalTime(
        tick_utc: *const u64,
        tick_local: *mut u64,
    ) -> i32;
    pub fn sceRtcConvertLocalTimeToUTC(
        tick_local: *const u64,
        tick_utc: *mut u64,
    ) -> i32;
    pub fn sceRtcIsLeapYear(year: i32) -> i32;
    pub fn sceRtcGetDaysInMonth(year: i32, month: i32) -> i32;
    pub fn sceRtcGetDayOfWeek(year: i32, month: i32, day: i32) -> i32;
    pub fn sceRtcCheckValid(date: *const ScePspDateTime) -> i32;
    pub fn sceRtcSetTick(date: *mut ScePspDateTime, tick: *const u64) -> i32;
    pub fn sceRtcGetTick(date: *const ScePspDateTime, tick: *mut u64) -> i32;
    pub fn sceRtcCompareTick(tick1: *const u64, tick2: *const u64) -> i32;
    pub fn sceRtcTickAddTicks(
        dest_tick: *mut u64,
        src_tick: *const u64,
        num_ticks: u64,
    ) -> i32;
    pub fn sceRtcTickAddMicroseconds(
        dest_tick: *mut u64,
        src_tick: *const u64,
        num_ms: u64,
    ) -> i32;
    pub fn sceRtcTickAddSeconds(
        dest_tick: *mut u64,
        src_tick: *const u64,
        num_seconds: u64,
    ) -> i32;
    pub fn sceRtcTickAddMinutes(
        dest_tick: *mut u64,
        src_tick: *const u64,
        num_minutes: u64,
    ) -> i32;
    pub fn sceRtcTickAddHours(
        dest_tick: *mut u64,
        src_tick: *const u64,
        num_hours: u64,
    ) -> i32;
    pub fn sceRtcTickAddDays(
        dest_tick: *mut u64,
        src_tick: *const u64,
        num_days: u64,
    ) -> i32;
    pub fn sceRtcTickAddWeeks(
        dest_tick: *mut u64,
        src_tick: *const u64,
        num_weeks: u64,
    ) -> i32;
    pub fn sceRtcTickAddMonths(
        dest_tick: *mut u64,
        src_tick: *const u64,
        num_months: u64,
    ) -> i32;
    pub fn sceRtcTickAddYears(
        dest_tick: *mut u64,
        src_tick: *const u64,
        num_years: u64,
    ) -> i32;
    pub fn sceRtcSetTime_t(date: *mut ScePspDateTime, time: i64) -> i32;
    pub fn sceRtcGetTime_t(date: *const ScePspDateTime, time: *mut i64)
        -> i32;
    pub fn sceRtcSetDosTime(date: *mut ScePspDateTime, dos_time: u32) -> i32;
    pub fn sceRtcGetDosTime(date: *mut ScePspDateTime, dos_time: u32) -> i32;
    pub fn sceRtcSetWin32FileTime(
        date: *mut ScePspDateTime,
        time: *mut u64,
    ) -> i32;
    pub fn sceRtcGetWin32FileTime(
        date: *mut ScePspDateTime,
        time: *mut u64,
    ) -> i32;
    pub fn sceRtcParseDateTime(
        dest_tick: *mut u64,
        date_string: *const u8,
    ) -> i32;
    pub fn sceRtcFormatRFC3339(
        psz_date_time: *mut char,
        p_utc: *const u64,
        time_zone_minutes: i32,
    ) -> i32;
    pub fn sceRtcFormatRFC3339LocalTime(
        psz_date_time: *mut char,
        p_utc: *const u64,
    ) -> i32;
    pub fn sceRtcParseRFC3339(
        p_utc: *mut u64,
        psz_date_time: *const u8,
    ) -> i32;
    pub fn sceRtcFormatRFC2822(
        psz_date_time: *mut char,
        p_utc: *const u64,
        time_zone_minutes: i32,
    ) -> i32;
    pub fn sceRtcFormatRFC2822LocalTime(
        psz_date_time: *mut char,
        p_utc: *const u64,
    ) -> i32;

    pub fn sceIoOpen(
        file: *const u8,
        flags: i32,
        permissions: IoPermissions,
    ) -> SceUid;
    pub fn sceIoOpenAsync(
        file: *const u8,
        flags: i32,
        permissions: IoPermissions,
    ) -> SceUid;
    pub fn sceIoClose(fd: SceUid) -> i32;
    pub fn sceIoCloseAsync(fd: SceUid) -> i32;
    pub fn sceIoRead(fd: SceUid, data: *mut c_void, size: u32) -> i32;
    pub fn sceIoReadAsync(fd: SceUid, data: *mut c_void, size: u32) -> i32;
    pub fn sceIoWrite(fd: SceUid, data: *const c_void, size: usize) -> i32;
    pub fn sceIoWriteAsync(fd: SceUid, data: *const c_void, size: u32) -> i32;
    pub fn sceIoLseek(fd: SceUid, offset: i64, whence: IoWhence) -> i64;
    pub fn sceIoLseekAsync(fd: SceUid, offset: i64, whence: IoWhence) -> i32;
    pub fn sceIoLseek32(fd: SceUid, offset: i32, whence: IoWhence) -> i32;
    pub fn sceIoLseek32Async(fd: SceUid, offset: i32, whence: IoWhence)
        -> i32;
    pub fn sceIoRemove(file: *const u8) -> i32;
    pub fn sceIoMkdir(dir: *const u8, mode: IoPermissions) -> i32;
    pub fn sceIoRmdir(path: *const u8) -> i32;
    pub fn sceIoChdir(path: *const u8) -> i32;
    pub fn sceIoRename(oldname: *const u8, newname: *const u8) -> i32;
    pub fn sceIoDopen(dirname: *const u8) -> SceUid;
    pub fn sceIoDread(fd: SceUid, dir: *mut SceIoDirent) -> i32;
    pub fn sceIoDclose(fd: SceUid) -> i32;
    pub fn sceIoDevctl(
        dev: *const u8,
        cmd: u32,
        indata: *mut c_void,
        inlen: i32,
        outdata: *mut c_void,
        outlen: i32,
    ) -> i32;
    pub fn sceIoAssign(
        dev1: *const u8,
        dev2: *const u8,
        dev3: *const u8,
        mode: IoAssignPerms,
        unk1: *mut c_void,
        unk2: i32,
    ) -> i32;
    pub fn sceIoUnassign(dev: *const u8) -> i32;
    pub fn sceIoGetstat(file: *const u8, stat: *mut SceIoStat) -> i32;
    pub fn sceIoChstat(
        file: *const u8,
        stat: *mut SceIoStat,
        bits: i32,
    ) -> i32;
    pub fn sceIoIoctl(
        fd: SceUid,
        cmd: u32,
        indata: *mut c_void,
        inlen: i32,
        outdata: *mut c_void,
        outlen: i32,
    ) -> i32;
    pub fn sceIoIoctlAsync(
        fd: SceUid,
        cmd: u32,
        indata: *mut c_void,
        inlen: i32,
        outdata: *mut c_void,
        outlen: i32,
    ) -> i32;
    pub fn sceIoSync(device: *const u8, unk: u32) -> i32;
    pub fn sceIoWaitAsync(fd: SceUid, res: *mut i64) -> i32;
    pub fn sceIoWaitAsyncCB(fd: SceUid, res: *mut i64) -> i32;
    pub fn sceIoPollAsync(fd: SceUid, res: *mut i64) -> i32;
    pub fn sceIoGetAsyncStat(fd: SceUid, poll: i32, res: *mut i64) -> i32;
    pub fn sceIoCancel(fd: SceUid) -> i32;
    pub fn sceIoGetDevType(fd: SceUid) -> i32;
    pub fn sceIoChangeAsyncPriority(fd: SceUid, pri: i32) -> i32;
    pub fn sceIoSetAsyncCallback(
        fd: SceUid,
        cb: SceUid,
        argp: *mut c_void,
    ) -> i32;

    pub fn sceJpegInitMJpeg() -> i32;
    pub fn sceJpegFinishMJpeg() -> i32;
    pub fn sceJpegCreateMJpeg(width: i32, height: i32) -> i32;
    pub fn sceJpegDeleteMJpeg() -> i32;
    pub fn sceJpegDecodeMJpeg(
        jpeg_buf: *mut u8,
        size: usize,
        rgba: *mut c_void,
        unk: u32,
    ) -> i32;

    pub fn sceUmdCheckMedium() -> i32;
    pub fn sceUmdGetDiscInfo(info: *mut UmdInfo) -> i32;
    pub fn sceUmdActivate(unit: i32, drive: *const u8) -> i32;
    pub fn sceUmdDeactivate(unit: i32, drive: *const u8) -> i32;
    pub fn sceUmdWaitDriveStat(state: i32) -> i32;
    pub fn sceUmdWaitDriveStatWithTimer(state: i32, timeout: u32) -> i32;
    pub fn sceUmdWaitDriveStatCB(state: i32, timeout: u32) -> i32;
    pub fn sceUmdCancelWaitDriveStat() -> i32;
    pub fn sceUmdGetDriveStat() -> i32;
    pub fn sceUmdGetErrorStat() -> i32;
    pub fn sceUmdRegisterUMDCallBack(cbid: i32) -> i32;
    pub fn sceUmdUnRegisterUMDCallBack(cbid: i32) -> i32;
    pub fn sceUmdReplacePermit() -> i32;
    pub fn sceUmdReplaceProhibit() -> i32;

    pub fn sceMpegInit() -> i32;
    pub fn sceMpegFinish();
    pub fn sceMpegRingbufferQueryMemSize(packets: i32) -> i32;
    pub fn sceMpegRingbufferConstruct(
        ringbuffer: *mut SceMpegRingbuffer,
        packets: i32,
        data: *mut c_void,
        size: i32,
        callback: SceMpegRingbufferCb,
        cb_param: *mut c_void,
    ) -> i32;
    pub fn sceMpegRingbufferDestruct(ringbuffer: *mut SceMpegRingbuffer);
    pub fn sceMpegRingbufferAvailableSize(
        ringbuffer: *mut SceMpegRingbuffer,
    ) -> i32;
    pub fn sceMpegRingbufferPut(
        ringbuffer: *mut SceMpegRingbuffer,
        num_packets: i32,
        available: i32,
    ) -> i32;
    pub fn sceMpegQueryMemSize(unk: i32) -> i32;
    pub fn sceMpegCreate(
        handle: SceMpeg,
        data: *mut c_void,
        size: i32,
        ringbuffer: *mut SceMpegRingbuffer,
        frame_width: i32,
        unk1: i32,
        unk2: i32,
    ) -> i32;
    pub fn sceMpegDelete(handle: SceMpeg);
    pub fn sceMpegQueryStreamOffset(
        handle: SceMpeg,
        buffer: *mut c_void,
        offset: *mut i32,
    ) -> i32;
    pub fn sceMpegQueryStreamSize(buffer: *mut c_void, size: *mut i32) -> i32;
    pub fn sceMpegRegistStream(
        handle: SceMpeg,
        stream_id: i32,
        unk: i32,
    ) -> SceMpegStream;
    pub fn sceMpegUnRegistStream(handle: SceMpeg, stream: SceMpegStream);
    pub fn sceMpegFlushAllStream(handle: SceMpeg) -> i32;
    pub fn sceMpegMallocAvcEsBuf(handle: SceMpeg) -> *mut c_void;
    pub fn sceMpegFreeAvcEsBuf(handle: SceMpeg, buf: *mut c_void);
    pub fn sceMpegQueryAtracEsSize(
        handle: SceMpeg,
        es_size: *mut i32,
        out_size: *mut i32,
    ) -> i32;
    pub fn sceMpegInitAu(
        handle: SceMpeg,
        es_buffer: *mut c_void,
        au: *mut SceMpegAu,
    ) -> i32;
    pub fn sceMpegGetAvcAu(
        handle: SceMpeg,
        stream: SceMpegStream,
        au: *mut SceMpegAu,
        unk: *mut i32,
    ) -> i32;
    pub fn sceMpegAvcDecodeMode(
        handle: SceMpeg,
        mode: *mut SceMpegAvcMode,
    ) -> i32;
    pub fn sceMpegAvcDecode(
        handle: SceMpeg,
        au: *mut SceMpegAu,
        iframe_width: i32,
        buffer: *mut c_void,
        init: *mut i32,
    ) -> i32;
    pub fn sceMpegAvcDecodeStop(
        handle: SceMpeg,
        frame_width: i32,
        buffer: *mut c_void,
        status: *mut i32,
    ) -> i32;
    pub fn sceMpegGetAtracAu(
        handle: SceMpeg,
        stream: SceMpegStream,
        au: *mut SceMpegAu,
        unk: *mut c_void,
    ) -> i32;
    pub fn sceMpegAtracDecode(
        handle: SceMpeg,
        au: *mut SceMpegAu,
        buffer: *mut c_void,
        init: i32,
    ) -> i32;

    pub fn sceMpegBaseYCrCbCopyVme(
        yuv_buffer: *mut c_void,
        buffer: *mut i32,
        type_: i32,
    ) -> i32;
    pub fn sceMpegBaseCscInit(width: i32) -> i32;
    pub fn sceMpegBaseCscVme(
        rgb_buffer: *mut c_void,
        rgb_buffer2: *mut c_void,
        width: i32,
        y_cr_cb_buffer: *mut SceMpegYCrCbBuffer,
    ) -> i32;
    pub fn sceMpegbase_BEA18F91(lli: *mut SceMpegLLI) -> i32;

    pub fn sceHprmPeekCurrentKey(key: *mut i32) -> i32;
    pub fn sceHprmPeekLatch(latch: *mut [u32; 4]) -> i32;
    pub fn sceHprmReadLatch(latch: *mut [u32; 4]) -> i32;
    pub fn sceHprmIsHeadphoneExist() -> i32;
    pub fn sceHprmIsRemoteExist() -> i32;
    pub fn sceHprmIsMicrophoneExist() -> i32;

    pub fn sceGuDepthBuffer(zbp: *mut c_void, zbw: i32);
    pub fn sceGuDispBuffer(
        width: i32,
        height: i32,
        dispbp: *mut c_void,
        dispbw: i32,
    );
    pub fn sceGuDrawBuffer(
        psm: DisplayPixelFormat,
        fbp: *mut c_void,
        fbw: i32,
    );
    pub fn sceGuDrawBufferList(
        psm: DisplayPixelFormat,
        fbp: *mut c_void,
        fbw: i32,
    );
    pub fn sceGuDisplay(state: bool) -> bool;
    pub fn sceGuDepthFunc(function: DepthFunc);
    pub fn sceGuDepthMask(mask: i32);
    pub fn sceGuDepthOffset(offset: i32);
    pub fn sceGuDepthRange(near: i32, far: i32);
    pub fn sceGuFog(near: f32, far: f32, color: u32);
    pub fn sceGuInit();
    pub fn sceGuTerm();
    pub fn sceGuBreak(mode: i32);
    pub fn sceGuContinue();
    pub fn sceGuSetCallback(
        signal: GuCallbackId,
        callback: GuCallback,
    ) -> GuCallback;
    pub fn sceGuSignal(behavior: SignalBehavior, signal: i32);
    pub fn sceGuSendCommandf(cmd: GeCommand, argument: f32);
    pub fn sceGuSendCommandi(cmd: GeCommand, argument: i32);
    pub fn sceGuGetMemory(size: i32) -> *mut c_void;
    pub fn sceGuStart(context_type: GuContextType, list: *mut c_void);
    pub fn sceGuFinish() -> i32;
    pub fn sceGuFinishId(id: u32) -> i32;
    pub fn sceGuCallList(list: *const c_void);
    pub fn sceGuCallMode(mode: i32);
    pub fn sceGuCheckList() -> i32;
    pub fn sceGuSendList(
        mode: GuQueueMode,
        list: *const c_void,
        context: *mut GeContext,
    );
    pub fn sceGuSwapBuffers() -> *mut c_void;
    pub fn sceGuSync(
        mode: GuSyncMode,
        behavior: GuSyncBehavior,
    ) -> GeListState;
    pub fn sceGuDrawArray(
        prim: GuPrimitive,
        vtype: i32,
        count: i32,
        indices: *const c_void,
        vertices: *const c_void,
    );
    pub fn sceGuBeginObject(
        vtype: i32,
        count: i32,
        indices: *const c_void,
        vertices: *const c_void,
    );
    pub fn sceGuEndObject();
    pub fn sceGuSetStatus(state: GuState, status: i32);
    pub fn sceGuGetStatus(state: GuState) -> bool;
    pub fn sceGuSetAllStatus(status: i32);
    pub fn sceGuGetAllStatus() -> i32;
    pub fn sceGuEnable(state: GuState);
    pub fn sceGuDisable(state: GuState);
    pub fn sceGuLight(
        light: i32,
        type_: LightType,
        components: i32,
        position: &ScePspFVector3,
    );
    pub fn sceGuLightAtt(light: i32, atten0: f32, atten1: f32, atten2: f32);
    pub fn sceGuLightColor(light: i32, component: i32, color: u32);
    pub fn sceGuLightMode(mode: LightMode);
    pub fn sceGuLightSpot(
        light: i32,
        direction: &ScePspFVector3,
        exponent: f32,
        cutoff: f32,
    );
    pub fn sceGuClear(flags: i32);
    pub fn sceGuClearColor(color: u32);
    pub fn sceGuClearDepth(depth: u32);
    pub fn sceGuClearStencil(stencil: u32);
    pub fn sceGuPixelMask(mask: u32);
    pub fn sceGuColor(color: u32);
    pub fn sceGuColorFunc(func: ColorFunc, color: u32, mask: u32);
    pub fn sceGuColorMaterial(components: i32);
    pub fn sceGuAlphaFunc(func: AlphaFunc, value: i32, mask: i32);
    pub fn sceGuAmbient(color: u32);
    pub fn sceGuAmbientColor(color: u32);
    pub fn sceGuBlendFunc(
        op: BlendOp,
        src: BlendSrc,
        dest: BlendDst,
        src_fix: u32,
        dest_fix: u32,
    );
    pub fn sceGuMaterial(components: i32, color: u32);
    pub fn sceGuModelColor(
        emissive: u32,
        ambient: u32,
        diffuse: u32,
        specular: u32,
    );
    pub fn sceGuStencilFunc(func: StencilFunc, ref_: i32, mask: i32);
    pub fn sceGuStencilOp(
        fail: StencilOperation,
        zfail: StencilOperation,
        zpass: StencilOperation,
    );
    pub fn sceGuSpecular(power: f32);
    pub fn sceGuFrontFace(order: FrontFaceDirection);
    pub fn sceGuLogicalOp(op: LogicalOperation);
    pub fn sceGuSetDither(matrix: &ScePspIMatrix4);
    pub fn sceGuShadeModel(mode: ShadingModel);
    pub fn sceGuCopyImage(
        psm: DisplayPixelFormat,
        sx: i32,
        sy: i32,
        width: i32,
        height: i32,
        srcw: i32,
        src: *mut c_void,
        dx: i32,
        dy: i32,
        destw: i32,
        dest: *mut c_void,
    );
    pub fn sceGuTexEnvColor(color: u32);
    pub fn sceGuTexFilter(min: TextureFilter, mag: TextureFilter);
    pub fn sceGuTexFlush();
    pub fn sceGuTexFunc(tfx: TextureEffect, tcc: TextureColorComponent);
    pub fn sceGuTexImage(
        mipmap: MipmapLevel,
        width: i32,
        height: i32,
        tbw: i32,
        tbp: *const c_void,
    );
    pub fn sceGuTexLevelMode(mode: TextureLevelMode, bias: f32);
    pub fn sceGuTexMapMode(mode: TextureMapMode, a1: u32, a2: u32);
    pub fn sceGuTexMode(
        tpsm: TexturePixelFormat,
        maxmips: i32,
        a2: i32,
        swizzle: i32,
    );
    pub fn sceGuTexOffset(u: f32, v: f32);
    pub fn sceGuTexProjMapMode(mode: TextureProjectionMapMode);
    pub fn sceGuTexScale(u: f32, v: f32);
    pub fn sceGuTexSlope(slope: f32);
    pub fn sceGuTexSync();
    pub fn sceGuTexWrap(u: GuTexWrapMode, v: GuTexWrapMode);
    pub fn sceGuClutLoad(num_blocks: i32, cbp: *const c_void);
    pub fn sceGuClutMode(
        cpsm: ClutPixelFormat,
        shift: u32,
        mask: u32,
        a3: u32,
    );
    pub fn sceGuOffset(x: u32, y: u32);
    pub fn sceGuScissor(x: i32, y: i32, w: i32, h: i32);
    pub fn sceGuViewport(cx: i32, cy: i32, width: i32, height: i32);
    pub fn sceGuDrawBezier(
        v_type: i32,
        u_count: i32,
        v_count: i32,
        indices: *const c_void,
        vertices: *const c_void,
    );
    pub fn sceGuPatchDivide(ulevel: u32, vlevel: u32);
    pub fn sceGuPatchFrontFace(a0: u32);
    pub fn sceGuPatchPrim(prim: PatchPrimitive);
    pub fn sceGuDrawSpline(
        v_type: i32,
        u_count: i32,
        v_count: i32,
        u_edge: i32,
        v_edge: i32,
        indices: *const c_void,
        vertices: *const c_void,
    );
    pub fn sceGuSetMatrix(type_: MatrixMode, matrix: &ScePspFMatrix4);
    pub fn sceGuBoneMatrix(index: u32, matrix: &ScePspFMatrix4);
    pub fn sceGuMorphWeight(index: i32, weight: f32);
    pub fn sceGuDrawArrayN(
        primitive_type: GuPrimitive,
        v_type: i32,
        count: i32,
        a3: i32,
        indices: *const c_void,
        vertices: *const c_void,
    );

    pub fn sceGumDrawArray(
        prim: GuPrimitive,
        v_type: i32,
        count: i32,
        indices: *const c_void,
        vertices: *const c_void,
    );
    pub fn sceGumDrawArrayN(
        prim: GuPrimitive,
        v_type: i32,
        count: i32,
        a3: i32,
        indices: *const c_void,
        vertices: *const c_void,
    );
    pub fn sceGumDrawBezier(
        v_type: i32,
        u_count: i32,
        v_count: i32,
        indices: *const c_void,
        vertices: *const c_void,
    );
    pub fn sceGumDrawSpline(
        v_type: i32,
        u_count: i32,
        v_count: i32,
        u_edge: i32,
        v_edge: i32,
        indices: *const c_void,
        vertices: *const c_void,
    );
    pub fn sceGumFastInverse();
    pub fn sceGumFullInverse();
    pub fn sceGumLoadIdentity();
    pub fn sceGumLoadMatrix(m: &ScePspFMatrix4);
    pub fn sceGumLookAt(
        eye: &ScePspFVector3,
        center: &ScePspFVector3,
        up: &ScePspFVector3,
    );
    pub fn sceGumMatrixMode(mode: MatrixMode);
    pub fn sceGumMultMatrix(m: &ScePspFMatrix4);
    pub fn sceGumOrtho(
        left: f32,
        right: f32,
        bottom: f32,
        top: f32,
        near: f32,
        far: f32,
    );
    pub fn sceGumPerspective(fovy: f32, aspect: f32, near: f32, far: f32);
    pub fn sceGumPopMatrix();
    pub fn sceGumPushMatrix();
    pub fn sceGumRotateX(angle: f32);
    pub fn sceGumRotateY(angle: f32);
    pub fn sceGumRotateZ(angle: f32);
    pub fn sceGumRotateXYZ(v: &ScePspFVector3);
    pub fn sceGumRotateZYX(v: &ScePspFVector3);
    pub fn sceGumScale(v: &ScePspFVector3);
    pub fn sceGumStoreMatrix(m: &mut ScePspFMatrix4);
    pub fn sceGumTranslate(v: &ScePspFVector3);
    pub fn sceGumUpdateMatrix();

    pub fn sceMp3ReserveMp3Handle(args: *mut SceMp3InitArg) -> i32;
    pub fn sceMp3ReleaseMp3Handle(handle: Mp3Handle) -> i32;
    pub fn sceMp3InitResource() -> i32;
    pub fn sceMp3TermResource() -> i32;
    pub fn sceMp3Init(handle: Mp3Handle) -> i32;
    pub fn sceMp3Decode(handle: Mp3Handle, dst: *mut *mut i16) -> i32;
    pub fn sceMp3GetInfoToAddStreamData(
        handle: Mp3Handle,
        dst: *mut *mut u8,
        to_write: *mut i32,
        src_pos: *mut i32,
    ) -> i32;
    pub fn sceMp3NotifyAddStreamData(handle: Mp3Handle, size: i32) -> i32;
    pub fn sceMp3CheckStreamDataNeeded(handle: Mp3Handle) -> i32;
    pub fn sceMp3SetLoopNum(handle: Mp3Handle, loop_: i32) -> i32;
    pub fn sceMp3GetLoopNum(handle: Mp3Handle) -> i32;
    pub fn sceMp3GetSumDecodedSample(handle: Mp3Handle) -> i32;
    pub fn sceMp3GetMaxOutputSample(handle: Mp3Handle) -> i32;
    pub fn sceMp3GetSamplingRate(handle: Mp3Handle) -> i32;
    pub fn sceMp3GetBitRate(handle: Mp3Handle) -> i32;
    pub fn sceMp3GetMp3ChannelNum(handle: Mp3Handle) -> i32;
    pub fn sceMp3ResetPlayPosition(handle: Mp3Handle) -> i32;

    pub fn sceRegOpenRegistry(
        reg: *mut Key,
        mode: i32,
        handle: *mut RegHandle,
    ) -> i32;
    pub fn sceRegFlushRegistry(handle: RegHandle) -> i32;
    pub fn sceRegCloseRegistry(handle: RegHandle) -> i32;
    pub fn sceRegOpenCategory(
        handle: RegHandle,
        name: *const u8,
        mode: i32,
        dir_handle: *mut RegHandle,
    ) -> i32;
    pub fn sceRegRemoveCategory(handle: RegHandle, name: *const u8) -> i32;
    pub fn sceRegCloseCategory(dir_handle: RegHandle) -> i32;
    pub fn sceRegFlushCategory(dir_handle: RegHandle) -> i32;
    pub fn sceRegGetKeyInfo(
        dir_handle: RegHandle,
        name: *const u8,
        key_handle: *mut RegHandle,
        type_: *mut KeyType,
        size: *mut usize,
    ) -> i32;
    pub fn sceRegGetKeyInfoByName(
        dir_handle: RegHandle,
        name: *const u8,
        type_: *mut KeyType,
        size: *mut usize,
    ) -> i32;
    pub fn sceRegGetKeyValue(
        dir_handle: RegHandle,
        key_handle: RegHandle,
        buf: *mut c_void,
        size: usize,
    ) -> i32;
    pub fn sceRegGetKeyValueByName(
        dir_handle: RegHandle,
        name: *const u8,
        buf: *mut c_void,
        size: usize,
    ) -> i32;
    pub fn sceRegSetKeyValue(
        dir_handle: RegHandle,
        name: *const u8,
        buf: *const c_void,
        size: usize,
    ) -> i32;
    pub fn sceRegGetKeysNum(dir_handle: RegHandle, num: *mut i32) -> i32;
    pub fn sceRegGetKeys(dir_handle: RegHandle, buf: *mut u8, num: i32)
        -> i32;
    pub fn sceRegCreateKey(
        dir_handle: RegHandle,
        name: *const u8,
        type_: i32,
        size: usize,
    ) -> i32;
    pub fn sceRegRemoveRegistry(key: *mut Key) -> i32;

    pub fn sceOpenPSIDGetOpenPSID(openpsid: *mut OpenPSID) -> i32;

    pub fn sceUtilityMsgDialogInitStart(
        params: *mut UtilityMsgDialogParams,
    ) -> i32;
    pub fn sceUtilityMsgDialogShutdownStart();
    pub fn sceUtilityMsgDialogGetStatus() -> i32;
    pub fn sceUtilityMsgDialogUpdate(n: i32);
    pub fn sceUtilityMsgDialogAbort() -> i32;
    pub fn sceUtilityNetconfInitStart(data: *mut UtilityNetconfData) -> i32;
    pub fn sceUtilityNetconfShutdownStart() -> i32;
    pub fn sceUtilityNetconfUpdate(unknown: i32) -> i32;
    pub fn sceUtilityNetconfGetStatus() -> i32;
    pub fn sceUtilityCheckNetParam(id: i32) -> i32;
    pub fn sceUtilityGetNetParam(
        conf: i32,
        param: NetParam,
        data: *mut UtilityNetData,
    ) -> i32;
    pub fn sceUtilitySavedataInitStart(
        params: *mut SceUtilitySavedataParam,
    ) -> i32;
    pub fn sceUtilitySavedataGetStatus() -> i32;
    pub fn sceUtilitySavedataShutdownStart() -> i32;
    pub fn sceUtilitySavedataUpdate(unknown: i32);
    pub fn sceUtilityGameSharingInitStart(
        params: *mut UtilityGameSharingParams,
    ) -> i32;
    pub fn sceUtilityGameSharingShutdownStart();
    pub fn sceUtilityGameSharingGetStatus() -> i32;
    pub fn sceUtilityGameSharingUpdate(n: i32);
    pub fn sceUtilityHtmlViewerInitStart(
        params: *mut UtilityHtmlViewerParam,
    ) -> i32;
    pub fn sceUtilityHtmlViewerShutdownStart() -> i32;
    pub fn sceUtilityHtmlViewerUpdate(n: i32) -> i32;
    pub fn sceUtilityHtmlViewerGetStatus() -> i32;
    pub fn sceUtilitySetSystemParamInt(id: SystemParamId, value: i32) -> i32;
    pub fn sceUtilitySetSystemParamString(
        id: SystemParamId,
        str: *const u8,
    ) -> i32;
    pub fn sceUtilityGetSystemParamInt(
        id: SystemParamId,
        value: *mut i32,
    ) -> i32;
    pub fn sceUtilityGetSystemParamString(
        id: SystemParamId,
        str: *mut u8,
        len: i32,
    ) -> i32;
    pub fn sceUtilityOskInitStart(params: *mut SceUtilityOskParams) -> i32;
    pub fn sceUtilityOskShutdownStart() -> i32;
    pub fn sceUtilityOskUpdate(n: i32) -> i32;
    pub fn sceUtilityOskGetStatus() -> i32;
    pub fn sceUtilityLoadNetModule(module: NetModule) -> i32;
    pub fn sceUtilityUnloadNetModule(module: NetModule) -> i32;
    pub fn sceUtilityLoadAvModule(module: AvModule) -> i32;
    pub fn sceUtilityUnloadAvModule(module: AvModule) -> i32;
    pub fn sceUtilityLoadUsbModule(module: UsbModule) -> i32;
    pub fn sceUtilityUnloadUsbModule(module: UsbModule) -> i32;
    pub fn sceUtilityLoadModule(module: Module) -> i32;
    pub fn sceUtilityUnloadModule(module: Module) -> i32;
    pub fn sceUtilityCreateNetParam(conf: i32) -> i32;
    pub fn sceUtilitySetNetParam(param: NetParam, val: *const c_void) -> i32;
    pub fn sceUtilityCopyNetParam(src: i32, dest: i32) -> i32;
    pub fn sceUtilityDeleteNetParam(conf: i32) -> i32;

    pub fn sceNetInit(
        poolsize: i32,
        calloutprio: i32,
        calloutstack: i32,
        netintrprio: i32,
        netintrstack: i32,
    ) -> i32;
    pub fn sceNetTerm() -> i32;
    pub fn sceNetFreeThreadinfo(thid: i32) -> i32;
    pub fn sceNetThreadAbort(thid: i32) -> i32;
    pub fn sceNetEtherStrton(name: *mut u8, mac: *mut u8);
    pub fn sceNetEtherNtostr(mac: *mut u8, name: *mut u8);
    pub fn sceNetGetLocalEtherAddr(mac: *mut u8) -> i32;
    pub fn sceNetGetMallocStat(stat: *mut SceNetMallocStat) -> i32;

    pub fn sceNetAdhocctlInit(
        stacksize: i32,
        priority: i32,
        adhoc_id: *mut SceNetAdhocctlAdhocId,
    ) -> i32;
    pub fn sceNetAdhocctlTerm() -> i32;
    pub fn sceNetAdhocctlConnect(name: *const u8) -> i32;
    pub fn sceNetAdhocctlDisconnect() -> i32;
    pub fn sceNetAdhocctlGetState(event: *mut i32) -> i32;
    pub fn sceNetAdhocctlCreate(name: *const u8) -> i32;
    pub fn sceNetAdhocctlJoin(scaninfo: *mut SceNetAdhocctlScanInfo) -> i32;
    pub fn sceNetAdhocctlGetAdhocId(id: *mut SceNetAdhocctlAdhocId) -> i32;
    pub fn sceNetAdhocctlCreateEnterGameMode(
        name: *const u8,
        unknown: i32,
        num: i32,
        macs: *mut u8,
        timeout: u32,
        unknown2: i32,
    ) -> i32;
    pub fn sceNetAdhocctlJoinEnterGameMode(
        name: *const u8,
        hostmac: *mut u8,
        timeout: u32,
        unknown: i32,
    ) -> i32;
    pub fn sceNetAdhocctlGetGameModeInfo(
        gamemodeinfo: *mut SceNetAdhocctlGameModeInfo,
    ) -> i32;
    pub fn sceNetAdhocctlExitGameMode() -> i32;
    pub fn sceNetAdhocctlGetPeerList(
        length: *mut i32,
        buf: *mut c_void,
    ) -> i32;
    pub fn sceNetAdhocctlGetPeerInfo(
        mac: *mut u8,
        size: i32,
        peerinfo: *mut SceNetAdhocctlPeerInfo,
    ) -> i32;
    pub fn sceNetAdhocctlScan() -> i32;
    pub fn sceNetAdhocctlGetScanInfo(
        length: *mut i32,
        buf: *mut c_void,
    ) -> i32;
    pub fn sceNetAdhocctlAddHandler(
        handler: SceNetAdhocctlHandler,
        unknown: *mut c_void,
    ) -> i32;
    pub fn sceNetAdhocctlDelHandler(id: i32) -> i32;
    pub fn sceNetAdhocctlGetNameByAddr(mac: *mut u8, nickname: *mut u8)
        -> i32;
    pub fn sceNetAdhocctlGetAddrByName(
        nickname: *mut u8,
        length: *mut i32,
        buf: *mut c_void,
    ) -> i32;
    pub fn sceNetAdhocctlGetParameter(
        params: *mut SceNetAdhocctlParams,
    ) -> i32;

    pub fn sceNetAdhocInit() -> i32;
    pub fn sceNetAdhocTerm() -> i32;
    pub fn sceNetAdhocPdpCreate(
        mac: *mut u8,
        port: u16,
        buf_size: u32,
        unk1: i32,
    ) -> i32;
    pub fn sceNetAdhocPdpDelete(id: i32, unk1: i32) -> i32;
    pub fn sceNetAdhocPdpSend(
        id: i32,
        dest_mac_addr: *mut u8,
        port: u16,
        data: *mut c_void,
        len: u32,
        timeout: u32,
        nonblock: i32,
    ) -> i32;
    pub fn sceNetAdhocPdpRecv(
        id: i32,
        src_mac_addr: *mut u8,
        port: *mut u16,
        data: *mut c_void,
        data_length: *mut c_void,
        timeout: u32,
        nonblock: i32,
    ) -> i32;
    pub fn sceNetAdhocGetPdpStat(
        size: *mut i32,
        stat: *mut SceNetAdhocPdpStat,
    ) -> i32;
    pub fn sceNetAdhocGameModeCreateMaster(
        data: *mut c_void,
        size: i32,
    ) -> i32;
    pub fn sceNetAdhocGameModeCreateReplica(
        mac: *mut u8,
        data: *mut c_void,
        size: i32,
    ) -> i32;
    pub fn sceNetAdhocGameModeUpdateMaster() -> i32;
    pub fn sceNetAdhocGameModeUpdateReplica(id: i32, unk1: i32) -> i32;
    pub fn sceNetAdhocGameModeDeleteMaster() -> i32;
    pub fn sceNetAdhocGameModeDeleteReplica(id: i32) -> i32;
    pub fn sceNetAdhocPtpOpen(
        srcmac: *mut u8,
        srcport: u16,
        destmac: *mut u8,
        destport: u16,
        buf_size: u32,
        delay: u32,
        count: i32,
        unk1: i32,
    ) -> i32;
    pub fn sceNetAdhocPtpConnect(id: i32, timeout: u32, nonblock: i32) -> i32;
    pub fn sceNetAdhocPtpListen(
        srcmac: *mut u8,
        srcport: u16,
        buf_size: u32,
        delay: u32,
        count: i32,
        queue: i32,
        unk1: i32,
    ) -> i32;
    pub fn sceNetAdhocPtpAccept(
        id: i32,
        mac: *mut u8,
        port: *mut u16,
        timeout: u32,
        nonblock: i32,
    ) -> i32;
    pub fn sceNetAdhocPtpSend(
        id: i32,
        data: *mut c_void,
        data_size: *mut i32,
        timeout: u32,
        nonblock: i32,
    ) -> i32;
    pub fn sceNetAdhocPtpRecv(
        id: i32,
        data: *mut c_void,
        data_size: *mut i32,
        timeout: u32,
        nonblock: i32,
    ) -> i32;
    pub fn sceNetAdhocPtpFlush(id: i32, timeout: u32, nonblock: i32) -> i32;
    pub fn sceNetAdhocPtpClose(id: i32, unk1: i32) -> i32;
    pub fn sceNetAdhocGetPtpStat(
        size: *mut i32,
        stat: *mut SceNetAdhocPtpStat,
    ) -> i32;
}

extern "C" {
    pub fn sceNetAdhocMatchingInit(memsize: i32) -> i32;
    pub fn sceNetAdhocMatchingTerm() -> i32;
    pub fn sceNetAdhocMatchingCreate(
        mode: AdhocMatchingMode,
        max_peers: i32,
        port: u16,
        buf_size: i32,
        hello_delay: u32,
        ping_delay: u32,
        init_count: i32,
        msg_delay: u32,
        callback: AdhocMatchingCallback,
    ) -> i32;
    pub fn sceNetAdhocMatchingDelete(matching_id: i32) -> i32;
    pub fn sceNetAdhocMatchingStart(
        matching_id: i32,
        evth_pri: i32,
        evth_stack: i32,
        inth_pri: i32,
        inth_stack: i32,
        opt_len: i32,
        opt_data: *mut c_void,
    ) -> i32;
    pub fn sceNetAdhocMatchingStop(matching_id: i32) -> i32;
    pub fn sceNetAdhocMatchingSelectTarget(
        matching_id: i32,
        mac: *mut u8,
        opt_len: i32,
        opt_data: *mut c_void,
    ) -> i32;
    pub fn sceNetAdhocMatchingCancelTarget(
        matching_id: i32,
        mac: *mut u8,
    ) -> i32;
    pub fn sceNetAdhocMatchingCancelTargetWithOpt(
        matching_id: i32,
        mac: *mut u8,
        opt_len: i32,
        opt_data: *mut c_void,
    ) -> i32;
    pub fn sceNetAdhocMatchingSendData(
        matching_id: i32,
        mac: *mut u8,
        data_len: i32,
        data: *mut c_void,
    ) -> i32;
    pub fn sceNetAdhocMatchingAbortSendData(
        matching_id: i32,
        mac: *mut u8,
    ) -> i32;
    pub fn sceNetAdhocMatchingSetHelloOpt(
        matching_id: i32,
        opt_len: i32,
        opt_data: *mut c_void,
    ) -> i32;
    pub fn sceNetAdhocMatchingGetHelloOpt(
        matching_id: i32,
        opt_len: *mut i32,
        opt_data: *mut c_void,
    ) -> i32;
    pub fn sceNetAdhocMatchingGetMembers(
        matching_id: i32,
        length: *mut i32,
        buf: *mut c_void,
    ) -> i32;
    pub fn sceNetAdhocMatchingGetPoolMaxAlloc() -> i32;
    pub fn sceNetAdhocMatchingGetPoolStat(poolstat: *mut AdhocPoolStat)
        -> i32;
}

extern "C" {
    pub fn sceNetApctlInit(stack_size: i32, init_priority: i32) -> i32;
    pub fn sceNetApctlTerm() -> i32;
    pub fn sceNetApctlGetInfo(
        code: ApctlInfo,
        pinfo: *mut SceNetApctlInfo,
    ) -> i32;
    pub fn sceNetApctlAddHandler(
        handler: SceNetApctlHandler,
        parg: *mut c_void,
    ) -> i32;
    pub fn sceNetApctlDelHandler(handler_id: i32) -> i32;
    pub fn sceNetApctlConnect(conn_index: i32) -> i32;
    pub fn sceNetApctlDisconnect() -> i32;
    pub fn sceNetApctlGetState(pstate: *mut ApctlState) -> i32;

    pub fn sceNetInetInit() -> i32;
    pub fn sceNetInetTerm() -> i32;
    pub fn sceNetInetAccept(
        s: i32,
        addr: *mut sockaddr,
        addr_len: *mut socklen_t,
    ) -> i32;
    pub fn sceNetInetBind(
        s: i32,
        my_addr: *const sockaddr,
        addr_len: socklen_t,
    ) -> i32;
    pub fn sceNetInetConnect(
        s: i32,
        serv_addr: *const sockaddr,
        addr_len: socklen_t,
    ) -> i32;
    pub fn sceNetInetGetsockopt(
        s: i32,
        level: i32,
        opt_name: i32,
        opt_val: *mut c_void,
        optl_en: *mut socklen_t,
    ) -> i32;
    pub fn sceNetInetListen(s: i32, backlog: i32) -> i32;
    pub fn sceNetInetRecv(
        s: i32,
        buf: *mut c_void,
        len: usize,
        flags: i32,
    ) -> usize;
    pub fn sceNetInetRecvfrom(
        s: i32,
        buf: *mut c_void,
        flags: usize,
        arg1: i32,
        from: *mut sockaddr,
        from_len: *mut socklen_t,
    ) -> usize;
    pub fn sceNetInetSend(
        s: i32,
        buf: *const c_void,
        len: usize,
        flags: i32,
    ) -> usize;
    pub fn sceNetInetSendto(
        s: i32,
        buf: *const c_void,
        len: usize,
        flags: i32,
        to: *const sockaddr,
        to_len: socklen_t,
    ) -> usize;
    pub fn sceNetInetSetsockopt(
        s: i32,
        level: i32,
        opt_name: i32,
        opt_val: *const c_void,
        opt_len: socklen_t,
    ) -> i32;
    pub fn sceNetInetShutdown(s: i32, how: i32) -> i32;
    pub fn sceNetInetSocket(domain: i32, type_: i32, protocol: i32) -> i32;
    pub fn sceNetInetClose(s: i32) -> i32;
    pub fn sceNetInetGetErrno() -> i32;

    pub fn sceSslInit(unknown1: i32) -> i32;
    pub fn sceSslEnd() -> i32;
    pub fn sceSslGetUsedMemoryMax(memory: *mut u32) -> i32;
    pub fn sceSslGetUsedMemoryCurrent(memory: *mut u32) -> i32;

    pub fn sceHttpInit(unknown1: u32) -> i32;
    pub fn sceHttpEnd() -> i32;
    pub fn sceHttpCreateTemplate(
        agent: *mut u8,
        unknown1: i32,
        unknown2: i32,
    ) -> i32;
    pub fn sceHttpDeleteTemplate(templateid: i32) -> i32;
    pub fn sceHttpCreateConnection(
        templateid: i32,
        host: *mut u8,
        unknown1: *mut u8,
        port: u16,
        unknown2: i32,
    ) -> i32;
    pub fn sceHttpCreateConnectionWithURL(
        templateid: i32,
        url: *const u8,
        unknown1: i32,
    ) -> i32;
    pub fn sceHttpDeleteConnection(connection_id: i32) -> i32;
    pub fn sceHttpCreateRequest(
        connection_id: i32,
        method: HttpMethod,
        path: *mut u8,
        content_length: u64,
    ) -> i32;
    pub fn sceHttpCreateRequestWithURL(
        connection_id: i32,
        method: HttpMethod,
        url: *mut u8,
        content_length: u64,
    ) -> i32;
    pub fn sceHttpDeleteRequest(request_id: i32) -> i32;
    pub fn sceHttpSendRequest(
        request_id: i32,
        data: *mut c_void,
        data_size: u32,
    ) -> i32;
    pub fn sceHttpAbortRequest(request_id: i32) -> i32;
    pub fn sceHttpReadData(
        request_id: i32,
        data: *mut c_void,
        data_size: u32,
    ) -> i32;
    pub fn sceHttpGetContentLength(
        request_id: i32,
        content_length: *mut u64,
    ) -> i32;
    pub fn sceHttpGetStatusCode(request_id: i32, status_code: *mut i32)
        -> i32;
    pub fn sceHttpSetResolveTimeOut(id: i32, timeout: u32) -> i32;
    pub fn sceHttpSetResolveRetry(id: i32, count: i32) -> i32;
    pub fn sceHttpSetConnectTimeOut(id: i32, timeout: u32) -> i32;
    pub fn sceHttpSetSendTimeOut(id: i32, timeout: u32) -> i32;
    pub fn sceHttpSetRecvTimeOut(id: i32, timeout: u32) -> i32;
    pub fn sceHttpEnableKeepAlive(id: i32) -> i32;
    pub fn sceHttpDisableKeepAlive(id: i32) -> i32;
    pub fn sceHttpEnableRedirect(id: i32) -> i32;
    pub fn sceHttpDisableRedirect(id: i32) -> i32;
    pub fn sceHttpEnableCookie(id: i32) -> i32;
    pub fn sceHttpDisableCookie(id: i32) -> i32;
    pub fn sceHttpSaveSystemCookie() -> i32;
    pub fn sceHttpLoadSystemCookie() -> i32;
    pub fn sceHttpAddExtraHeader(
        id: i32,
        name: *mut u8,
        value: *mut u8,
        unknown1: i32,
    ) -> i32;
    pub fn sceHttpDeleteHeader(id: i32, name: *const u8) -> i32;
    pub fn sceHttpsInit(
        unknown1: i32,
        unknown2: i32,
        unknown3: i32,
        unknown4: i32,
    ) -> i32;
    pub fn sceHttpsEnd() -> i32;
    pub fn sceHttpsLoadDefaultCert(unknown1: i32, unknown2: i32) -> i32;
    pub fn sceHttpDisableAuth(id: i32) -> i32;
    pub fn sceHttpDisableCache(id: i32) -> i32;
    pub fn sceHttpEnableAuth(id: i32) -> i32;
    pub fn sceHttpEnableCache(id: i32) -> i32;
    pub fn sceHttpEndCache() -> i32;
    pub fn sceHttpGetAllHeader(
        request: i32,
        header: *mut *mut u8,
        header_size: *mut u32,
    ) -> i32;
    pub fn sceHttpGetNetworkErrno(request: i32, err_num: *mut i32) -> i32;
    pub fn sceHttpGetProxy(
        id: i32,
        activate_flag: *mut i32,
        mode: *mut i32,
        proxy_host: *mut u8,
        len: usize,
        proxy_port: *mut u16,
    ) -> i32;
    pub fn sceHttpInitCache(max_size: usize) -> i32;
    pub fn sceHttpSetAuthInfoCB(id: i32, cbfunc: HttpPasswordCB) -> i32;
    pub fn sceHttpSetProxy(
        id: i32,
        activate_flag: i32,
        mode: i32,
        new_proxy_host: *const u8,
        new_proxy_port: u16,
    ) -> i32;
    pub fn sceHttpSetResHeaderMaxSize(id: i32, header_size: u32) -> i32;
    pub fn sceHttpSetMallocFunction(
        malloc_func: HttpMallocFunction,
        free_func: HttpFreeFunction,
        realloc_func: HttpReallocFunction,
    ) -> i32;

    pub fn sceNetResolverInit() -> i32;
    pub fn sceNetResolverCreate(
        rid: *mut i32,
        buf: *mut c_void,
        buf_length: u32,
    ) -> i32;
    pub fn sceNetResolverDelete(rid: i32) -> i32;
    pub fn sceNetResolverStartNtoA(
        rid: i32,
        hostname: *const u8,
        addr: *mut in_addr,
        timeout: u32,
        retry: i32,
    ) -> i32;
    pub fn sceNetResolverStartAtoN(
        rid: i32,
        addr: *const in_addr,
        hostname: *mut u8,
        hostname_len: u32,
        timeout: u32,
        retry: i32,
    ) -> i32;
    pub fn sceNetResolverStop(rid: i32) -> i32;
    pub fn sceNetResolverTerm() -> i32;
}