#pragma once

#include <cstdint>
#include <cstddef>

namespace holly::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;
  };
  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;
  };
  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;
  };
  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;
  };
  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;
  };
  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;
  };
  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;
  };
  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;
  };
  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;
  };
  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;
  };
  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;
  };
  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;
  };
  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;
  };
  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;
  };
  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;
  };
  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;
  };
  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;
  };
  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;
  };
  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);

}