ACCESSRECTLIST

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct RECT
{
    public int left;
    public int top;
    public int right;
    public int bottom;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct ACCESSRECTLIST
{
    public IntPtr lpLink;
    public RECT rDest;
    public IntPtr lpOwner;
    public IntPtr lpSurfaceData;
    public uint dwFlags;
    public IntPtr lpHeapAliasInfo;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure RECT
    Public left As Integer
    Public top As Integer
    Public right As Integer
    Public bottom As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure ACCESSRECTLIST
    Public lpLink As IntPtr
    Public rDest As RECT
    Public lpOwner As IntPtr
    Public lpSurfaceData As IntPtr
    Public dwFlags As UInteger
    Public lpHeapAliasInfo As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class RECT(ctypes.Structure):
    _fields_ = [
        ("left", ctypes.c_int),
        ("top", ctypes.c_int),
        ("right", ctypes.c_int),
        ("bottom", ctypes.c_int),
    ]

class ACCESSRECTLIST(ctypes.Structure):
    _fields_ = [
        ("lpLink", ctypes.c_void_p),
        ("rDest", RECT),
        ("lpOwner", ctypes.c_void_p),
        ("lpSurfaceData", ctypes.c_void_p),
        ("dwFlags", wintypes.DWORD),
        ("lpHeapAliasInfo", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct RECT {
    pub left: i32,
    pub top: i32,
    pub right: i32,
    pub bottom: i32,
}

#[repr(C)]
pub struct ACCESSRECTLIST {
    pub lpLink: *mut core::ffi::c_void,
    pub rDest: RECT,
    pub lpOwner: *mut core::ffi::c_void,
    pub lpSurfaceData: *mut core::ffi::c_void,
    pub dwFlags: u32,
    pub lpHeapAliasInfo: *mut core::ffi::c_void,
}

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

type RECT struct {
	left int32
	top int32
	right int32
	bottom int32
}

type ACCESSRECTLIST struct {
	lpLink uintptr
	rDest RECT
	lpOwner uintptr
	lpSurfaceData uintptr
	dwFlags uint32
	lpHeapAliasInfo uintptr
}

type
  RECT = record
    left: Integer;
    top: Integer;
    right: Integer;
    bottom: Integer;
  end;

  ACCESSRECTLIST = record
    lpLink: Pointer;
    rDest: RECT;
    lpOwner: Pointer;
    lpSurfaceData: Pointer;
    dwFlags: DWORD;
    lpHeapAliasInfo: Pointer;
  end;

const RECT = extern struct {
    left: i32,
    top: i32,
    right: i32,
    bottom: i32,
};

const ACCESSRECTLIST = extern struct {
    lpLink: ?*anyopaque,
    rDest: RECT,
    lpOwner: ?*anyopaque,
    lpSurfaceData: ?*anyopaque,
    dwFlags: u32,
    lpHeapAliasInfo: ?*anyopaque,
};

type
  RECT {.bycopy.} = object
    left: int32
    top: int32
    right: int32
    bottom: int32

  ACCESSRECTLIST {.bycopy.} = object
    lpLink: pointer
    rDest: RECT
    lpOwner: pointer
    lpSurfaceData: pointer
    dwFlags: uint32
    lpHeapAliasInfo: pointer

struct RECT
{
    int left;
    int top;
    int right;
    int bottom;
}

struct ACCESSRECTLIST
{
    void* lpLink;
    RECT rDest;
    void* lpOwner;
    void* lpSurfaceData;
    uint dwFlags;
    void* lpHeapAliasInfo;
}