// WARNING: This file is machine generated by fidlgen.

// fidl_experiment = output_index_json

#include <test/padding/cpp/fidl.h>

#include "lib/fidl/cpp/internal/implementation.h"

//
// Domain objects definitions
//
namespace test {
namespace padding {

extern "C" const fidl_type_t test_padding_Padding1ByteEndTable;
const fidl_type_t* Padding1ByteEnd::FidlType = &test_padding_Padding1ByteEndTable;

void Padding1ByteEnd::Encode(::fidl::Encoder* _encoder, size_t _offset,
                             cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
  if (::fidl::IsMemcpyCompatible<Padding1ByteEnd>::value) {
    memcpy(_encoder->template GetPtr<Padding1ByteEnd>(_offset), this, sizeof(Padding1ByteEnd));
  } else {
    ::fidl::Encode(_encoder, &a, _offset + 0);
    ::fidl::Encode(_encoder, &b, _offset + 2);
  }
}

void Padding1ByteEnd::Decode(::fidl::Decoder* _decoder, Padding1ByteEnd* _value, size_t _offset) {
  if (::fidl::IsMemcpyCompatible<Padding1ByteEnd>::value) {
    memcpy(_value, _decoder->template GetPtr<Padding1ByteEnd>(_offset), sizeof(Padding1ByteEnd));
  } else {
    ::fidl::Decode(_decoder, &_value->a, _offset + 0);
    ::fidl::Decode(_decoder, &_value->b, _offset + 2);
  }
}

zx_status_t Padding1ByteEnd::Clone(Padding1ByteEnd* _result) const {
  zx_status_t _status = ::fidl::Clone(a, &_result->a);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(b, &_result->b);
  if (_status != ZX_OK)
    return _status;
  return ZX_OK;
}

extern "C" const fidl_type_t test_padding_Padding2ByteEndTable;
const fidl_type_t* Padding2ByteEnd::FidlType = &test_padding_Padding2ByteEndTable;

void Padding2ByteEnd::Encode(::fidl::Encoder* _encoder, size_t _offset,
                             cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
  if (::fidl::IsMemcpyCompatible<Padding2ByteEnd>::value) {
    memcpy(_encoder->template GetPtr<Padding2ByteEnd>(_offset), this, sizeof(Padding2ByteEnd));
  } else {
    ::fidl::Encode(_encoder, &a, _offset + 0);
    ::fidl::Encode(_encoder, &b, _offset + 4);
  }
}

void Padding2ByteEnd::Decode(::fidl::Decoder* _decoder, Padding2ByteEnd* _value, size_t _offset) {
  if (::fidl::IsMemcpyCompatible<Padding2ByteEnd>::value) {
    memcpy(_value, _decoder->template GetPtr<Padding2ByteEnd>(_offset), sizeof(Padding2ByteEnd));
  } else {
    ::fidl::Decode(_decoder, &_value->a, _offset + 0);
    ::fidl::Decode(_decoder, &_value->b, _offset + 4);
  }
}

zx_status_t Padding2ByteEnd::Clone(Padding2ByteEnd* _result) const {
  zx_status_t _status = ::fidl::Clone(a, &_result->a);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(b, &_result->b);
  if (_status != ZX_OK)
    return _status;
  return ZX_OK;
}

extern "C" const fidl_type_t test_padding_Padding3ByteEndTable;
const fidl_type_t* Padding3ByteEnd::FidlType = &test_padding_Padding3ByteEndTable;

void Padding3ByteEnd::Encode(::fidl::Encoder* _encoder, size_t _offset,
                             cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
  if (::fidl::IsMemcpyCompatible<Padding3ByteEnd>::value) {
    memcpy(_encoder->template GetPtr<Padding3ByteEnd>(_offset), this, sizeof(Padding3ByteEnd));
  } else {
    ::fidl::Encode(_encoder, &a, _offset + 0);
    ::fidl::Encode(_encoder, &b, _offset + 4);
  }
}

void Padding3ByteEnd::Decode(::fidl::Decoder* _decoder, Padding3ByteEnd* _value, size_t _offset) {
  if (::fidl::IsMemcpyCompatible<Padding3ByteEnd>::value) {
    memcpy(_value, _decoder->template GetPtr<Padding3ByteEnd>(_offset), sizeof(Padding3ByteEnd));
  } else {
    ::fidl::Decode(_decoder, &_value->a, _offset + 0);
    ::fidl::Decode(_decoder, &_value->b, _offset + 4);
  }
}

zx_status_t Padding3ByteEnd::Clone(Padding3ByteEnd* _result) const {
  zx_status_t _status = ::fidl::Clone(a, &_result->a);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(b, &_result->b);
  if (_status != ZX_OK)
    return _status;
  return ZX_OK;
}

extern "C" const fidl_type_t test_padding_Padding4ByteEndTable;
const fidl_type_t* Padding4ByteEnd::FidlType = &test_padding_Padding4ByteEndTable;

void Padding4ByteEnd::Encode(::fidl::Encoder* _encoder, size_t _offset,
                             cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
  if (::fidl::IsMemcpyCompatible<Padding4ByteEnd>::value) {
    memcpy(_encoder->template GetPtr<Padding4ByteEnd>(_offset), this, sizeof(Padding4ByteEnd));
  } else {
    ::fidl::Encode(_encoder, &a, _offset + 0);
    ::fidl::Encode(_encoder, &b, _offset + 8);
  }
}

void Padding4ByteEnd::Decode(::fidl::Decoder* _decoder, Padding4ByteEnd* _value, size_t _offset) {
  if (::fidl::IsMemcpyCompatible<Padding4ByteEnd>::value) {
    memcpy(_value, _decoder->template GetPtr<Padding4ByteEnd>(_offset), sizeof(Padding4ByteEnd));
  } else {
    ::fidl::Decode(_decoder, &_value->a, _offset + 0);
    ::fidl::Decode(_decoder, &_value->b, _offset + 8);
  }
}

zx_status_t Padding4ByteEnd::Clone(Padding4ByteEnd* _result) const {
  zx_status_t _status = ::fidl::Clone(a, &_result->a);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(b, &_result->b);
  if (_status != ZX_OK)
    return _status;
  return ZX_OK;
}

extern "C" const fidl_type_t test_padding_Padding5ByteEndTable;
const fidl_type_t* Padding5ByteEnd::FidlType = &test_padding_Padding5ByteEndTable;

void Padding5ByteEnd::Encode(::fidl::Encoder* _encoder, size_t _offset,
                             cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
  if (::fidl::IsMemcpyCompatible<Padding5ByteEnd>::value) {
    memcpy(_encoder->template GetPtr<Padding5ByteEnd>(_offset), this, sizeof(Padding5ByteEnd));
  } else {
    ::fidl::Encode(_encoder, &a, _offset + 0);
    ::fidl::Encode(_encoder, &b, _offset + 8);
    ::fidl::Encode(_encoder, &c, _offset + 10);
  }
}

void Padding5ByteEnd::Decode(::fidl::Decoder* _decoder, Padding5ByteEnd* _value, size_t _offset) {
  if (::fidl::IsMemcpyCompatible<Padding5ByteEnd>::value) {
    memcpy(_value, _decoder->template GetPtr<Padding5ByteEnd>(_offset), sizeof(Padding5ByteEnd));
  } else {
    ::fidl::Decode(_decoder, &_value->a, _offset + 0);
    ::fidl::Decode(_decoder, &_value->b, _offset + 8);
    ::fidl::Decode(_decoder, &_value->c, _offset + 10);
  }
}

zx_status_t Padding5ByteEnd::Clone(Padding5ByteEnd* _result) const {
  zx_status_t _status = ::fidl::Clone(a, &_result->a);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(b, &_result->b);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(c, &_result->c);
  if (_status != ZX_OK)
    return _status;
  return ZX_OK;
}

extern "C" const fidl_type_t test_padding_Padding6ByteEndTable;
const fidl_type_t* Padding6ByteEnd::FidlType = &test_padding_Padding6ByteEndTable;

void Padding6ByteEnd::Encode(::fidl::Encoder* _encoder, size_t _offset,
                             cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
  if (::fidl::IsMemcpyCompatible<Padding6ByteEnd>::value) {
    memcpy(_encoder->template GetPtr<Padding6ByteEnd>(_offset), this, sizeof(Padding6ByteEnd));
  } else {
    ::fidl::Encode(_encoder, &a, _offset + 0);
    ::fidl::Encode(_encoder, &b, _offset + 8);
  }
}

void Padding6ByteEnd::Decode(::fidl::Decoder* _decoder, Padding6ByteEnd* _value, size_t _offset) {
  if (::fidl::IsMemcpyCompatible<Padding6ByteEnd>::value) {
    memcpy(_value, _decoder->template GetPtr<Padding6ByteEnd>(_offset), sizeof(Padding6ByteEnd));
  } else {
    ::fidl::Decode(_decoder, &_value->a, _offset + 0);
    ::fidl::Decode(_decoder, &_value->b, _offset + 8);
  }
}

zx_status_t Padding6ByteEnd::Clone(Padding6ByteEnd* _result) const {
  zx_status_t _status = ::fidl::Clone(a, &_result->a);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(b, &_result->b);
  if (_status != ZX_OK)
    return _status;
  return ZX_OK;
}

extern "C" const fidl_type_t test_padding_Padding7ByteEndTable;
const fidl_type_t* Padding7ByteEnd::FidlType = &test_padding_Padding7ByteEndTable;

void Padding7ByteEnd::Encode(::fidl::Encoder* _encoder, size_t _offset,
                             cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
  if (::fidl::IsMemcpyCompatible<Padding7ByteEnd>::value) {
    memcpy(_encoder->template GetPtr<Padding7ByteEnd>(_offset), this, sizeof(Padding7ByteEnd));
  } else {
    ::fidl::Encode(_encoder, &a, _offset + 0);
    ::fidl::Encode(_encoder, &b, _offset + 8);
  }
}

void Padding7ByteEnd::Decode(::fidl::Decoder* _decoder, Padding7ByteEnd* _value, size_t _offset) {
  if (::fidl::IsMemcpyCompatible<Padding7ByteEnd>::value) {
    memcpy(_value, _decoder->template GetPtr<Padding7ByteEnd>(_offset), sizeof(Padding7ByteEnd));
  } else {
    ::fidl::Decode(_decoder, &_value->a, _offset + 0);
    ::fidl::Decode(_decoder, &_value->b, _offset + 8);
  }
}

zx_status_t Padding7ByteEnd::Clone(Padding7ByteEnd* _result) const {
  zx_status_t _status = ::fidl::Clone(a, &_result->a);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(b, &_result->b);
  if (_status != ZX_OK)
    return _status;
  return ZX_OK;
}

extern "C" const fidl_type_t test_padding_Padding1ByteMiddleTable;
const fidl_type_t* Padding1ByteMiddle::FidlType = &test_padding_Padding1ByteMiddleTable;

void Padding1ByteMiddle::Encode(::fidl::Encoder* _encoder, size_t _offset,
                                cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
  if (::fidl::IsMemcpyCompatible<Padding1ByteMiddle>::value) {
    memcpy(_encoder->template GetPtr<Padding1ByteMiddle>(_offset), this, sizeof(Padding1ByteMiddle));
  } else {
    ::fidl::Encode(_encoder, &a, _offset + 0);
    ::fidl::Encode(_encoder, &b, _offset + 2);
  }
}

void Padding1ByteMiddle::Decode(::fidl::Decoder* _decoder, Padding1ByteMiddle* _value, size_t _offset) {
  if (::fidl::IsMemcpyCompatible<Padding1ByteMiddle>::value) {
    memcpy(_value, _decoder->template GetPtr<Padding1ByteMiddle>(_offset), sizeof(Padding1ByteMiddle));
  } else {
    ::fidl::Decode(_decoder, &_value->a, _offset + 0);
    ::fidl::Decode(_decoder, &_value->b, _offset + 2);
  }
}

zx_status_t Padding1ByteMiddle::Clone(Padding1ByteMiddle* _result) const {
  zx_status_t _status = ::fidl::Clone(a, &_result->a);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(b, &_result->b);
  if (_status != ZX_OK)
    return _status;
  return ZX_OK;
}

extern "C" const fidl_type_t test_padding_Padding2ByteMiddleTable;
const fidl_type_t* Padding2ByteMiddle::FidlType = &test_padding_Padding2ByteMiddleTable;

void Padding2ByteMiddle::Encode(::fidl::Encoder* _encoder, size_t _offset,
                                cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
  if (::fidl::IsMemcpyCompatible<Padding2ByteMiddle>::value) {
    memcpy(_encoder->template GetPtr<Padding2ByteMiddle>(_offset), this, sizeof(Padding2ByteMiddle));
  } else {
    ::fidl::Encode(_encoder, &a, _offset + 0);
    ::fidl::Encode(_encoder, &b, _offset + 4);
  }
}

void Padding2ByteMiddle::Decode(::fidl::Decoder* _decoder, Padding2ByteMiddle* _value, size_t _offset) {
  if (::fidl::IsMemcpyCompatible<Padding2ByteMiddle>::value) {
    memcpy(_value, _decoder->template GetPtr<Padding2ByteMiddle>(_offset), sizeof(Padding2ByteMiddle));
  } else {
    ::fidl::Decode(_decoder, &_value->a, _offset + 0);
    ::fidl::Decode(_decoder, &_value->b, _offset + 4);
  }
}

zx_status_t Padding2ByteMiddle::Clone(Padding2ByteMiddle* _result) const {
  zx_status_t _status = ::fidl::Clone(a, &_result->a);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(b, &_result->b);
  if (_status != ZX_OK)
    return _status;
  return ZX_OK;
}

extern "C" const fidl_type_t test_padding_Padding3ByteMiddleTable;
const fidl_type_t* Padding3ByteMiddle::FidlType = &test_padding_Padding3ByteMiddleTable;

void Padding3ByteMiddle::Encode(::fidl::Encoder* _encoder, size_t _offset,
                                cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
  if (::fidl::IsMemcpyCompatible<Padding3ByteMiddle>::value) {
    memcpy(_encoder->template GetPtr<Padding3ByteMiddle>(_offset), this, sizeof(Padding3ByteMiddle));
  } else {
    ::fidl::Encode(_encoder, &a, _offset + 0);
    ::fidl::Encode(_encoder, &b, _offset + 4);
  }
}

void Padding3ByteMiddle::Decode(::fidl::Decoder* _decoder, Padding3ByteMiddle* _value, size_t _offset) {
  if (::fidl::IsMemcpyCompatible<Padding3ByteMiddle>::value) {
    memcpy(_value, _decoder->template GetPtr<Padding3ByteMiddle>(_offset), sizeof(Padding3ByteMiddle));
  } else {
    ::fidl::Decode(_decoder, &_value->a, _offset + 0);
    ::fidl::Decode(_decoder, &_value->b, _offset + 4);
  }
}

zx_status_t Padding3ByteMiddle::Clone(Padding3ByteMiddle* _result) const {
  zx_status_t _status = ::fidl::Clone(a, &_result->a);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(b, &_result->b);
  if (_status != ZX_OK)
    return _status;
  return ZX_OK;
}

extern "C" const fidl_type_t test_padding_Padding4ByteMiddleTable;
const fidl_type_t* Padding4ByteMiddle::FidlType = &test_padding_Padding4ByteMiddleTable;

void Padding4ByteMiddle::Encode(::fidl::Encoder* _encoder, size_t _offset,
                                cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
  if (::fidl::IsMemcpyCompatible<Padding4ByteMiddle>::value) {
    memcpy(_encoder->template GetPtr<Padding4ByteMiddle>(_offset), this, sizeof(Padding4ByteMiddle));
  } else {
    ::fidl::Encode(_encoder, &a, _offset + 0);
    ::fidl::Encode(_encoder, &b, _offset + 8);
  }
}

void Padding4ByteMiddle::Decode(::fidl::Decoder* _decoder, Padding4ByteMiddle* _value, size_t _offset) {
  if (::fidl::IsMemcpyCompatible<Padding4ByteMiddle>::value) {
    memcpy(_value, _decoder->template GetPtr<Padding4ByteMiddle>(_offset), sizeof(Padding4ByteMiddle));
  } else {
    ::fidl::Decode(_decoder, &_value->a, _offset + 0);
    ::fidl::Decode(_decoder, &_value->b, _offset + 8);
  }
}

zx_status_t Padding4ByteMiddle::Clone(Padding4ByteMiddle* _result) const {
  zx_status_t _status = ::fidl::Clone(a, &_result->a);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(b, &_result->b);
  if (_status != ZX_OK)
    return _status;
  return ZX_OK;
}

extern "C" const fidl_type_t test_padding_Padding5ByteMiddleTable;
const fidl_type_t* Padding5ByteMiddle::FidlType = &test_padding_Padding5ByteMiddleTable;

void Padding5ByteMiddle::Encode(::fidl::Encoder* _encoder, size_t _offset,
                                cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
  if (::fidl::IsMemcpyCompatible<Padding5ByteMiddle>::value) {
    memcpy(_encoder->template GetPtr<Padding5ByteMiddle>(_offset), this, sizeof(Padding5ByteMiddle));
  } else {
    ::fidl::Encode(_encoder, &a, _offset + 0);
    ::fidl::Encode(_encoder, &b, _offset + 2);
    ::fidl::Encode(_encoder, &c, _offset + 8);
  }
}

void Padding5ByteMiddle::Decode(::fidl::Decoder* _decoder, Padding5ByteMiddle* _value, size_t _offset) {
  if (::fidl::IsMemcpyCompatible<Padding5ByteMiddle>::value) {
    memcpy(_value, _decoder->template GetPtr<Padding5ByteMiddle>(_offset), sizeof(Padding5ByteMiddle));
  } else {
    ::fidl::Decode(_decoder, &_value->a, _offset + 0);
    ::fidl::Decode(_decoder, &_value->b, _offset + 2);
    ::fidl::Decode(_decoder, &_value->c, _offset + 8);
  }
}

zx_status_t Padding5ByteMiddle::Clone(Padding5ByteMiddle* _result) const {
  zx_status_t _status = ::fidl::Clone(a, &_result->a);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(b, &_result->b);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(c, &_result->c);
  if (_status != ZX_OK)
    return _status;
  return ZX_OK;
}

extern "C" const fidl_type_t test_padding_Padding6ByteMiddleTable;
const fidl_type_t* Padding6ByteMiddle::FidlType = &test_padding_Padding6ByteMiddleTable;

void Padding6ByteMiddle::Encode(::fidl::Encoder* _encoder, size_t _offset,
                                cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
  if (::fidl::IsMemcpyCompatible<Padding6ByteMiddle>::value) {
    memcpy(_encoder->template GetPtr<Padding6ByteMiddle>(_offset), this, sizeof(Padding6ByteMiddle));
  } else {
    ::fidl::Encode(_encoder, &a, _offset + 0);
    ::fidl::Encode(_encoder, &b, _offset + 8);
  }
}

void Padding6ByteMiddle::Decode(::fidl::Decoder* _decoder, Padding6ByteMiddle* _value, size_t _offset) {
  if (::fidl::IsMemcpyCompatible<Padding6ByteMiddle>::value) {
    memcpy(_value, _decoder->template GetPtr<Padding6ByteMiddle>(_offset), sizeof(Padding6ByteMiddle));
  } else {
    ::fidl::Decode(_decoder, &_value->a, _offset + 0);
    ::fidl::Decode(_decoder, &_value->b, _offset + 8);
  }
}

zx_status_t Padding6ByteMiddle::Clone(Padding6ByteMiddle* _result) const {
  zx_status_t _status = ::fidl::Clone(a, &_result->a);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(b, &_result->b);
  if (_status != ZX_OK)
    return _status;
  return ZX_OK;
}

extern "C" const fidl_type_t test_padding_Padding7ByteMiddleTable;
const fidl_type_t* Padding7ByteMiddle::FidlType = &test_padding_Padding7ByteMiddleTable;

void Padding7ByteMiddle::Encode(::fidl::Encoder* _encoder, size_t _offset,
                                cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
  if (::fidl::IsMemcpyCompatible<Padding7ByteMiddle>::value) {
    memcpy(_encoder->template GetPtr<Padding7ByteMiddle>(_offset), this, sizeof(Padding7ByteMiddle));
  } else {
    ::fidl::Encode(_encoder, &a, _offset + 0);
    ::fidl::Encode(_encoder, &b, _offset + 8);
  }
}

void Padding7ByteMiddle::Decode(::fidl::Decoder* _decoder, Padding7ByteMiddle* _value, size_t _offset) {
  if (::fidl::IsMemcpyCompatible<Padding7ByteMiddle>::value) {
    memcpy(_value, _decoder->template GetPtr<Padding7ByteMiddle>(_offset), sizeof(Padding7ByteMiddle));
  } else {
    ::fidl::Decode(_decoder, &_value->a, _offset + 0);
    ::fidl::Decode(_decoder, &_value->b, _offset + 8);
  }
}

zx_status_t Padding7ByteMiddle::Clone(Padding7ByteMiddle* _result) const {
  zx_status_t _status = ::fidl::Clone(a, &_result->a);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(b, &_result->b);
  if (_status != ZX_OK)
    return _status;
  return ZX_OK;
}

extern "C" const fidl_type_t test_padding_Padding4ByteAlignmentLength12Table;
const fidl_type_t* Padding4ByteAlignmentLength12::FidlType = &test_padding_Padding4ByteAlignmentLength12Table;

void Padding4ByteAlignmentLength12::Encode(::fidl::Encoder* _encoder, size_t _offset,
                                           cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
  if (::fidl::IsMemcpyCompatible<Padding4ByteAlignmentLength12>::value) {
    memcpy(_encoder->template GetPtr<Padding4ByteAlignmentLength12>(_offset), this, sizeof(Padding4ByteAlignmentLength12));
  } else {
    ::fidl::Encode(_encoder, &a, _offset + 0);
    ::fidl::Encode(_encoder, &b, _offset + 4);
    ::fidl::Encode(_encoder, &c, _offset + 6);
    ::fidl::Encode(_encoder, &d, _offset + 8);
  }
}

void Padding4ByteAlignmentLength12::Decode(::fidl::Decoder* _decoder, Padding4ByteAlignmentLength12* _value, size_t _offset) {
  if (::fidl::IsMemcpyCompatible<Padding4ByteAlignmentLength12>::value) {
    memcpy(_value, _decoder->template GetPtr<Padding4ByteAlignmentLength12>(_offset), sizeof(Padding4ByteAlignmentLength12));
  } else {
    ::fidl::Decode(_decoder, &_value->a, _offset + 0);
    ::fidl::Decode(_decoder, &_value->b, _offset + 4);
    ::fidl::Decode(_decoder, &_value->c, _offset + 6);
    ::fidl::Decode(_decoder, &_value->d, _offset + 8);
  }
}

zx_status_t Padding4ByteAlignmentLength12::Clone(Padding4ByteAlignmentLength12* _result) const {
  zx_status_t _status = ::fidl::Clone(a, &_result->a);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(b, &_result->b);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(c, &_result->c);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(d, &_result->d);
  if (_status != ZX_OK)
    return _status;
  return ZX_OK;
}

extern "C" const fidl_type_t test_padding_Padding2ByteAlignmentLength6Table;
const fidl_type_t* Padding2ByteAlignmentLength6::FidlType = &test_padding_Padding2ByteAlignmentLength6Table;

void Padding2ByteAlignmentLength6::Encode(::fidl::Encoder* _encoder, size_t _offset,
                                          cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
  if (::fidl::IsMemcpyCompatible<Padding2ByteAlignmentLength6>::value) {
    memcpy(_encoder->template GetPtr<Padding2ByteAlignmentLength6>(_offset), this, sizeof(Padding2ByteAlignmentLength6));
  } else {
    ::fidl::Encode(_encoder, &a, _offset + 0);
    ::fidl::Encode(_encoder, &b, _offset + 2);
    ::fidl::Encode(_encoder, &c, _offset + 4);
  }
}

void Padding2ByteAlignmentLength6::Decode(::fidl::Decoder* _decoder, Padding2ByteAlignmentLength6* _value, size_t _offset) {
  if (::fidl::IsMemcpyCompatible<Padding2ByteAlignmentLength6>::value) {
    memcpy(_value, _decoder->template GetPtr<Padding2ByteAlignmentLength6>(_offset), sizeof(Padding2ByteAlignmentLength6));
  } else {
    ::fidl::Decode(_decoder, &_value->a, _offset + 0);
    ::fidl::Decode(_decoder, &_value->b, _offset + 2);
    ::fidl::Decode(_decoder, &_value->c, _offset + 4);
  }
}

zx_status_t Padding2ByteAlignmentLength6::Clone(Padding2ByteAlignmentLength6* _result) const {
  zx_status_t _status = ::fidl::Clone(a, &_result->a);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(b, &_result->b);
  if (_status != ZX_OK)
    return _status;
  _status = ::fidl::Clone(c, &_result->c);
  if (_status != ZX_OK)
    return _status;
  return ZX_OK;
}

//
// Proxies and stubs definitions
//
}  // namespace padding
}  // namespace test