AutoProxyHelperVtbl

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct AutoProxyHelperVtbl
{
    public IntPtr IsResolvable;
    public IntPtr GetIPAddress;
    public IntPtr ResolveHostName;
    public IntPtr IsInNet;
    public IntPtr IsResolvableEx;
    public IntPtr GetIPAddressEx;
    public IntPtr ResolveHostNameEx;
    public IntPtr IsInNetEx;
    public IntPtr SortIpList;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure AutoProxyHelperVtbl
    Public IsResolvable As IntPtr
    Public GetIPAddress As IntPtr
    Public ResolveHostName As IntPtr
    Public IsInNet As IntPtr
    Public IsResolvableEx As IntPtr
    Public GetIPAddressEx As IntPtr
    Public ResolveHostNameEx As IntPtr
    Public IsInNetEx As IntPtr
    Public SortIpList As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class AutoProxyHelperVtbl(ctypes.Structure):
    _fields_ = [
        ("IsResolvable", ctypes.c_ssize_t),
        ("GetIPAddress", ctypes.c_ssize_t),
        ("ResolveHostName", ctypes.c_ssize_t),
        ("IsInNet", ctypes.c_ssize_t),
        ("IsResolvableEx", ctypes.c_ssize_t),
        ("GetIPAddressEx", ctypes.c_ssize_t),
        ("ResolveHostNameEx", ctypes.c_ssize_t),
        ("IsInNetEx", ctypes.c_ssize_t),
        ("SortIpList", ctypes.c_ssize_t),
    ]

#[repr(C)]
pub struct AutoProxyHelperVtbl {
    pub IsResolvable: isize,
    pub GetIPAddress: isize,
    pub ResolveHostName: isize,
    pub IsInNet: isize,
    pub IsResolvableEx: isize,
    pub GetIPAddressEx: isize,
    pub ResolveHostNameEx: isize,
    pub IsInNetEx: isize,
    pub SortIpList: isize,
}

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

type AutoProxyHelperVtbl struct {
	IsResolvable uintptr
	GetIPAddress uintptr
	ResolveHostName uintptr
	IsInNet uintptr
	IsResolvableEx uintptr
	GetIPAddressEx uintptr
	ResolveHostNameEx uintptr
	IsInNetEx uintptr
	SortIpList uintptr
}

type
  AutoProxyHelperVtbl = record
    IsResolvable: NativeInt;
    GetIPAddress: NativeInt;
    ResolveHostName: NativeInt;
    IsInNet: NativeInt;
    IsResolvableEx: NativeInt;
    GetIPAddressEx: NativeInt;
    ResolveHostNameEx: NativeInt;
    IsInNetEx: NativeInt;
    SortIpList: NativeInt;
  end;

const AutoProxyHelperVtbl = extern struct {
    IsResolvable: isize,
    GetIPAddress: isize,
    ResolveHostName: isize,
    IsInNet: isize,
    IsResolvableEx: isize,
    GetIPAddressEx: isize,
    ResolveHostNameEx: isize,
    IsInNetEx: isize,
    SortIpList: isize,
};

type
  AutoProxyHelperVtbl {.bycopy.} = object
    IsResolvable: int
    GetIPAddress: int
    ResolveHostName: int
    IsInNet: int
    IsResolvableEx: int
    GetIPAddressEx: int
    ResolveHostNameEx: int
    IsInNetEx: int
    SortIpList: int

struct AutoProxyHelperVtbl
{
    ptrdiff_t IsResolvable;
    ptrdiff_t GetIPAddress;
    ptrdiff_t ResolveHostName;
    ptrdiff_t IsInNet;
    ptrdiff_t IsResolvableEx;
    ptrdiff_t GetIPAddressEx;
    ptrdiff_t ResolveHostNameEx;
    ptrdiff_t IsInNetEx;
    ptrdiff_t SortIpList;
}