LOADED_IMAGE

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct LIST_ENTRY
{
    public IntPtr Flink;
    public IntPtr Blink;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct LOADED_IMAGE
{
    public IntPtr ModuleName;
    public IntPtr hFile;
    public IntPtr MappedAddress;
    public IntPtr FileHeader;
    public IntPtr LastRvaSection;
    public uint NumberOfSections;
    public IntPtr Sections;
    public uint Characteristics;
    [MarshalAs(UnmanagedType.U1)] public bool fSystemImage;
    [MarshalAs(UnmanagedType.U1)] public bool fDOSImage;
    [MarshalAs(UnmanagedType.U1)] public bool fReadOnly;
    public byte Version;
    public LIST_ENTRY Links;
    public uint SizeOfImage;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure LIST_ENTRY
    Public Flink As IntPtr
    Public Blink As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure LOADED_IMAGE
    Public ModuleName As IntPtr
    Public hFile As IntPtr
    Public MappedAddress As IntPtr
    Public FileHeader As IntPtr
    Public LastRvaSection As IntPtr
    Public NumberOfSections As UInteger
    Public Sections As IntPtr
    Public Characteristics As UInteger
    <MarshalAs(UnmanagedType.U1)> Public fSystemImage As Boolean
    <MarshalAs(UnmanagedType.U1)> Public fDOSImage As Boolean
    <MarshalAs(UnmanagedType.U1)> Public fReadOnly As Boolean
    Public Version As Byte
    Public Links As LIST_ENTRY
    Public SizeOfImage As UInteger
End Structure

import ctypes
from ctypes import wintypes

class LIST_ENTRY(ctypes.Structure):
    _fields_ = [
        ("Flink", ctypes.c_void_p),
        ("Blink", ctypes.c_void_p),
    ]

class LOADED_IMAGE(ctypes.Structure):
    _fields_ = [
        ("ModuleName", ctypes.c_void_p),
        ("hFile", ctypes.c_void_p),
        ("MappedAddress", ctypes.c_void_p),
        ("FileHeader", ctypes.c_void_p),
        ("LastRvaSection", ctypes.c_void_p),
        ("NumberOfSections", wintypes.DWORD),
        ("Sections", ctypes.c_void_p),
        ("Characteristics", wintypes.DWORD),
        ("fSystemImage", ctypes.c_byte),
        ("fDOSImage", ctypes.c_byte),
        ("fReadOnly", ctypes.c_byte),
        ("Version", ctypes.c_ubyte),
        ("Links", LIST_ENTRY),
        ("SizeOfImage", wintypes.DWORD),
    ]

#[repr(C)]
pub struct LIST_ENTRY {
    pub Flink: *mut core::ffi::c_void,
    pub Blink: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct LOADED_IMAGE {
    pub ModuleName: *mut core::ffi::c_void,
    pub hFile: *mut core::ffi::c_void,
    pub MappedAddress: *mut core::ffi::c_void,
    pub FileHeader: *mut core::ffi::c_void,
    pub LastRvaSection: *mut core::ffi::c_void,
    pub NumberOfSections: u32,
    pub Sections: *mut core::ffi::c_void,
    pub Characteristics: u32,
    pub fSystemImage: u8,
    pub fDOSImage: u8,
    pub fReadOnly: u8,
    pub Version: u8,
    pub Links: LIST_ENTRY,
    pub SizeOfImage: u32,
}

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

type LIST_ENTRY struct {
	Flink uintptr
	Blink uintptr
}

type LOADED_IMAGE struct {
	ModuleName uintptr
	hFile uintptr
	MappedAddress uintptr
	FileHeader uintptr
	LastRvaSection uintptr
	NumberOfSections uint32
	Sections uintptr
	Characteristics uint32
	fSystemImage byte
	fDOSImage byte
	fReadOnly byte
	Version byte
	Links LIST_ENTRY
	SizeOfImage uint32
}

type
  LIST_ENTRY = record
    Flink: Pointer;
    Blink: Pointer;
  end;

  LOADED_IMAGE = record
    ModuleName: Pointer;
    hFile: Pointer;
    MappedAddress: Pointer;
    FileHeader: Pointer;
    LastRvaSection: Pointer;
    NumberOfSections: DWORD;
    Sections: Pointer;
    Characteristics: DWORD;
    fSystemImage: ByteBool;
    fDOSImage: ByteBool;
    fReadOnly: ByteBool;
    Version: Byte;
    Links: LIST_ENTRY;
    SizeOfImage: DWORD;
  end;

const LIST_ENTRY = extern struct {
    Flink: ?*anyopaque,
    Blink: ?*anyopaque,
};

const LOADED_IMAGE = extern struct {
    ModuleName: ?*anyopaque,
    hFile: ?*anyopaque,
    MappedAddress: ?*anyopaque,
    FileHeader: ?*anyopaque,
    LastRvaSection: ?*anyopaque,
    NumberOfSections: u32,
    Sections: ?*anyopaque,
    Characteristics: u32,
    fSystemImage: u8,
    fDOSImage: u8,
    fReadOnly: u8,
    Version: u8,
    Links: LIST_ENTRY,
    SizeOfImage: u32,
};

type
  LIST_ENTRY {.bycopy.} = object
    Flink: pointer
    Blink: pointer

  LOADED_IMAGE {.bycopy.} = object
    ModuleName: pointer
    hFile: pointer
    MappedAddress: pointer
    FileHeader: pointer
    LastRvaSection: pointer
    NumberOfSections: uint32
    Sections: pointer
    Characteristics: uint32
    fSystemImage: uint8
    fDOSImage: uint8
    fReadOnly: uint8
    Version: uint8
    Links: LIST_ENTRY
    SizeOfImage: uint32

struct LIST_ENTRY
{
    void* Flink;
    void* Blink;
}

struct LOADED_IMAGE
{
    void* ModuleName;
    void* hFile;
    void* MappedAddress;
    void* FileHeader;
    void* LastRvaSection;
    uint NumberOfSections;
    void* Sections;
    uint Characteristics;
    ubyte fSystemImage;
    ubyte fDOSImage;
    ubyte fReadOnly;
    ubyte Version;
    LIST_ENTRY Links;
    uint SizeOfImage;
}