DedupChunk

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DedupHash
{
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] public byte[] Hash;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DedupChunk
{
    public DedupHash Hash;
    public int Flags;
    public uint LogicalSize;
    public uint DataSize;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DedupHash
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=32)> Public Hash() As Byte
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DedupChunk
    Public Hash As DedupHash
    Public Flags As Integer
    Public LogicalSize As UInteger
    Public DataSize As UInteger
End Structure

import ctypes
from ctypes import wintypes

class DedupHash(ctypes.Structure):
    _fields_ = [
        ("Hash", ctypes.c_ubyte * 32),
    ]

class DedupChunk(ctypes.Structure):
    _fields_ = [
        ("Hash", DedupHash),
        ("Flags", ctypes.c_int),
        ("LogicalSize", wintypes.DWORD),
        ("DataSize", wintypes.DWORD),
    ]

#[repr(C)]
pub struct DedupHash {
    pub Hash: [u8; 32],
}

#[repr(C)]
pub struct DedupChunk {
    pub Hash: DedupHash,
    pub Flags: i32,
    pub LogicalSize: u32,
    pub DataSize: u32,
}

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

type DedupHash struct {
	Hash [32]byte
}

type DedupChunk struct {
	Hash DedupHash
	Flags int32
	LogicalSize uint32
	DataSize uint32
}

type
  DedupHash = record
    Hash: array[0..31] of Byte;
  end;

  DedupChunk = record
    Hash: DedupHash;
    Flags: Integer;
    LogicalSize: DWORD;
    DataSize: DWORD;
  end;

const DedupHash = extern struct {
    Hash: [32]u8,
};

const DedupChunk = extern struct {
    Hash: DedupHash,
    Flags: i32,
    LogicalSize: u32,
    DataSize: u32,
};

type
  DedupHash {.bycopy.} = object
    Hash: array[32, uint8]

  DedupChunk {.bycopy.} = object
    Hash: DedupHash
    Flags: int32
    LogicalSize: uint32
    DataSize: uint32

struct DedupHash
{
    ubyte[32] Hash;
}

struct DedupChunk
{
    DedupHash Hash;
    int Flags;
    uint LogicalSize;
    uint DataSize;
}