SYSTEM_PROCESS_INFORMATION

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct UNICODE_STRING
{
    public ushort Length;
    public ushort MaximumLength;
    public IntPtr Buffer;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SYSTEM_PROCESS_INFORMATION
{
    public uint NextEntryOffset;
    public uint NumberOfThreads;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 48)] public byte[] Reserved1;
    public UNICODE_STRING ImageName;
    public int BasePriority;
    public IntPtr UniqueProcessId;
    public IntPtr Reserved2;
    public uint HandleCount;
    public uint SessionId;
    public IntPtr Reserved3;
    public UIntPtr PeakVirtualSize;
    public UIntPtr VirtualSize;
    public uint Reserved4;
    public UIntPtr PeakWorkingSetSize;
    public UIntPtr WorkingSetSize;
    public IntPtr Reserved5;
    public UIntPtr QuotaPagedPoolUsage;
    public IntPtr Reserved6;
    public UIntPtr QuotaNonPagedPoolUsage;
    public UIntPtr PagefileUsage;
    public UIntPtr PeakPagefileUsage;
    public UIntPtr PrivatePageCount;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)] public long[] Reserved7;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure UNICODE_STRING
    Public Length As UShort
    Public MaximumLength As UShort
    Public Buffer As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SYSTEM_PROCESS_INFORMATION
    Public NextEntryOffset As UInteger
    Public NumberOfThreads As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=48)> Public Reserved1() As Byte
    Public ImageName As UNICODE_STRING
    Public BasePriority As Integer
    Public UniqueProcessId As IntPtr
    Public Reserved2 As IntPtr
    Public HandleCount As UInteger
    Public SessionId As UInteger
    Public Reserved3 As IntPtr
    Public PeakVirtualSize As UIntPtr
    Public VirtualSize As UIntPtr
    Public Reserved4 As UInteger
    Public PeakWorkingSetSize As UIntPtr
    Public WorkingSetSize As UIntPtr
    Public Reserved5 As IntPtr
    Public QuotaPagedPoolUsage As UIntPtr
    Public Reserved6 As IntPtr
    Public QuotaNonPagedPoolUsage As UIntPtr
    Public PagefileUsage As UIntPtr
    Public PeakPagefileUsage As UIntPtr
    Public PrivatePageCount As UIntPtr
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=6)> Public Reserved7() As Long
End Structure

import ctypes
from ctypes import wintypes

class UNICODE_STRING(ctypes.Structure):
    _fields_ = [
        ("Length", ctypes.c_ushort),
        ("MaximumLength", ctypes.c_ushort),
        ("Buffer", ctypes.c_void_p),
    ]

class SYSTEM_PROCESS_INFORMATION(ctypes.Structure):
    _fields_ = [
        ("NextEntryOffset", wintypes.DWORD),
        ("NumberOfThreads", wintypes.DWORD),
        ("Reserved1", ctypes.c_ubyte * 48),
        ("ImageName", UNICODE_STRING),
        ("BasePriority", ctypes.c_int),
        ("UniqueProcessId", ctypes.c_void_p),
        ("Reserved2", ctypes.c_void_p),
        ("HandleCount", wintypes.DWORD),
        ("SessionId", wintypes.DWORD),
        ("Reserved3", ctypes.c_void_p),
        ("PeakVirtualSize", ctypes.c_size_t),
        ("VirtualSize", ctypes.c_size_t),
        ("Reserved4", wintypes.DWORD),
        ("PeakWorkingSetSize", ctypes.c_size_t),
        ("WorkingSetSize", ctypes.c_size_t),
        ("Reserved5", ctypes.c_void_p),
        ("QuotaPagedPoolUsage", ctypes.c_size_t),
        ("Reserved6", ctypes.c_void_p),
        ("QuotaNonPagedPoolUsage", ctypes.c_size_t),
        ("PagefileUsage", ctypes.c_size_t),
        ("PeakPagefileUsage", ctypes.c_size_t),
        ("PrivatePageCount", ctypes.c_size_t),
        ("Reserved7", ctypes.c_longlong * 6),
    ]

#[repr(C)]
pub struct UNICODE_STRING {
    pub Length: u16,
    pub MaximumLength: u16,
    pub Buffer: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct SYSTEM_PROCESS_INFORMATION {
    pub NextEntryOffset: u32,
    pub NumberOfThreads: u32,
    pub Reserved1: [u8; 48],
    pub ImageName: UNICODE_STRING,
    pub BasePriority: i32,
    pub UniqueProcessId: *mut core::ffi::c_void,
    pub Reserved2: *mut core::ffi::c_void,
    pub HandleCount: u32,
    pub SessionId: u32,
    pub Reserved3: *mut core::ffi::c_void,
    pub PeakVirtualSize: usize,
    pub VirtualSize: usize,
    pub Reserved4: u32,
    pub PeakWorkingSetSize: usize,
    pub WorkingSetSize: usize,
    pub Reserved5: *mut core::ffi::c_void,
    pub QuotaPagedPoolUsage: usize,
    pub Reserved6: *mut core::ffi::c_void,
    pub QuotaNonPagedPoolUsage: usize,
    pub PagefileUsage: usize,
    pub PeakPagefileUsage: usize,
    pub PrivatePageCount: usize,
    pub Reserved7: [i64; 6],
}

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

type UNICODE_STRING struct {
	Length uint16
	MaximumLength uint16
	Buffer uintptr
}

type SYSTEM_PROCESS_INFORMATION struct {
	NextEntryOffset uint32
	NumberOfThreads uint32
	Reserved1 [48]byte
	ImageName UNICODE_STRING
	BasePriority int32
	UniqueProcessId uintptr
	Reserved2 uintptr
	HandleCount uint32
	SessionId uint32
	Reserved3 uintptr
	PeakVirtualSize uintptr
	VirtualSize uintptr
	Reserved4 uint32
	PeakWorkingSetSize uintptr
	WorkingSetSize uintptr
	Reserved5 uintptr
	QuotaPagedPoolUsage uintptr
	Reserved6 uintptr
	QuotaNonPagedPoolUsage uintptr
	PagefileUsage uintptr
	PeakPagefileUsage uintptr
	PrivatePageCount uintptr
	Reserved7 [6]int64
}

type
  UNICODE_STRING = record
    Length: Word;
    MaximumLength: Word;
    Buffer: Pointer;
  end;

  SYSTEM_PROCESS_INFORMATION = record
    NextEntryOffset: DWORD;
    NumberOfThreads: DWORD;
    Reserved1: array[0..47] of Byte;
    ImageName: UNICODE_STRING;
    BasePriority: Integer;
    UniqueProcessId: Pointer;
    Reserved2: Pointer;
    HandleCount: DWORD;
    SessionId: DWORD;
    Reserved3: Pointer;
    PeakVirtualSize: NativeUInt;
    VirtualSize: NativeUInt;
    Reserved4: DWORD;
    PeakWorkingSetSize: NativeUInt;
    WorkingSetSize: NativeUInt;
    Reserved5: Pointer;
    QuotaPagedPoolUsage: NativeUInt;
    Reserved6: Pointer;
    QuotaNonPagedPoolUsage: NativeUInt;
    PagefileUsage: NativeUInt;
    PeakPagefileUsage: NativeUInt;
    PrivatePageCount: NativeUInt;
    Reserved7: array[0..5] of Int64;
  end;

const UNICODE_STRING = extern struct {
    Length: u16,
    MaximumLength: u16,
    Buffer: ?*anyopaque,
};

const SYSTEM_PROCESS_INFORMATION = extern struct {
    NextEntryOffset: u32,
    NumberOfThreads: u32,
    Reserved1: [48]u8,
    ImageName: UNICODE_STRING,
    BasePriority: i32,
    UniqueProcessId: ?*anyopaque,
    Reserved2: ?*anyopaque,
    HandleCount: u32,
    SessionId: u32,
    Reserved3: ?*anyopaque,
    PeakVirtualSize: usize,
    VirtualSize: usize,
    Reserved4: u32,
    PeakWorkingSetSize: usize,
    WorkingSetSize: usize,
    Reserved5: ?*anyopaque,
    QuotaPagedPoolUsage: usize,
    Reserved6: ?*anyopaque,
    QuotaNonPagedPoolUsage: usize,
    PagefileUsage: usize,
    PeakPagefileUsage: usize,
    PrivatePageCount: usize,
    Reserved7: [6]i64,
};

type
  UNICODE_STRING {.bycopy.} = object
    Length: uint16
    MaximumLength: uint16
    Buffer: pointer

  SYSTEM_PROCESS_INFORMATION {.bycopy.} = object
    NextEntryOffset: uint32
    NumberOfThreads: uint32
    Reserved1: array[48, uint8]
    ImageName: UNICODE_STRING
    BasePriority: int32
    UniqueProcessId: pointer
    Reserved2: pointer
    HandleCount: uint32
    SessionId: uint32
    Reserved3: pointer
    PeakVirtualSize: uint
    VirtualSize: uint
    Reserved4: uint32
    PeakWorkingSetSize: uint
    WorkingSetSize: uint
    Reserved5: pointer
    QuotaPagedPoolUsage: uint
    Reserved6: pointer
    QuotaNonPagedPoolUsage: uint
    PagefileUsage: uint
    PeakPagefileUsage: uint
    PrivatePageCount: uint
    Reserved7: array[6, int64]

struct UNICODE_STRING
{
    ushort Length;
    ushort MaximumLength;
    void* Buffer;
}

struct SYSTEM_PROCESS_INFORMATION
{
    uint NextEntryOffset;
    uint NumberOfThreads;
    ubyte[48] Reserved1;
    UNICODE_STRING ImageName;
    int BasePriority;
    void* UniqueProcessId;
    void* Reserved2;
    uint HandleCount;
    uint SessionId;
    void* Reserved3;
    size_t PeakVirtualSize;
    size_t VirtualSize;
    uint Reserved4;
    size_t PeakWorkingSetSize;
    size_t WorkingSetSize;
    void* Reserved5;
    size_t QuotaPagedPoolUsage;
    void* Reserved6;
    size_t QuotaNonPagedPoolUsage;
    size_t PagefileUsage;
    size_t PeakPagefileUsage;
    size_t PrivatePageCount;
    long[6] Reserved7;
}