STARTUPINFOEXA

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct STARTUPINFOA
{
    public uint cb;
    public IntPtr lpReserved;
    public IntPtr lpDesktop;
    public IntPtr lpTitle;
    public uint dwX;
    public uint dwY;
    public uint dwXSize;
    public uint dwYSize;
    public uint dwXCountChars;
    public uint dwYCountChars;
    public uint dwFillAttribute;
    public uint dwFlags;
    public ushort wShowWindow;
    public ushort cbReserved2;
    public IntPtr lpReserved2;
    public IntPtr hStdInput;
    public IntPtr hStdOutput;
    public IntPtr hStdError;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct STARTUPINFOEXA
{
    public STARTUPINFOA StartupInfo;
    public IntPtr lpAttributeList;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure STARTUPINFOA
    Public cb As UInteger
    Public lpReserved As IntPtr
    Public lpDesktop As IntPtr
    Public lpTitle As IntPtr
    Public dwX As UInteger
    Public dwY As UInteger
    Public dwXSize As UInteger
    Public dwYSize As UInteger
    Public dwXCountChars As UInteger
    Public dwYCountChars As UInteger
    Public dwFillAttribute As UInteger
    Public dwFlags As UInteger
    Public wShowWindow As UShort
    Public cbReserved2 As UShort
    Public lpReserved2 As IntPtr
    Public hStdInput As IntPtr
    Public hStdOutput As IntPtr
    Public hStdError As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure STARTUPINFOEXA
    Public StartupInfo As STARTUPINFOA
    Public lpAttributeList As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class STARTUPINFOA(ctypes.Structure):
    _fields_ = [
        ("cb", wintypes.DWORD),
        ("lpReserved", ctypes.c_void_p),
        ("lpDesktop", ctypes.c_void_p),
        ("lpTitle", ctypes.c_void_p),
        ("dwX", wintypes.DWORD),
        ("dwY", wintypes.DWORD),
        ("dwXSize", wintypes.DWORD),
        ("dwYSize", wintypes.DWORD),
        ("dwXCountChars", wintypes.DWORD),
        ("dwYCountChars", wintypes.DWORD),
        ("dwFillAttribute", wintypes.DWORD),
        ("dwFlags", wintypes.DWORD),
        ("wShowWindow", ctypes.c_ushort),
        ("cbReserved2", ctypes.c_ushort),
        ("lpReserved2", ctypes.c_void_p),
        ("hStdInput", ctypes.c_void_p),
        ("hStdOutput", ctypes.c_void_p),
        ("hStdError", ctypes.c_void_p),
    ]

class STARTUPINFOEXA(ctypes.Structure):
    _fields_ = [
        ("StartupInfo", STARTUPINFOA),
        ("lpAttributeList", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct STARTUPINFOA {
    pub cb: u32,
    pub lpReserved: *mut core::ffi::c_void,
    pub lpDesktop: *mut core::ffi::c_void,
    pub lpTitle: *mut core::ffi::c_void,
    pub dwX: u32,
    pub dwY: u32,
    pub dwXSize: u32,
    pub dwYSize: u32,
    pub dwXCountChars: u32,
    pub dwYCountChars: u32,
    pub dwFillAttribute: u32,
    pub dwFlags: u32,
    pub wShowWindow: u16,
    pub cbReserved2: u16,
    pub lpReserved2: *mut core::ffi::c_void,
    pub hStdInput: *mut core::ffi::c_void,
    pub hStdOutput: *mut core::ffi::c_void,
    pub hStdError: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct STARTUPINFOEXA {
    pub StartupInfo: STARTUPINFOA,
    pub lpAttributeList: *mut core::ffi::c_void,
}

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

type STARTUPINFOA struct {
	cb uint32
	lpReserved uintptr
	lpDesktop uintptr
	lpTitle uintptr
	dwX uint32
	dwY uint32
	dwXSize uint32
	dwYSize uint32
	dwXCountChars uint32
	dwYCountChars uint32
	dwFillAttribute uint32
	dwFlags uint32
	wShowWindow uint16
	cbReserved2 uint16
	lpReserved2 uintptr
	hStdInput uintptr
	hStdOutput uintptr
	hStdError uintptr
}

type STARTUPINFOEXA struct {
	StartupInfo STARTUPINFOA
	lpAttributeList uintptr
}

type
  STARTUPINFOA = record
    cb: DWORD;
    lpReserved: Pointer;
    lpDesktop: Pointer;
    lpTitle: Pointer;
    dwX: DWORD;
    dwY: DWORD;
    dwXSize: DWORD;
    dwYSize: DWORD;
    dwXCountChars: DWORD;
    dwYCountChars: DWORD;
    dwFillAttribute: DWORD;
    dwFlags: DWORD;
    wShowWindow: Word;
    cbReserved2: Word;
    lpReserved2: Pointer;
    hStdInput: Pointer;
    hStdOutput: Pointer;
    hStdError: Pointer;
  end;

  STARTUPINFOEXA = record
    StartupInfo: STARTUPINFOA;
    lpAttributeList: Pointer;
  end;

const STARTUPINFOA = extern struct {
    cb: u32,
    lpReserved: ?*anyopaque,
    lpDesktop: ?*anyopaque,
    lpTitle: ?*anyopaque,
    dwX: u32,
    dwY: u32,
    dwXSize: u32,
    dwYSize: u32,
    dwXCountChars: u32,
    dwYCountChars: u32,
    dwFillAttribute: u32,
    dwFlags: u32,
    wShowWindow: u16,
    cbReserved2: u16,
    lpReserved2: ?*anyopaque,
    hStdInput: ?*anyopaque,
    hStdOutput: ?*anyopaque,
    hStdError: ?*anyopaque,
};

const STARTUPINFOEXA = extern struct {
    StartupInfo: STARTUPINFOA,
    lpAttributeList: ?*anyopaque,
};

type
  STARTUPINFOA {.bycopy.} = object
    cb: uint32
    lpReserved: pointer
    lpDesktop: pointer
    lpTitle: pointer
    dwX: uint32
    dwY: uint32
    dwXSize: uint32
    dwYSize: uint32
    dwXCountChars: uint32
    dwYCountChars: uint32
    dwFillAttribute: uint32
    dwFlags: uint32
    wShowWindow: uint16
    cbReserved2: uint16
    lpReserved2: pointer
    hStdInput: pointer
    hStdOutput: pointer
    hStdError: pointer

  STARTUPINFOEXA {.bycopy.} = object
    StartupInfo: STARTUPINFOA
    lpAttributeList: pointer

struct STARTUPINFOA
{
    uint cb;
    void* lpReserved;
    void* lpDesktop;
    void* lpTitle;
    uint dwX;
    uint dwY;
    uint dwXSize;
    uint dwYSize;
    uint dwXCountChars;
    uint dwYCountChars;
    uint dwFillAttribute;
    uint dwFlags;
    ushort wShowWindow;
    ushort cbReserved2;
    void* lpReserved2;
    void* hStdInput;
    void* hStdOutput;
    void* hStdError;
}

struct STARTUPINFOEXA
{
    STARTUPINFOA StartupInfo;
    void* lpAttributeList;
}