PSS_AUXILIARY_PAGE_ENTRY

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MEMORY_BASIC_INFORMATION
{
    public IntPtr BaseAddress;
    public IntPtr AllocationBase;
    public uint AllocationProtect;
    public ushort PartitionId;
    public UIntPtr RegionSize;
    public uint State;
    public uint Protect;
    public uint Type;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct FILETIME
{
    public uint dwLowDateTime;
    public uint dwHighDateTime;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct PSS_AUXILIARY_PAGE_ENTRY
{
    public IntPtr Address;
    public MEMORY_BASIC_INFORMATION BasicInformation;
    public FILETIME CaptureTime;
    public IntPtr PageContents;
    public uint PageSize;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MEMORY_BASIC_INFORMATION
    Public BaseAddress As IntPtr
    Public AllocationBase As IntPtr
    Public AllocationProtect As UInteger
    Public PartitionId As UShort
    Public RegionSize As UIntPtr
    Public State As UInteger
    Public Protect As UInteger
    Public Type As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure FILETIME
    Public dwLowDateTime As UInteger
    Public dwHighDateTime As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure PSS_AUXILIARY_PAGE_ENTRY
    Public Address As IntPtr
    Public BasicInformation As MEMORY_BASIC_INFORMATION
    Public CaptureTime As FILETIME
    Public PageContents As IntPtr
    Public PageSize As UInteger
End Structure

import ctypes
from ctypes import wintypes

class MEMORY_BASIC_INFORMATION(ctypes.Structure):
    _fields_ = [
        ("BaseAddress", ctypes.c_void_p),
        ("AllocationBase", ctypes.c_void_p),
        ("AllocationProtect", wintypes.DWORD),
        ("PartitionId", ctypes.c_ushort),
        ("RegionSize", ctypes.c_size_t),
        ("State", wintypes.DWORD),
        ("Protect", wintypes.DWORD),
        ("Type", wintypes.DWORD),
    ]

class FILETIME(ctypes.Structure):
    _fields_ = [
        ("dwLowDateTime", wintypes.DWORD),
        ("dwHighDateTime", wintypes.DWORD),
    ]

class PSS_AUXILIARY_PAGE_ENTRY(ctypes.Structure):
    _fields_ = [
        ("Address", ctypes.c_void_p),
        ("BasicInformation", MEMORY_BASIC_INFORMATION),
        ("CaptureTime", FILETIME),
        ("PageContents", ctypes.c_void_p),
        ("PageSize", wintypes.DWORD),
    ]

#[repr(C)]
pub struct MEMORY_BASIC_INFORMATION {
    pub BaseAddress: *mut core::ffi::c_void,
    pub AllocationBase: *mut core::ffi::c_void,
    pub AllocationProtect: u32,
    pub PartitionId: u16,
    pub RegionSize: usize,
    pub State: u32,
    pub Protect: u32,
    pub Type: u32,
}

#[repr(C)]
pub struct FILETIME {
    pub dwLowDateTime: u32,
    pub dwHighDateTime: u32,
}

#[repr(C)]
pub struct PSS_AUXILIARY_PAGE_ENTRY {
    pub Address: *mut core::ffi::c_void,
    pub BasicInformation: MEMORY_BASIC_INFORMATION,
    pub CaptureTime: FILETIME,
    pub PageContents: *mut core::ffi::c_void,
    pub PageSize: u32,
}

import "golang.org/x/sys/windows"

type MEMORY_BASIC_INFORMATION struct {
	BaseAddress uintptr
	AllocationBase uintptr
	AllocationProtect uint32
	PartitionId uint16
	RegionSize uintptr
	State uint32
	Protect uint32
	Type uint32
}

type FILETIME struct {
	dwLowDateTime uint32
	dwHighDateTime uint32
}

type PSS_AUXILIARY_PAGE_ENTRY struct {
	Address uintptr
	BasicInformation MEMORY_BASIC_INFORMATION
	CaptureTime FILETIME
	PageContents uintptr
	PageSize uint32
}

type
  MEMORY_BASIC_INFORMATION = record
    BaseAddress: Pointer;
    AllocationBase: Pointer;
    AllocationProtect: DWORD;
    PartitionId: Word;
    RegionSize: NativeUInt;
    State: DWORD;
    Protect: DWORD;
    Type: DWORD;
  end;

  FILETIME = record
    dwLowDateTime: DWORD;
    dwHighDateTime: DWORD;
  end;

  PSS_AUXILIARY_PAGE_ENTRY = record
    Address: Pointer;
    BasicInformation: MEMORY_BASIC_INFORMATION;
    CaptureTime: FILETIME;
    PageContents: Pointer;
    PageSize: DWORD;
  end;

const MEMORY_BASIC_INFORMATION = extern struct {
    BaseAddress: ?*anyopaque,
    AllocationBase: ?*anyopaque,
    AllocationProtect: u32,
    PartitionId: u16,
    RegionSize: usize,
    State: u32,
    Protect: u32,
    Type: u32,
};

const FILETIME = extern struct {
    dwLowDateTime: u32,
    dwHighDateTime: u32,
};

const PSS_AUXILIARY_PAGE_ENTRY = extern struct {
    Address: ?*anyopaque,
    BasicInformation: MEMORY_BASIC_INFORMATION,
    CaptureTime: FILETIME,
    PageContents: ?*anyopaque,
    PageSize: u32,
};

type
  MEMORY_BASIC_INFORMATION {.bycopy.} = object
    BaseAddress: pointer
    AllocationBase: pointer
    AllocationProtect: uint32
    PartitionId: uint16
    RegionSize: uint
    State: uint32
    Protect: uint32
    Type: uint32

  FILETIME {.bycopy.} = object
    dwLowDateTime: uint32
    dwHighDateTime: uint32

  PSS_AUXILIARY_PAGE_ENTRY {.bycopy.} = object
    Address: pointer
    BasicInformation: MEMORY_BASIC_INFORMATION
    CaptureTime: FILETIME
    PageContents: pointer
    PageSize: uint32

struct MEMORY_BASIC_INFORMATION
{
    void* BaseAddress;
    void* AllocationBase;
    uint AllocationProtect;
    ushort PartitionId;
    size_t RegionSize;
    uint State;
    uint Protect;
    uint Type;
}

struct FILETIME
{
    uint dwLowDateTime;
    uint dwHighDateTime;
}

struct PSS_AUXILIARY_PAGE_ENTRY
{
    void* Address;
    MEMORY_BASIC_INFORMATION BasicInformation;
    FILETIME CaptureTime;
    void* PageContents;
    uint PageSize;
}