#pragma once

#include <cstdint>
#include <cstddef>

namespace ta_vertex_parameter {
  struct polygon_type_0 {
    uint32_t parameter_control_word;
    float x;
    float y;
    float z;
    uint32_t _res0;
    uint32_t _res1;
    uint32_t base_color;
    uint32_t _res2;

    polygon_type_0(const uint32_t parameter_control_word,
                   const float x,
                   const float y,
                   const float z,
                   const uint32_t base_color
                   )
      : parameter_control_word(parameter_control_word)
      , x(x)
      , y(y)
      , z(z)
      , _res0(0)
      , _res1(0)
      , base_color(base_color)
      , _res2(0)
    { }
  };
  static_assert((sizeof (polygon_type_0)) == 32);
  static_assert((offsetof (struct polygon_type_0, parameter_control_word)) == 0x00);
  static_assert((offsetof (struct polygon_type_0, x)) == 0x04);
  static_assert((offsetof (struct polygon_type_0, y)) == 0x08);
  static_assert((offsetof (struct polygon_type_0, z)) == 0x0c);
  static_assert((offsetof (struct polygon_type_0, _res0)) == 0x10);
  static_assert((offsetof (struct polygon_type_0, _res1)) == 0x14);
  static_assert((offsetof (struct polygon_type_0, base_color)) == 0x18);
  static_assert((offsetof (struct polygon_type_0, _res2)) == 0x1c);

  struct polygon_type_1 {
    uint32_t parameter_control_word;
    float x;
    float y;
    float z;
    float base_color_alpha;
    float base_color_r;
    float base_color_g;
    float base_color_b;

    polygon_type_1(const uint32_t parameter_control_word,
                   const float x,
                   const float y,
                   const float z,
                   const float base_color_alpha,
                   const float base_color_r,
                   const float base_color_g,
                   const float base_color_b
                   )
      : parameter_control_word(parameter_control_word)
      , x(x)
      , y(y)
      , z(z)
      , base_color_alpha(base_color_alpha)
      , base_color_r(base_color_r)
      , base_color_g(base_color_g)
      , base_color_b(base_color_b)
    { }
  };
  static_assert((sizeof (polygon_type_1)) == 32);
  static_assert((offsetof (struct polygon_type_1, parameter_control_word)) == 0x00);
  static_assert((offsetof (struct polygon_type_1, x)) == 0x04);
  static_assert((offsetof (struct polygon_type_1, y)) == 0x08);
  static_assert((offsetof (struct polygon_type_1, z)) == 0x0c);
  static_assert((offsetof (struct polygon_type_1, base_color_alpha)) == 0x10);
  static_assert((offsetof (struct polygon_type_1, base_color_r)) == 0x14);
  static_assert((offsetof (struct polygon_type_1, base_color_g)) == 0x18);
  static_assert((offsetof (struct polygon_type_1, base_color_b)) == 0x1c);

  struct polygon_type_2 {
    uint32_t parameter_control_word;
    float x;
    float y;
    float z;
    uint32_t _res0;
    uint32_t _res1;
    float base_intensity;
    uint32_t _res2;

    polygon_type_2(const uint32_t parameter_control_word,
                   const float x,
                   const float y,
                   const float z,
                   const float base_intensity
                   )
      : parameter_control_word(parameter_control_word)
      , x(x)
      , y(y)
      , z(z)
      , _res0(0)
      , _res1(0)
      , base_intensity(base_intensity)
      , _res2(0)
    { }
  };
  static_assert((sizeof (polygon_type_2)) == 32);
  static_assert((offsetof (struct polygon_type_2, parameter_control_word)) == 0x00);
  static_assert((offsetof (struct polygon_type_2, x)) == 0x04);
  static_assert((offsetof (struct polygon_type_2, y)) == 0x08);
  static_assert((offsetof (struct polygon_type_2, z)) == 0x0c);
  static_assert((offsetof (struct polygon_type_2, _res0)) == 0x10);
  static_assert((offsetof (struct polygon_type_2, _res1)) == 0x14);
  static_assert((offsetof (struct polygon_type_2, base_intensity)) == 0x18);
  static_assert((offsetof (struct polygon_type_2, _res2)) == 0x1c);

  struct polygon_type_3 {
    uint32_t parameter_control_word;
    float x;
    float y;
    float z;
    float u;
    float v;
    uint32_t base_color;
    uint32_t offset_color;

    polygon_type_3(const uint32_t parameter_control_word,
                   const float x,
                   const float y,
                   const float z,
                   const float u,
                   const float v,
                   const uint32_t base_color,
                   const uint32_t offset_color
                   )
      : parameter_control_word(parameter_control_word)
      , x(x)
      , y(y)
      , z(z)
      , u(u)
      , v(v)
      , base_color(base_color)
      , offset_color(offset_color)
    { }
  };
  static_assert((sizeof (polygon_type_3)) == 32);
  static_assert((offsetof (struct polygon_type_3, parameter_control_word)) == 0x00);
  static_assert((offsetof (struct polygon_type_3, x)) == 0x04);
  static_assert((offsetof (struct polygon_type_3, y)) == 0x08);
  static_assert((offsetof (struct polygon_type_3, z)) == 0x0c);
  static_assert((offsetof (struct polygon_type_3, u)) == 0x10);
  static_assert((offsetof (struct polygon_type_3, v)) == 0x14);
  static_assert((offsetof (struct polygon_type_3, base_color)) == 0x18);
  static_assert((offsetof (struct polygon_type_3, offset_color)) == 0x1c);

  struct polygon_type_4 {
    uint32_t parameter_control_word;
    float x;
    float y;
    float z;
    uint32_t u_v;
    uint32_t _res0;
    uint32_t base_color;
    uint32_t offset_color;

    polygon_type_4(const uint32_t parameter_control_word,
                   const float x,
                   const float y,
                   const float z,
                   const uint32_t u_v,
                   const uint32_t base_color,
                   const uint32_t offset_color
                   )
      : parameter_control_word(parameter_control_word)
      , x(x)
      , y(y)
      , z(z)
      , u_v(u_v)
      , _res0(0)
      , base_color(base_color)
      , offset_color(offset_color)
    { }
  };
  static_assert((sizeof (polygon_type_4)) == 32);
  static_assert((offsetof (struct polygon_type_4, parameter_control_word)) == 0x00);
  static_assert((offsetof (struct polygon_type_4, x)) == 0x04);
  static_assert((offsetof (struct polygon_type_4, y)) == 0x08);
  static_assert((offsetof (struct polygon_type_4, z)) == 0x0c);
  static_assert((offsetof (struct polygon_type_4, u_v)) == 0x10);
  static_assert((offsetof (struct polygon_type_4, _res0)) == 0x14);
  static_assert((offsetof (struct polygon_type_4, base_color)) == 0x18);
  static_assert((offsetof (struct polygon_type_4, offset_color)) == 0x1c);

  struct polygon_type_5 {
    uint32_t parameter_control_word;
    float x;
    float y;
    float z;
    float u;
    float v;
    uint32_t _res0;
    uint32_t _res1;
    float base_color_alpha;
    float base_color_r;
    float base_color_g;
    float base_color_b;
    float offset_color_alpha;
    float offset_color_r;
    float offset_color_g;
    float offset_color_b;

    polygon_type_5(const uint32_t parameter_control_word,
                   const float x,
                   const float y,
                   const float z,
                   const float u,
                   const float v,
                   const float base_color_alpha,
                   const float base_color_r,
                   const float base_color_g,
                   const float base_color_b,
                   const float offset_color_alpha,
                   const float offset_color_r,
                   const float offset_color_g,
                   const float offset_color_b
                   )
      : parameter_control_word(parameter_control_word)
      , x(x)
      , y(y)
      , z(z)
      , u(u)
      , v(v)
      , _res0(0)
      , _res1(0)
      , base_color_alpha(base_color_alpha)
      , base_color_r(base_color_r)
      , base_color_g(base_color_g)
      , base_color_b(base_color_b)
      , offset_color_alpha(offset_color_alpha)
      , offset_color_r(offset_color_r)
      , offset_color_g(offset_color_g)
      , offset_color_b(offset_color_b)
    { }
  };
  static_assert((sizeof (polygon_type_5)) == 64);
  static_assert((offsetof (struct polygon_type_5, parameter_control_word)) == 0x00);
  static_assert((offsetof (struct polygon_type_5, x)) == 0x04);
  static_assert((offsetof (struct polygon_type_5, y)) == 0x08);
  static_assert((offsetof (struct polygon_type_5, z)) == 0x0c);
  static_assert((offsetof (struct polygon_type_5, u)) == 0x10);
  static_assert((offsetof (struct polygon_type_5, v)) == 0x14);
  static_assert((offsetof (struct polygon_type_5, _res0)) == 0x18);
  static_assert((offsetof (struct polygon_type_5, _res1)) == 0x1c);
  static_assert((offsetof (struct polygon_type_5, base_color_alpha)) == 0x20);
  static_assert((offsetof (struct polygon_type_5, base_color_r)) == 0x24);
  static_assert((offsetof (struct polygon_type_5, base_color_g)) == 0x28);
  static_assert((offsetof (struct polygon_type_5, base_color_b)) == 0x2c);
  static_assert((offsetof (struct polygon_type_5, offset_color_alpha)) == 0x30);
  static_assert((offsetof (struct polygon_type_5, offset_color_r)) == 0x34);
  static_assert((offsetof (struct polygon_type_5, offset_color_g)) == 0x38);
  static_assert((offsetof (struct polygon_type_5, offset_color_b)) == 0x3c);

  struct polygon_type_6 {
    uint32_t parameter_control_word;
    float x;
    float y;
    float z;
    uint32_t u_v;
    uint32_t _res0;
    uint32_t _res1;
    uint32_t _res2;
    float base_color_alpha;
    float base_color_r;
    float base_color_g;
    float base_color_b;
    float offset_color_alpha;
    float offset_color_r;
    float offset_color_g;
    float offset_color_b;

    polygon_type_6(const uint32_t parameter_control_word,
                   const float x,
                   const float y,
                   const float z,
                   const uint32_t u_v,
                   const float base_color_alpha,
                   const float base_color_r,
                   const float base_color_g,
                   const float base_color_b,
                   const float offset_color_alpha,
                   const float offset_color_r,
                   const float offset_color_g,
                   const float offset_color_b
                   )
      : parameter_control_word(parameter_control_word)
      , x(x)
      , y(y)
      , z(z)
      , u_v(u_v)
      , _res0(0)
      , _res1(0)
      , _res2(0)
      , base_color_alpha(base_color_alpha)
      , base_color_r(base_color_r)
      , base_color_g(base_color_g)
      , base_color_b(base_color_b)
      , offset_color_alpha(offset_color_alpha)
      , offset_color_r(offset_color_r)
      , offset_color_g(offset_color_g)
      , offset_color_b(offset_color_b)
    { }
  };
  static_assert((sizeof (polygon_type_6)) == 64);
  static_assert((offsetof (struct polygon_type_6, parameter_control_word)) == 0x00);
  static_assert((offsetof (struct polygon_type_6, x)) == 0x04);
  static_assert((offsetof (struct polygon_type_6, y)) == 0x08);
  static_assert((offsetof (struct polygon_type_6, z)) == 0x0c);
  static_assert((offsetof (struct polygon_type_6, u_v)) == 0x10);
  static_assert((offsetof (struct polygon_type_6, _res0)) == 0x14);
  static_assert((offsetof (struct polygon_type_6, _res1)) == 0x18);
  static_assert((offsetof (struct polygon_type_6, _res2)) == 0x1c);
  static_assert((offsetof (struct polygon_type_6, base_color_alpha)) == 0x20);
  static_assert((offsetof (struct polygon_type_6, base_color_r)) == 0x24);
  static_assert((offsetof (struct polygon_type_6, base_color_g)) == 0x28);
  static_assert((offsetof (struct polygon_type_6, base_color_b)) == 0x2c);
  static_assert((offsetof (struct polygon_type_6, offset_color_alpha)) == 0x30);
  static_assert((offsetof (struct polygon_type_6, offset_color_r)) == 0x34);
  static_assert((offsetof (struct polygon_type_6, offset_color_g)) == 0x38);
  static_assert((offsetof (struct polygon_type_6, offset_color_b)) == 0x3c);

  struct polygon_type_7 {
    uint32_t parameter_control_word;
    float x;
    float y;
    float z;
    float u;
    float v;
    float base_intensity;
    float offset_intensity;

    polygon_type_7(const uint32_t parameter_control_word,
                   const float x,
                   const float y,
                   const float z,
                   const float u,
                   const float v,
                   const float base_intensity,
                   const float offset_intensity
                   )
      : parameter_control_word(parameter_control_word)
      , x(x)
      , y(y)
      , z(z)
      , u(u)
      , v(v)
      , base_intensity(base_intensity)
      , offset_intensity(offset_intensity)
    { }
  };
  static_assert((sizeof (polygon_type_7)) == 32);
  static_assert((offsetof (struct polygon_type_7, parameter_control_word)) == 0x00);
  static_assert((offsetof (struct polygon_type_7, x)) == 0x04);
  static_assert((offsetof (struct polygon_type_7, y)) == 0x08);
  static_assert((offsetof (struct polygon_type_7, z)) == 0x0c);
  static_assert((offsetof (struct polygon_type_7, u)) == 0x10);
  static_assert((offsetof (struct polygon_type_7, v)) == 0x14);
  static_assert((offsetof (struct polygon_type_7, base_intensity)) == 0x18);
  static_assert((offsetof (struct polygon_type_7, offset_intensity)) == 0x1c);

  struct polygon_type_8 {
    uint32_t parameter_control_word;
    float x;
    float y;
    float z;
    uint32_t u_v;
    uint32_t _res0;
    float base_intensity;
    float offset_intensity;

    polygon_type_8(const uint32_t parameter_control_word,
                   const float x,
                   const float y,
                   const float z,
                   const uint32_t u_v,
                   const float base_intensity,
                   const float offset_intensity
                   )
      : parameter_control_word(parameter_control_word)
      , x(x)
      , y(y)
      , z(z)
      , u_v(u_v)
      , _res0(0)
      , base_intensity(base_intensity)
      , offset_intensity(offset_intensity)
    { }
  };
  static_assert((sizeof (polygon_type_8)) == 32);
  static_assert((offsetof (struct polygon_type_8, parameter_control_word)) == 0x00);
  static_assert((offsetof (struct polygon_type_8, x)) == 0x04);
  static_assert((offsetof (struct polygon_type_8, y)) == 0x08);
  static_assert((offsetof (struct polygon_type_8, z)) == 0x0c);
  static_assert((offsetof (struct polygon_type_8, u_v)) == 0x10);
  static_assert((offsetof (struct polygon_type_8, _res0)) == 0x14);
  static_assert((offsetof (struct polygon_type_8, base_intensity)) == 0x18);
  static_assert((offsetof (struct polygon_type_8, offset_intensity)) == 0x1c);

  struct polygon_type_9 {
    uint32_t parameter_control_word;
    float x;
    float y;
    float z;
    uint32_t base_color_0;
    uint32_t base_color_1;
    uint32_t _res0;
    uint32_t _res1;

    polygon_type_9(const uint32_t parameter_control_word,
                   const float x,
                   const float y,
                   const float z,
                   const uint32_t base_color_0,
                   const uint32_t base_color_1
                   )
      : parameter_control_word(parameter_control_word)
      , x(x)
      , y(y)
      , z(z)
      , base_color_0(base_color_0)
      , base_color_1(base_color_1)
      , _res0(0)
      , _res1(0)
    { }
  };
  static_assert((sizeof (polygon_type_9)) == 32);
  static_assert((offsetof (struct polygon_type_9, parameter_control_word)) == 0x00);
  static_assert((offsetof (struct polygon_type_9, x)) == 0x04);
  static_assert((offsetof (struct polygon_type_9, y)) == 0x08);
  static_assert((offsetof (struct polygon_type_9, z)) == 0x0c);
  static_assert((offsetof (struct polygon_type_9, base_color_0)) == 0x10);
  static_assert((offsetof (struct polygon_type_9, base_color_1)) == 0x14);
  static_assert((offsetof (struct polygon_type_9, _res0)) == 0x18);
  static_assert((offsetof (struct polygon_type_9, _res1)) == 0x1c);

  struct polygon_type_10 {
    uint32_t parameter_control_word;
    float x;
    float y;
    float z;
    uint32_t base_intensity_0;
    uint32_t base_intensity_1;
    uint32_t _res0;
    uint32_t _res1;

    polygon_type_10(const uint32_t parameter_control_word,
                    const float x,
                    const float y,
                    const float z,
                    const uint32_t base_intensity_0,
                    const uint32_t base_intensity_1
                    )
      : parameter_control_word(parameter_control_word)
      , x(x)
      , y(y)
      , z(z)
      , base_intensity_0(base_intensity_0)
      , base_intensity_1(base_intensity_1)
      , _res0(0)
      , _res1(0)
    { }
  };
  static_assert((sizeof (polygon_type_10)) == 32);
  static_assert((offsetof (struct polygon_type_10, parameter_control_word)) == 0x00);
  static_assert((offsetof (struct polygon_type_10, x)) == 0x04);
  static_assert((offsetof (struct polygon_type_10, y)) == 0x08);
  static_assert((offsetof (struct polygon_type_10, z)) == 0x0c);
  static_assert((offsetof (struct polygon_type_10, base_intensity_0)) == 0x10);
  static_assert((offsetof (struct polygon_type_10, base_intensity_1)) == 0x14);
  static_assert((offsetof (struct polygon_type_10, _res0)) == 0x18);
  static_assert((offsetof (struct polygon_type_10, _res1)) == 0x1c);

  struct polygon_type_11 {
    uint32_t parameter_control_word;
    float x;
    float y;
    float z;
    float u_0;
    float v_0;
    uint32_t base_color_0;
    uint32_t offset_color_0;
    float u_1;
    float v_1;
    uint32_t base_color_1;
    uint32_t offset_color_1;
    uint32_t _res0;
    uint32_t _res1;
    uint32_t _res2;
    uint32_t _res3;

    polygon_type_11(const uint32_t parameter_control_word,
                    const float x,
                    const float y,
                    const float z,
                    const float u_0,
                    const float v_0,
                    const uint32_t base_color_0,
                    const uint32_t offset_color_0,
                    const float u_1,
                    const float v_1,
                    const uint32_t base_color_1,
                    const uint32_t offset_color_1
                    )
      : parameter_control_word(parameter_control_word)
      , x(x)
      , y(y)
      , z(z)
      , u_0(u_0)
      , v_0(v_0)
      , base_color_0(base_color_0)
      , offset_color_0(offset_color_0)
      , u_1(u_1)
      , v_1(v_1)
      , base_color_1(base_color_1)
      , offset_color_1(offset_color_1)
      , _res0(0)
      , _res1(0)
      , _res2(0)
      , _res3(0)
    { }
  };
  static_assert((sizeof (polygon_type_11)) == 64);
  static_assert((offsetof (struct polygon_type_11, parameter_control_word)) == 0x00);
  static_assert((offsetof (struct polygon_type_11, x)) == 0x04);
  static_assert((offsetof (struct polygon_type_11, y)) == 0x08);
  static_assert((offsetof (struct polygon_type_11, z)) == 0x0c);
  static_assert((offsetof (struct polygon_type_11, u_0)) == 0x10);
  static_assert((offsetof (struct polygon_type_11, v_0)) == 0x14);
  static_assert((offsetof (struct polygon_type_11, base_color_0)) == 0x18);
  static_assert((offsetof (struct polygon_type_11, offset_color_0)) == 0x1c);
  static_assert((offsetof (struct polygon_type_11, u_1)) == 0x20);
  static_assert((offsetof (struct polygon_type_11, v_1)) == 0x24);
  static_assert((offsetof (struct polygon_type_11, base_color_1)) == 0x28);
  static_assert((offsetof (struct polygon_type_11, offset_color_1)) == 0x2c);
  static_assert((offsetof (struct polygon_type_11, _res0)) == 0x30);
  static_assert((offsetof (struct polygon_type_11, _res1)) == 0x34);
  static_assert((offsetof (struct polygon_type_11, _res2)) == 0x38);
  static_assert((offsetof (struct polygon_type_11, _res3)) == 0x3c);

  struct polygon_type_12 {
    uint32_t parameter_control_word;
    float x;
    float y;
    float z;
    uint32_t u_v_0;
    uint32_t _res0;
    uint32_t base_color_0;
    uint32_t offset_color_0;
    uint32_t u_v_1;
    uint32_t _res1;
    uint32_t base_color_1;
    uint32_t offset_color_1;
    uint32_t _res2;
    uint32_t _res3;
    uint32_t _res4;
    uint32_t _res5;

    polygon_type_12(const uint32_t parameter_control_word,
                    const float x,
                    const float y,
                    const float z,
                    const uint32_t u_v_0,
                    const uint32_t base_color_0,
                    const uint32_t offset_color_0,
                    const uint32_t u_v_1,
                    const uint32_t base_color_1,
                    const uint32_t offset_color_1
                    )
      : parameter_control_word(parameter_control_word)
      , x(x)
      , y(y)
      , z(z)
      , u_v_0(u_v_0)
      , _res0(0)
      , base_color_0(base_color_0)
      , offset_color_0(offset_color_0)
      , u_v_1(u_v_1)
      , _res1(0)
      , base_color_1(base_color_1)
      , offset_color_1(offset_color_1)
      , _res2(0)
      , _res3(0)
      , _res4(0)
      , _res5(0)
    { }
  };
  static_assert((sizeof (polygon_type_12)) == 64);
  static_assert((offsetof (struct polygon_type_12, parameter_control_word)) == 0x00);
  static_assert((offsetof (struct polygon_type_12, x)) == 0x04);
  static_assert((offsetof (struct polygon_type_12, y)) == 0x08);
  static_assert((offsetof (struct polygon_type_12, z)) == 0x0c);
  static_assert((offsetof (struct polygon_type_12, u_v_0)) == 0x10);
  static_assert((offsetof (struct polygon_type_12, _res0)) == 0x14);
  static_assert((offsetof (struct polygon_type_12, base_color_0)) == 0x18);
  static_assert((offsetof (struct polygon_type_12, offset_color_0)) == 0x1c);
  static_assert((offsetof (struct polygon_type_12, u_v_1)) == 0x20);
  static_assert((offsetof (struct polygon_type_12, _res1)) == 0x24);
  static_assert((offsetof (struct polygon_type_12, base_color_1)) == 0x28);
  static_assert((offsetof (struct polygon_type_12, offset_color_1)) == 0x2c);
  static_assert((offsetof (struct polygon_type_12, _res2)) == 0x30);
  static_assert((offsetof (struct polygon_type_12, _res3)) == 0x34);
  static_assert((offsetof (struct polygon_type_12, _res4)) == 0x38);
  static_assert((offsetof (struct polygon_type_12, _res5)) == 0x3c);

  struct polygon_type_13 {
    uint32_t parameter_control_word;
    float x;
    float y;
    float z;
    float u_0;
    float v_0;
    uint32_t base_intensity_0;
    float offset_intensity_0;
    float u_1;
    float v_1;
    uint32_t base_intensity_1;
    float offset_intensity_1;
    uint32_t _res0;
    uint32_t _res1;
    uint32_t _res2;
    uint32_t _res3;

    polygon_type_13(const uint32_t parameter_control_word,
                    const float x,
                    const float y,
                    const float z,
                    const float u_0,
                    const float v_0,
                    const uint32_t base_intensity_0,
                    const float offset_intensity_0,
                    const float u_1,
                    const float v_1,
                    const uint32_t base_intensity_1,
                    const float offset_intensity_1
                    )
      : parameter_control_word(parameter_control_word)
      , x(x)
      , y(y)
      , z(z)
      , u_0(u_0)
      , v_0(v_0)
      , base_intensity_0(base_intensity_0)
      , offset_intensity_0(offset_intensity_0)
      , u_1(u_1)
      , v_1(v_1)
      , base_intensity_1(base_intensity_1)
      , offset_intensity_1(offset_intensity_1)
      , _res0(0)
      , _res1(0)
      , _res2(0)
      , _res3(0)
    { }
  };
  static_assert((sizeof (polygon_type_13)) == 64);
  static_assert((offsetof (struct polygon_type_13, parameter_control_word)) == 0x00);
  static_assert((offsetof (struct polygon_type_13, x)) == 0x04);
  static_assert((offsetof (struct polygon_type_13, y)) == 0x08);
  static_assert((offsetof (struct polygon_type_13, z)) == 0x0c);
  static_assert((offsetof (struct polygon_type_13, u_0)) == 0x10);
  static_assert((offsetof (struct polygon_type_13, v_0)) == 0x14);
  static_assert((offsetof (struct polygon_type_13, base_intensity_0)) == 0x18);
  static_assert((offsetof (struct polygon_type_13, offset_intensity_0)) == 0x1c);
  static_assert((offsetof (struct polygon_type_13, u_1)) == 0x20);
  static_assert((offsetof (struct polygon_type_13, v_1)) == 0x24);
  static_assert((offsetof (struct polygon_type_13, base_intensity_1)) == 0x28);
  static_assert((offsetof (struct polygon_type_13, offset_intensity_1)) == 0x2c);
  static_assert((offsetof (struct polygon_type_13, _res0)) == 0x30);
  static_assert((offsetof (struct polygon_type_13, _res1)) == 0x34);
  static_assert((offsetof (struct polygon_type_13, _res2)) == 0x38);
  static_assert((offsetof (struct polygon_type_13, _res3)) == 0x3c);

  struct polygon_type_14 {
    uint32_t parameter_control_word;
    float x;
    float y;
    float z;
    uint32_t u_v_0;
    uint32_t _res0;
    uint32_t base_intensity_0;
    float offset_intensity_0;
    uint32_t u_v_1;
    uint32_t _res1;
    uint32_t base_intensity_1;
    float offset_intensity_1;
    uint32_t _res2;
    uint32_t _res3;
    uint32_t _res4;
    uint32_t _res5;

    polygon_type_14(const uint32_t parameter_control_word,
                    const float x,
                    const float y,
                    const float z,
                    const uint32_t u_v_0,
                    const uint32_t base_intensity_0,
                    const float offset_intensity_0,
                    const uint32_t u_v_1,
                    const uint32_t base_intensity_1,
                    const float offset_intensity_1
                    )
      : parameter_control_word(parameter_control_word)
      , x(x)
      , y(y)
      , z(z)
      , u_v_0(u_v_0)
      , _res0(0)
      , base_intensity_0(base_intensity_0)
      , offset_intensity_0(offset_intensity_0)
      , u_v_1(u_v_1)
      , _res1(0)
      , base_intensity_1(base_intensity_1)
      , offset_intensity_1(offset_intensity_1)
      , _res2(0)
      , _res3(0)
      , _res4(0)
      , _res5(0)
    { }
  };
  static_assert((sizeof (polygon_type_14)) == 64);
  static_assert((offsetof (struct polygon_type_14, parameter_control_word)) == 0x00);
  static_assert((offsetof (struct polygon_type_14, x)) == 0x04);
  static_assert((offsetof (struct polygon_type_14, y)) == 0x08);
  static_assert((offsetof (struct polygon_type_14, z)) == 0x0c);
  static_assert((offsetof (struct polygon_type_14, u_v_0)) == 0x10);
  static_assert((offsetof (struct polygon_type_14, _res0)) == 0x14);
  static_assert((offsetof (struct polygon_type_14, base_intensity_0)) == 0x18);
  static_assert((offsetof (struct polygon_type_14, offset_intensity_0)) == 0x1c);
  static_assert((offsetof (struct polygon_type_14, u_v_1)) == 0x20);
  static_assert((offsetof (struct polygon_type_14, _res1)) == 0x24);
  static_assert((offsetof (struct polygon_type_14, base_intensity_1)) == 0x28);
  static_assert((offsetof (struct polygon_type_14, offset_intensity_1)) == 0x2c);
  static_assert((offsetof (struct polygon_type_14, _res2)) == 0x30);
  static_assert((offsetof (struct polygon_type_14, _res3)) == 0x34);
  static_assert((offsetof (struct polygon_type_14, _res4)) == 0x38);
  static_assert((offsetof (struct polygon_type_14, _res5)) == 0x3c);

  struct sprite_type_0 {
    uint32_t parameter_control_word;
    float a_x;
    float a_y;
    float a_z;
    float b_x;
    float b_y;
    float b_z;
    float c_x;
    float c_y;
    float c_z;
    float d_x;
    float d_y;
    uint32_t _res0;
    uint32_t _res1;
    uint32_t _res2;
    uint32_t _res3;

    sprite_type_0(const uint32_t parameter_control_word,
                  const float a_x,
                  const float a_y,
                  const float a_z,
                  const float b_x,
                  const float b_y,
                  const float b_z,
                  const float c_x,
                  const float c_y,
                  const float c_z,
                  const float d_x,
                  const float d_y
                  )
      : parameter_control_word(parameter_control_word)
      , a_x(a_x)
      , a_y(a_y)
      , a_z(a_z)
      , b_x(b_x)
      , b_y(b_y)
      , b_z(b_z)
      , c_x(c_x)
      , c_y(c_y)
      , c_z(c_z)
      , d_x(d_x)
      , d_y(d_y)
      , _res0(0)
      , _res1(0)
      , _res2(0)
      , _res3(0)
    { }
  };
  static_assert((sizeof (sprite_type_0)) == 64);
  static_assert((offsetof (struct sprite_type_0, parameter_control_word)) == 0x00);
  static_assert((offsetof (struct sprite_type_0, a_x)) == 0x04);
  static_assert((offsetof (struct sprite_type_0, a_y)) == 0x08);
  static_assert((offsetof (struct sprite_type_0, a_z)) == 0x0c);
  static_assert((offsetof (struct sprite_type_0, b_x)) == 0x10);
  static_assert((offsetof (struct sprite_type_0, b_y)) == 0x14);
  static_assert((offsetof (struct sprite_type_0, b_z)) == 0x18);
  static_assert((offsetof (struct sprite_type_0, c_x)) == 0x1c);
  static_assert((offsetof (struct sprite_type_0, c_y)) == 0x20);
  static_assert((offsetof (struct sprite_type_0, c_z)) == 0x24);
  static_assert((offsetof (struct sprite_type_0, d_x)) == 0x28);
  static_assert((offsetof (struct sprite_type_0, d_y)) == 0x2c);
  static_assert((offsetof (struct sprite_type_0, _res0)) == 0x30);
  static_assert((offsetof (struct sprite_type_0, _res1)) == 0x34);
  static_assert((offsetof (struct sprite_type_0, _res2)) == 0x38);
  static_assert((offsetof (struct sprite_type_0, _res3)) == 0x3c);

  struct sprite_type_1 {
    uint32_t parameter_control_word;
    float a_x;
    float a_y;
    float a_z;
    float b_x;
    float b_y;
    float b_z;
    float c_x;
    float c_y;
    float c_z;
    float d_x;
    float d_y;
    uint32_t _res0;
    uint32_t a_u_a_v;
    uint32_t b_u_b_v;
    uint32_t c_u_c_v;

    sprite_type_1(const uint32_t parameter_control_word,
                  const float a_x,
                  const float a_y,
                  const float a_z,
                  const float b_x,
                  const float b_y,
                  const float b_z,
                  const float c_x,
                  const float c_y,
                  const float c_z,
                  const float d_x,
                  const float d_y,
                  const uint32_t a_u_a_v,
                  const uint32_t b_u_b_v,
                  const uint32_t c_u_c_v
                  )
      : parameter_control_word(parameter_control_word)
      , a_x(a_x)
      , a_y(a_y)
      , a_z(a_z)
      , b_x(b_x)
      , b_y(b_y)
      , b_z(b_z)
      , c_x(c_x)
      , c_y(c_y)
      , c_z(c_z)
      , d_x(d_x)
      , d_y(d_y)
      , _res0(0)
      , a_u_a_v(a_u_a_v)
      , b_u_b_v(b_u_b_v)
      , c_u_c_v(c_u_c_v)
    { }
  };
  static_assert((sizeof (sprite_type_1)) == 64);
  static_assert((offsetof (struct sprite_type_1, parameter_control_word)) == 0x00);
  static_assert((offsetof (struct sprite_type_1, a_x)) == 0x04);
  static_assert((offsetof (struct sprite_type_1, a_y)) == 0x08);
  static_assert((offsetof (struct sprite_type_1, a_z)) == 0x0c);
  static_assert((offsetof (struct sprite_type_1, b_x)) == 0x10);
  static_assert((offsetof (struct sprite_type_1, b_y)) == 0x14);
  static_assert((offsetof (struct sprite_type_1, b_z)) == 0x18);
  static_assert((offsetof (struct sprite_type_1, c_x)) == 0x1c);
  static_assert((offsetof (struct sprite_type_1, c_y)) == 0x20);
  static_assert((offsetof (struct sprite_type_1, c_z)) == 0x24);
  static_assert((offsetof (struct sprite_type_1, d_x)) == 0x28);
  static_assert((offsetof (struct sprite_type_1, d_y)) == 0x2c);
  static_assert((offsetof (struct sprite_type_1, _res0)) == 0x30);
  static_assert((offsetof (struct sprite_type_1, a_u_a_v)) == 0x34);
  static_assert((offsetof (struct sprite_type_1, b_u_b_v)) == 0x38);
  static_assert((offsetof (struct sprite_type_1, c_u_c_v)) == 0x3c);

  struct modifier_volume {
    uint32_t parameter_control_word;
    float a_x;
    float a_y;
    float a_z;
    float b_x;
    float b_y;
    float b_z;
    float c_x;
    float c_y;
    float c_z;
    uint32_t _res0;
    uint32_t _res1;
    uint32_t _res2;
    uint32_t _res3;
    uint32_t _res4;
    uint32_t _res5;

    modifier_volume(const uint32_t parameter_control_word,
                    const float a_x,
                    const float a_y,
                    const float a_z,
                    const float b_x,
                    const float b_y,
                    const float b_z,
                    const float c_x,
                    const float c_y,
                    const float c_z
                    )
      : parameter_control_word(parameter_control_word)
      , a_x(a_x)
      , a_y(a_y)
      , a_z(a_z)
      , b_x(b_x)
      , b_y(b_y)
      , b_z(b_z)
      , c_x(c_x)
      , c_y(c_y)
      , c_z(c_z)
      , _res0(0)
      , _res1(0)
      , _res2(0)
      , _res3(0)
      , _res4(0)
      , _res5(0)
    { }
  };
  static_assert((sizeof (modifier_volume)) == 64);
  static_assert((offsetof (struct modifier_volume, parameter_control_word)) == 0x00);
  static_assert((offsetof (struct modifier_volume, a_x)) == 0x04);
  static_assert((offsetof (struct modifier_volume, a_y)) == 0x08);
  static_assert((offsetof (struct modifier_volume, a_z)) == 0x0c);
  static_assert((offsetof (struct modifier_volume, b_x)) == 0x10);
  static_assert((offsetof (struct modifier_volume, b_y)) == 0x14);
  static_assert((offsetof (struct modifier_volume, b_z)) == 0x18);
  static_assert((offsetof (struct modifier_volume, c_x)) == 0x1c);
  static_assert((offsetof (struct modifier_volume, c_y)) == 0x20);
  static_assert((offsetof (struct modifier_volume, c_z)) == 0x24);
  static_assert((offsetof (struct modifier_volume, _res0)) == 0x28);
  static_assert((offsetof (struct modifier_volume, _res1)) == 0x2c);
  static_assert((offsetof (struct modifier_volume, _res2)) == 0x30);
  static_assert((offsetof (struct modifier_volume, _res3)) == 0x34);
  static_assert((offsetof (struct modifier_volume, _res4)) == 0x38);
  static_assert((offsetof (struct modifier_volume, _res5)) == 0x3c);

}

