VMEMR

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct VMEMR
{
    public IntPtr next;
    public IntPtr prev;
    public IntPtr pUp;
    public IntPtr pDown;
    public IntPtr pLeft;
    public IntPtr pRight;
    public UIntPtr ptr;
    public uint size;
    public uint x;
    public uint y;
    public uint cx;
    public uint cy;
    public uint flags;
    public UIntPtr pBits;
    [MarshalAs(UnmanagedType.Bool)] public bool bDiscardable;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure VMEMR
    Public next As IntPtr
    Public prev As IntPtr
    Public pUp As IntPtr
    Public pDown As IntPtr
    Public pLeft As IntPtr
    Public pRight As IntPtr
    Public ptr As UIntPtr
    Public size As UInteger
    Public x As UInteger
    Public y As UInteger
    Public cx As UInteger
    Public cy As UInteger
    Public flags As UInteger
    Public pBits As UIntPtr
    <MarshalAs(UnmanagedType.Bool)> Public bDiscardable As Boolean
End Structure

import ctypes
from ctypes import wintypes

class VMEMR(ctypes.Structure):
    _fields_ = [
        ("next", ctypes.c_void_p),
        ("prev", ctypes.c_void_p),
        ("pUp", ctypes.c_void_p),
        ("pDown", ctypes.c_void_p),
        ("pLeft", ctypes.c_void_p),
        ("pRight", ctypes.c_void_p),
        ("ptr", ctypes.c_size_t),
        ("size", wintypes.DWORD),
        ("x", wintypes.DWORD),
        ("y", wintypes.DWORD),
        ("cx", wintypes.DWORD),
        ("cy", wintypes.DWORD),
        ("flags", wintypes.DWORD),
        ("pBits", ctypes.c_size_t),
        ("bDiscardable", wintypes.BOOL),
    ]

#[repr(C)]
pub struct VMEMR {
    pub next: *mut core::ffi::c_void,
    pub prev: *mut core::ffi::c_void,
    pub pUp: *mut core::ffi::c_void,
    pub pDown: *mut core::ffi::c_void,
    pub pLeft: *mut core::ffi::c_void,
    pub pRight: *mut core::ffi::c_void,
    pub ptr: usize,
    pub size: u32,
    pub x: u32,
    pub y: u32,
    pub cx: u32,
    pub cy: u32,
    pub flags: u32,
    pub pBits: usize,
    pub bDiscardable: i32,
}

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

type VMEMR struct {
	next uintptr
	prev uintptr
	pUp uintptr
	pDown uintptr
	pLeft uintptr
	pRight uintptr
	ptr uintptr
	size uint32
	x uint32
	y uint32
	cx uint32
	cy uint32
	flags uint32
	pBits uintptr
	bDiscardable int32
}

type
  VMEMR = record
    next: Pointer;
    prev: Pointer;
    pUp: Pointer;
    pDown: Pointer;
    pLeft: Pointer;
    pRight: Pointer;
    ptr: NativeUInt;
    size: DWORD;
    x: DWORD;
    y: DWORD;
    cx: DWORD;
    cy: DWORD;
    flags: DWORD;
    pBits: NativeUInt;
    bDiscardable: BOOL;
  end;

const VMEMR = extern struct {
    next: ?*anyopaque,
    prev: ?*anyopaque,
    pUp: ?*anyopaque,
    pDown: ?*anyopaque,
    pLeft: ?*anyopaque,
    pRight: ?*anyopaque,
    ptr: usize,
    size: u32,
    x: u32,
    y: u32,
    cx: u32,
    cy: u32,
    flags: u32,
    pBits: usize,
    bDiscardable: i32,
};

type
  VMEMR {.bycopy.} = object
    next: pointer
    prev: pointer
    pUp: pointer
    pDown: pointer
    pLeft: pointer
    pRight: pointer
    ptr: uint
    size: uint32
    x: uint32
    y: uint32
    cx: uint32
    cy: uint32
    flags: uint32
    pBits: uint
    bDiscardable: int32

struct VMEMR
{
    void* next;
    void* prev;
    void* pUp;
    void* pDown;
    void* pLeft;
    void* pRight;
    size_t ptr;
    uint size;
    uint x;
    uint y;
    uint cx;
    uint cy;
    uint flags;
    size_t pBits;
    int bDiscardable;
}